type_balancer 0.1.0 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9d017bcd987973e61c2cca2f30f3a968ebccc0604b7043e44fd7ca4aa22a57a2
-  data.tar.gz: 214815b85a1095b6c4b9b853c6154b3c919d4671db2c69a6730ca21dcad5c559
+  metadata.gz: f73ec86fddfda3cd22f19b0081824a8a488e1a47359976e32eb6b999074b92a3
+  data.tar.gz: f25f85b6caeeeb3a5f8012ae295b96ae02413e4b4342aba946438bbcbb9eb063
 SHA512:
-  metadata.gz: c8e8dd1cd9854f80d68a54475e13634bb2ca2e78350f9fe4994252a502bd7acd75d764f7a7c0bd779808ebf39ba496289efa50f8bc7a281391d9e11d3a8ab500
-  data.tar.gz: fbcec72c85c4480f6b035f07bc8f49311798b90dd14c6eaf8cf4a7054c8ec2e7ded4ef9d1dd08e9029a5ce2f698696054f9f96191fae5f88461ad5d303aa10c8
+  metadata.gz: c8895eea255feccab33cd33ba70d9bfb486a4ff9108ba1a828d1be72b501db1635cb35d5aab574298923533d1080c29d7b45a50bb8d1547ffdacfd882dc4d491
+  data.tar.gz: '09f755338981a1523cae4eddc3468b17d7693b9183e7039b7e81f1d24bd6beab29133d9d9a797487ea3745195f3f4e577311c89258b41fa237bd63cc3fb63cd2'

data/CHANGELOG.md

@@ -1,5 +1,39 @@
-## [Unreleased]
+# Changelog
 
-## [0.1.0] - 2025-03-29
+## [0.1.2] - 2024-04-11
 
-- Initial release
+- Re-release of 0.1.1 due to RubyGems.org publishing issue
+- No functional changes from 0.1.1
+
+## [0.1.1] - 2024-03-XX
+
+### Refactoring
+- Major refactoring of core components to follow SOLID principles:
+  - Extracted core functionality into separate modules for better separation of concerns
+  - Split balancer logic into `batch_processing`, `ratio_calculator`, and `type_extractor` modules
+  - Improved error handling and type management
+  - Enhanced position calculator with better edge case handling
+
+### Documentation
+- Added comprehensive project description and use cases to README
+- Updated performance metrics with accurate benchmarks
+- Improved contribution guidelines
+- Enhanced quality script documentation
+
+### Performance
+- Updated benchmark results showing significant improvements:
+  - Tiny collections (10 items): 6-10μs
+  - Small collections (100 items): 30-52μs
+  - Medium collections (1,000 items): 274-555μs
+  - Large collections (10,000 items): 2.4-4.5ms
+
+### Fixed
+- Position calculator edge cases and quality checks
+- RSpec test failures related to type extraction
+- Custom type order handling in balancer implementation
+
+## [0.1.0] - Initial Release
+
+- Initial release of TypeBalancer
+- Core functionality for balancing collections by type
+- Basic documentation and tests

data/Dockerfile

@@ -13,6 +13,9 @@ RUN apt-get update && apt-get install -y \
 
 # Install Rust if YJIT is enabled
 ARG ENABLE_YJIT=false
+ARG RUBY_YJIT_ENABLE=0
+ENV RUBY_YJIT_ENABLE=${RUBY_YJIT_ENABLE}
+
 RUN if [ "${ENABLE_YJIT}" = "true" ]; then \
     curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y; \
     fi
@@ -22,7 +25,6 @@ WORKDIR /app
 # Copy all necessary files for building the gem
 COPY Gemfile Gemfile.lock type_balancer.gemspec Rakefile ./
 COPY lib/ lib/
-COPY sig/ sig/
 COPY benchmark/ benchmark/
 
 # Initialize Git repository and stage files (needed for gemspec)

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    type_balancer (0.1.0)
+    type_balancer (0.1.3)
 
 GEM
   remote: https://rubygems.org/

data/README.md

@@ -2,12 +2,25 @@
 
 # TypeBalancer
 
-[![Gem Version](https://badge.fury.io/rb/type_balancer.svg)](https://badge.fury.io/rb/type_balancer)
+[![Gem Version](https://badge.fury.io/rb/type_balancer.svg)](https://rubygems.org/gems/type_balancer)
 [![CI](https://github.com/llwebconsulting/type_balancer/actions/workflows/ci.yml/badge.svg)](https://github.com/llwebconsulting/type_balancer/actions/workflows/ci.yml)
 [![Ruby Coverage](https://img.shields.io/badge/ruby--coverage-78.57%25-yellow.svg)](https://github.com/llwebconsulting/type_balancer/blob/main/coverage/index.html)
 [![MIT License](https://img.shields.io/badge/license-MIT-blue.svg)](LICENSE.txt)
 
-A Ruby gem for balancing and distributing items of different types across a sequence while maintaining optimal spacing.
+Imagine you have a collection of items—like blog posts—that each belong to a specific type: Articles, Images, and Videos. Typically, articles heavily outnumber the other types, which means users often have to scroll past dozens of articles before encountering a video or image. Not an ideal experience.
+
+TypeBalancer solves this by intelligently mixing your collection based on type. You simply pass it your collection and the name of the type field, and it ensures that Images and Videos are evenly distributed alongside Articles right at the top of your feed. This way, your users get a more varied and engaging experience from the moment they start scrolling.
+
+TypeBalancer is a sophisticated Ruby gem designed to solve the challenge of distributing different types of content across a sequence while maintaining optimal spacing and ratios. It's particularly useful for:
+
+- **Content Management Systems**: Ensure a balanced mix of content types (videos, articles, images) in feeds
+- **E-commerce**: Distribute different product categories evenly across search results
+- **News Feeds**: Balance different news categories while maintaining relevance
+- **Recommendation Systems**: Mix various content types while preserving user preferences
+
+The gem uses advanced distribution algorithms to ensure that items are not only balanced by type but also maintain optimal spacing, preventing clusters of similar content while respecting specified ratios.
+
+[View Documentation](docs/README.md) | [View Benchmark Results](docs/benchmarks/README.md)
 
 ## Installation
 
@@ -43,16 +56,70 @@ items = [
 balanced_items = TypeBalancer.balance(items, type_field: :type)
 ```
 
+## Balancing Collections with `TypeBalancer.balance`
+
+The primary method for balancing collections is `TypeBalancer.balance`. This method takes an array of items and distributes them by type, ensuring optimal spacing and respecting type ratios.
+
+**Basic Example:**
+
+```ruby
+items = [
+  { type: 'video', title: 'Video 1' },
+  { type: 'image', title: 'Image 1' },
+  { type: 'article', title: 'Article 1' },
+  # ...
+]
+balanced = TypeBalancer.balance(items, type_field: :type)
+# => [ { type: 'article', ... }, { type: 'image', ... }, { type: 'video', ... }, ... ]
+```
+
+**Custom Type Order:**
+
+You can specify a custom order for types using the `type_order` argument. This controls the priority of types in the balanced output.
+
+```ruby
+# Prioritize images, then videos, then articles
+balanced = TypeBalancer.balance(items, type_field: :type, type_order: %w[image video article])
+# => [ { type: 'image', ... }, { type: 'video', ... }, { type: 'article', ... }, ... ]
+```
+
+- `type_field`: The key to use for type extraction (default: `:type`).
+- `type_order`: An array of type names (as strings) specifying the desired order.
+
+For more advanced usage and options, see [Detailed Balance Method Documentation](docs/balance.md).
+
+## Calculating Positions Directly
+
+In addition to balancing collections, you can use `TypeBalancer.calculate_positions` to determine optimal positions for a given type or subset of items within a sequence. This is useful for advanced scenarios where you need fine-grained control over item placement.
+
+**Basic Example:**
+
+```ruby
+# Calculate positions for 3 items in a sequence of 10 slots
+positions = TypeBalancer.calculate_positions(total_count: 10, ratio: 0.3)
+# => [0, 5, 9]
+```
+
+**With Available Items:**
+
+```ruby
+# Restrict placement to specific slots
+positions = TypeBalancer.calculate_positions(total_count: 10, ratio: 0.5, available_items: [0, 1, 2])
+# => [0, 1, 2]
+```
+
+For more advanced usage and options, see [Detailed Position Calculation Documentation](docs/calculate_positions.md).
+
 ## Performance Characteristics
 
 TypeBalancer is designed to handle collections of varying sizes efficiently. Here are the current performance metrics:
 
-- Tiny collections (10 items): Microsecond-level processing (9-14μs)
-- Small collections (100 items): Sub-millisecond processing (~450-500μs)
-- Medium collections (1,000 items): Fast processing (~20-21ms)
-- Large collections (10,000 items): Efficient processing (~193-209ms)
+- Tiny collections (10 items): Microsecond-level processing (6-10μs)
+- Small collections (100 items): Sub-millisecond processing (30-52μs)
+- Medium collections (1,000 items): Fast processing (274-555μs)
+- Large collections (10,000 items): Efficient processing (2.4-4.5ms)
 
-Performance has been thoroughly tested across Ruby versions (3.2.8, 3.3.7, and 3.4.2). YJIT provides significant improvements for small datasets (up to 51% faster for tiny collections) with varying impact on larger datasets. For detailed benchmarks across Ruby versions and YJIT configurations, see our [benchmark documentation](docs/benchmarks/README.md).
+Performance has been thoroughly tested across Ruby versions (3.2.8, 3.3.7, and 3.4.2). YJIT provides significant improvements (40-89% faster) with the greatest impact on medium-sized datasets. For detailed benchmarks across Ruby versions and YJIT configurations, see our [benchmark documentation](docs/benchmarks/README.md).
 
 ### Recommendations
 
@@ -71,11 +138,64 @@ Performance has been thoroughly tested across Ruby versions (3.2.8, 3.3.7, and 3
 
 ## Development
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+After checking out the repo, run `bin/setup` to install dependencies. Then:
+
+1. Run `rake spec` to run the test suite
+2. Run `bundle exec ruby examples/quality.rb` to run the quality checks
+3. Run `rake rubocop` to check code style
+4. Run `bin/console` for an interactive prompt
+
+For more information about the gem, its features, and quality checks, see our [documentation](docs/README.md).
 
 ## Contributing
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/llwebconsulting/type_balancer. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/llwebconsulting/type_balancer/blob/main/CODE_OF_CONDUCT.md).
+We welcome contributions to TypeBalancer! Here's how you can help:
+
+1. **Fork the Repository**
+   - Visit the [TypeBalancer repository](https://github.com/llwebconsulting/type_balancer)
+   - Click the "Fork" button in the top right
+   - Clone your fork locally: `git clone git@github.com:your-username/type_balancer.git`
+
+2. **Create a Feature Branch**
+   ```bash
+   git checkout -b feature/your-feature-name
+   ```
+
+3. **Make Your Changes**
+   - Write tests for new functionality
+   - Ensure all tests pass: `rake spec`
+   - Run quality checks: `bundle exec ruby examples/quality.rb`
+   - Check code style: `rake rubocop`
+   - Update documentation as needed
+
+4. **Commit Your Changes**
+   ```bash
+   git commit -am 'feat: add some feature'
+   ```
+   Please follow [conventional commits](https://www.conventionalcommits.org/) for commit messages.
+
+5. **Push to Your Fork**
+   ```bash
+   git push origin feature/your-feature-name
+   ```
+
+6. **Create a Pull Request**
+   - Visit your fork on GitHub
+   - Click "New Pull Request"
+   - Ensure the base branch is `main`
+   - Provide a clear description of your changes
+   - Link any relevant issues
+
+### Pull Request Requirements
+- All CI checks must pass
+- Test coverage should be maintained or improved
+- Documentation should be updated as needed
+- Code should follow the project's style guide
+- Quality script should pass without new issues
+
+For more detailed information about our development process and tools:
+- [Documentation](docs/README.md)
+- [Benchmark Documentation](docs/benchmarks/README.md)
 
 ## License
 

data/Rakefile

@@ -66,36 +66,14 @@ task default: [:test_with_mocks, 'lint:all']
 
 # Benchmark tasks
 namespace :benchmark do
-  desc 'Run distributor benchmark comparing C extension vs Pure Ruby (without YJIT)'
-  task :distributor do
-    ruby 'benchmark/distributor_benchmark.rb'
+  desc 'Run end-to-end benchmarks'
+  task :end_to_end do
+    ruby 'benchmark/end_to_end_benchmark.rb'
   end
 
-  desc 'Run combined benchmark comparing full C vs Ruby implementations (without YJIT)'
-  task :combined do
-    ruby 'benchmark/combined_benchmark.rb'
-  end
-
-  desc 'Run all benchmarks (without YJIT)'
-  task all: %i[distributor combined]
-
-  namespace :yjit do
-    desc 'Run distributor benchmark comparing C extension vs Pure Ruby with YJIT enabled'
-    task :distributor do
-      ENV['RUBY_YJIT_ENABLE'] = '1'
-      ruby 'benchmark/distributor_benchmark.rb'
-    end
-
-    desc 'Run combined benchmark comparing full C vs Ruby implementations with YJIT enabled'
-    task :combined do
-      ENV['RUBY_YJIT_ENABLE'] = '1'
-      ruby 'benchmark/combined_benchmark.rb'
-    end
-
-    desc 'Run all benchmarks with YJIT enabled'
-    task all: %i[distributor combined]
-  end
+  desc 'Run all benchmarks'
+  task all: [:end_to_end]
 
-  desc 'Run all benchmarks with and without YJIT'
-  task complete: %i[all yjit:all]
+  desc 'Run complete benchmark suite'
+  task complete: [:all]
 end

data/benchmark/end_to_end_benchmark.rb

@@ -22,7 +22,7 @@ def generate_test_data(size)
   end
 end
 
-# More granular test cases
+# Test cases with different dataset sizes
 TEST_CASES = [
   { name: "Tiny Dataset", size: 10 },
   { name: "Small Dataset", size: 100 },
@@ -32,6 +32,7 @@ TEST_CASES = [
 
 def run_benchmark
   puts "\nRunning benchmarks..."
+  types = %w[video image article]
 
   TEST_CASES.each do |test_case|
     puts "\nBenchmarking #{test_case[:name]} (#{test_case[:size]} items)"
@@ -54,9 +55,11 @@ def run_benchmark
 
     # Print distribution stats for verification
     result = TypeBalancer.balance(collection, type_field: :type)
+    # Flatten batches into a single array
+    flattened_result = result.flatten
     puts "\nDistribution Stats:"
-    %w[video image article].each do |type|
-      count = result.count { |i| i[:type] == type }
+    types.each do |type|
+      count = flattened_result.count { |i| i[:type] == type }
       puts "#{type.capitalize}: #{count} (#{(count.to_f / test_case[:size] * 100).round(2)}%)"
     end
   end

data/benchmark_results/ruby3.2.8.txt

@@ -9,9 +9,9 @@ Running benchmarks...
 Benchmarking Tiny Dataset (10 items)
 ruby 3.2.8 (2025-03-26 revision 13f495dc2c) [aarch64-linux]
 Warming up --------------------------------------
- Ruby Implementation     5.815k i/100ms
+ Ruby Implementation    12.737k i/100ms
 Calculating -------------------------------------
- Ruby Implementation     70.626k (± 8.1%) i/s   (14.16 μs/i) -    145.375k in   2.072857s
+ Ruby Implementation    126.497k (± 9.6%) i/s    (7.91 μs/i) -    254.740k in   2.033633s
 
 Distribution Stats:
 Video: 4 (40.0%)
@@ -21,9 +21,9 @@ Article: 3 (30.0%)
 Benchmarking Small Dataset (100 items)
 ruby 3.2.8 (2025-03-26 revision 13f495dc2c) [aarch64-linux]
 Warming up --------------------------------------
- Ruby Implementation   179.000 i/100ms
+ Ruby Implementation     2.261k i/100ms
 Calculating -------------------------------------
- Ruby Implementation      1.904k (± 4.8%) i/s  (525.33 μs/i) -      3.938k in   2.073542s
+ Ruby Implementation     23.642k (± 9.3%) i/s   (42.30 μs/i) -     47.481k in   2.025722s
 
 Distribution Stats:
 Video: 34 (34.0%)
@@ -33,9 +33,9 @@ Article: 33 (33.0%)
 Benchmarking Medium Dataset (1000 items)
 ruby 3.2.8 (2025-03-26 revision 13f495dc2c) [aarch64-linux]
 Warming up --------------------------------------
- Ruby Implementation     1.000 i/100ms
+ Ruby Implementation   248.000 i/100ms
 Calculating -------------------------------------
- Ruby Implementation     20.785 (± 9.6%) i/s   (48.11 ms/i) -     62.000 in   3.018630s
+ Ruby Implementation      2.417k (±19.4%) i/s  (413.65 μs/i) -      6.944k in   3.022707s
 
 Distribution Stats:
 Video: 334 (33.4%)
@@ -45,9 +45,9 @@ Article: 333 (33.3%)
 Benchmarking Large Dataset (10000 items)
 ruby 3.2.8 (2025-03-26 revision 13f495dc2c) [aarch64-linux]
 Warming up --------------------------------------
- Ruby Implementation     1.000 i/100ms
+ Ruby Implementation    28.000 i/100ms
 Calculating -------------------------------------
- Ruby Implementation      0.229 (± 0.0%) i/s     (4.37 s/i) -      1.000 in   4.371704s
+ Ruby Implementation    267.855 (±12.7%) i/s    (3.73 ms/i) -    812.000 in   3.093948s
 
 Distribution Stats:
 Video: 3334 (33.34%)

data/benchmark_results/ruby3.2.8_yjit.txt

@@ -2,16 +2,16 @@
 + bundle exec ruby -I lib benchmark/end_to_end_benchmark.rb
 Ruby version: 3.2.8
 RUBY_PLATFORM: aarch64-linux
-YJIT enabled: false
+YJIT enabled: true
 
 Running benchmarks...
 
 Benchmarking Tiny Dataset (10 items)
-ruby 3.2.8 (2025-03-26 revision 13f495dc2c) [aarch64-linux]
+ruby 3.2.8 (2025-03-26 revision 13f495dc2c) +YJIT [aarch64-linux]
 Warming up --------------------------------------
- Ruby Implementation     8.136k i/100ms
+ Ruby Implementation    14.779k i/100ms
 Calculating -------------------------------------
- Ruby Implementation     74.212k (± 6.1%) i/s   (13.47 μs/i) -    154.584k in   2.090755s
+ Ruby Implementation    157.751k (±10.4%) i/s    (6.34 μs/i) -    325.138k in   2.085954s
 
 Distribution Stats:
 Video: 4 (40.0%)
@@ -19,11 +19,11 @@ Image: 3 (30.0%)
 Article: 3 (30.0%)
 
 Benchmarking Small Dataset (100 items)
-ruby 3.2.8 (2025-03-26 revision 13f495dc2c) [aarch64-linux]
+ruby 3.2.8 (2025-03-26 revision 13f495dc2c) +YJIT [aarch64-linux]
 Warming up --------------------------------------
- Ruby Implementation   181.000 i/100ms
+ Ruby Implementation     2.795k i/100ms
 Calculating -------------------------------------
- Ruby Implementation      1.934k (± 4.9%) i/s  (517.12 μs/i) -      3.982k in   2.064193s
+ Ruby Implementation     30.774k (± 7.0%) i/s   (32.50 μs/i) -     61.490k in   2.007908s
 
 Distribution Stats:
 Video: 34 (34.0%)
@@ -31,11 +31,11 @@ Image: 33 (33.0%)
 Article: 33 (33.0%)
 
 Benchmarking Medium Dataset (1000 items)
-ruby 3.2.8 (2025-03-26 revision 13f495dc2c) [aarch64-linux]
+ruby 3.2.8 (2025-03-26 revision 13f495dc2c) +YJIT [aarch64-linux]
 Warming up --------------------------------------
- Ruby Implementation     1.000 i/100ms
+ Ruby Implementation   321.000 i/100ms
 Calculating -------------------------------------
- Ruby Implementation     18.611 (±16.1%) i/s   (53.73 ms/i) -     54.000 in   3.010201s
+ Ruby Implementation      2.931k (±18.8%) i/s  (341.19 μs/i) -      8.667k in   3.086876s
 
 Distribution Stats:
 Video: 334 (33.4%)
@@ -43,11 +43,11 @@ Image: 333 (33.3%)
 Article: 333 (33.3%)
 
 Benchmarking Large Dataset (10000 items)
-ruby 3.2.8 (2025-03-26 revision 13f495dc2c) [aarch64-linux]
+ruby 3.2.8 (2025-03-26 revision 13f495dc2c) +YJIT [aarch64-linux]
 Warming up --------------------------------------
- Ruby Implementation     1.000 i/100ms
+ Ruby Implementation    35.000 i/100ms
 Calculating -------------------------------------
- Ruby Implementation      0.227 (± 0.0%) i/s     (4.41 s/i) -      1.000 in   4.405356s
+ Ruby Implementation    356.223 (±12.4%) i/s    (2.81 ms/i) -      1.050k in   3.028643s
 
 Distribution Stats:
 Video: 3334 (33.34%)

data/benchmark_results/ruby3.3.7.txt

@@ -9,9 +9,9 @@ Running benchmarks...
 Benchmarking Tiny Dataset (10 items)
 ruby 3.3.7 (2025-01-15 revision be31f993d7) [aarch64-linux]
 Warming up --------------------------------------
- Ruby Implementation     6.917k i/100ms
+ Ruby Implementation    11.284k i/100ms
 Calculating -------------------------------------
- Ruby Implementation     66.848k (± 4.7%) i/s   (14.96 μs/i) -    138.340k in   2.074218s
+ Ruby Implementation    126.984k (± 6.9%) i/s    (7.87 μs/i) -    259.532k in   2.054088s
 
 Distribution Stats:
 Video: 4 (40.0%)
@@ -21,9 +21,9 @@ Article: 3 (30.0%)
 Benchmarking Small Dataset (100 items)
 ruby 3.3.7 (2025-01-15 revision be31f993d7) [aarch64-linux]
 Warming up --------------------------------------
- Ruby Implementation   174.000 i/100ms
+ Ruby Implementation   749.000 i/100ms
 Calculating -------------------------------------
- Ruby Implementation      1.897k (± 4.5%) i/s  (527.03 μs/i) -      3.828k in   2.021687s
+ Ruby Implementation     19.547k (±15.9%) i/s   (51.16 μs/i) -     38.199k in   2.007898s
 
 Distribution Stats:
 Video: 34 (34.0%)
@@ -33,9 +33,9 @@ Article: 33 (33.0%)
 Benchmarking Medium Dataset (1000 items)
 ruby 3.3.7 (2025-01-15 revision be31f993d7) [aarch64-linux]
 Warming up --------------------------------------
- Ruby Implementation     2.000 i/100ms
+ Ruby Implementation   205.000 i/100ms
 Calculating -------------------------------------
- Ruby Implementation     19.511 (±10.3%) i/s   (51.25 ms/i) -     58.000 in   3.018480s
+ Ruby Implementation      2.299k (± 9.3%) i/s  (434.98 μs/i) -      6.970k in   3.064546s
 
 Distribution Stats:
 Video: 334 (33.4%)
@@ -45,9 +45,9 @@ Article: 333 (33.3%)
 Benchmarking Large Dataset (10000 items)
 ruby 3.3.7 (2025-01-15 revision be31f993d7) [aarch64-linux]
 Warming up --------------------------------------
- Ruby Implementation     1.000 i/100ms
+ Ruby Implementation    27.000 i/100ms
 Calculating -------------------------------------
- Ruby Implementation      0.224 (± 0.0%) i/s     (4.46 s/i) -      1.000 in   4.464788s
+ Ruby Implementation    271.425 (± 4.8%) i/s    (3.68 ms/i) -    837.000 in   3.091882s
 
 Distribution Stats:
 Video: 3334 (33.34%)

data/benchmark_results/ruby3.3.7_yjit.txt

@@ -2,16 +2,16 @@
 + bundle exec ruby -I lib benchmark/end_to_end_benchmark.rb
 Ruby version: 3.3.7
 RUBY_PLATFORM: aarch64-linux
-YJIT enabled: false
+YJIT enabled: true
 
 Running benchmarks...
 
 Benchmarking Tiny Dataset (10 items)
-ruby 3.3.7 (2025-01-15 revision be31f993d7) [aarch64-linux]
+ruby 3.3.7 (2025-01-15 revision be31f993d7) +YJIT [aarch64-linux]
 Warming up --------------------------------------
- Ruby Implementation     6.343k i/100ms
+ Ruby Implementation    15.811k i/100ms
 Calculating -------------------------------------
- Ruby Implementation     66.941k (± 6.0%) i/s   (14.94 μs/i) -    139.546k in   2.092006s
+ Ruby Implementation    176.585k (±10.2%) i/s    (5.66 μs/i) -    363.653k in   2.084636s
 
 Distribution Stats:
 Video: 4 (40.0%)
@@ -19,11 +19,11 @@ Image: 3 (30.0%)
 Article: 3 (30.0%)
 
 Benchmarking Small Dataset (100 items)
-ruby 3.3.7 (2025-01-15 revision be31f993d7) [aarch64-linux]
+ruby 3.3.7 (2025-01-15 revision be31f993d7) +YJIT [aarch64-linux]
 Warming up --------------------------------------
- Ruby Implementation   175.000 i/100ms
+ Ruby Implementation     2.755k i/100ms
 Calculating -------------------------------------
- Ruby Implementation      1.888k (± 5.1%) i/s  (529.71 μs/i) -      3.850k in   2.044860s
+ Ruby Implementation     29.060k (± 8.7%) i/s   (34.41 μs/i) -     57.855k in   2.007501s
 
 Distribution Stats:
 Video: 34 (34.0%)
@@ -31,11 +31,11 @@ Image: 33 (33.0%)
 Article: 33 (33.0%)
 
 Benchmarking Medium Dataset (1000 items)
-ruby 3.3.7 (2025-01-15 revision be31f993d7) [aarch64-linux]
+ruby 3.3.7 (2025-01-15 revision be31f993d7) +YJIT [aarch64-linux]
 Warming up --------------------------------------
- Ruby Implementation     1.000 i/100ms
+ Ruby Implementation   328.000 i/100ms
 Calculating -------------------------------------
- Ruby Implementation     19.923 (±15.1%) i/s   (50.19 ms/i) -     59.000 in   3.031767s
+ Ruby Implementation      3.619k (±10.0%) i/s  (276.35 μs/i) -     10.824k in   3.027879s
 
 Distribution Stats:
 Video: 334 (33.4%)
@@ -43,11 +43,11 @@ Image: 333 (33.3%)
 Article: 333 (33.3%)
 
 Benchmarking Large Dataset (10000 items)
-ruby 3.3.7 (2025-01-15 revision be31f993d7) [aarch64-linux]
+ruby 3.3.7 (2025-01-15 revision be31f993d7) +YJIT [aarch64-linux]
 Warming up --------------------------------------
- Ruby Implementation     1.000 i/100ms
+ Ruby Implementation    40.000 i/100ms
 Calculating -------------------------------------
- Ruby Implementation      0.224 (± 0.0%) i/s     (4.47 s/i) -      1.000 in   4.467441s
+ Ruby Implementation    394.097 (± 4.8%) i/s    (2.54 ms/i) -      1.200k in   3.053424s
 
 Distribution Stats:
 Video: 3334 (33.34%)

data/benchmark_results/ruby3.4.2.txt

@@ -9,9 +9,9 @@ Running benchmarks...
 Benchmarking Tiny Dataset (10 items)
 ruby 3.4.2 (2025-02-15 revision d2930f8e7a) +PRISM [aarch64-linux]
 Warming up --------------------------------------
- Ruby Implementation     6.476k i/100ms
+ Ruby Implementation    11.805k i/100ms
 Calculating -------------------------------------
- Ruby Implementation     66.552k (± 5.7%) i/s   (15.03 μs/i) -    135.996k in   2.050038s
+ Ruby Implementation    108.979k (±11.4%) i/s    (9.18 μs/i) -    224.295k in   2.082118s
 
 Distribution Stats:
 Video: 4 (40.0%)
@@ -21,9 +21,9 @@ Article: 3 (30.0%)
 Benchmarking Small Dataset (100 items)
 ruby 3.4.2 (2025-02-15 revision d2930f8e7a) +PRISM [aarch64-linux]
 Warming up --------------------------------------
- Ruby Implementation   168.000 i/100ms
+ Ruby Implementation     1.992k i/100ms
 Calculating -------------------------------------
- Ruby Implementation      1.790k (± 5.2%) i/s  (558.74 μs/i) -      3.696k in   2.070989s
+ Ruby Implementation     21.879k (± 6.7%) i/s   (45.71 μs/i) -     43.824k in   2.011722s
 
 Distribution Stats:
 Video: 34 (34.0%)
@@ -33,9 +33,9 @@ Article: 33 (33.0%)
 Benchmarking Medium Dataset (1000 items)
 ruby 3.4.2 (2025-02-15 revision d2930f8e7a) +PRISM [aarch64-linux]
 Warming up --------------------------------------
- Ruby Implementation     1.000 i/100ms
+ Ruby Implementation   248.000 i/100ms
 Calculating -------------------------------------
- Ruby Implementation     19.043 (±10.5%) i/s   (52.51 ms/i) -     57.000 in   3.042588s
+ Ruby Implementation      2.004k (±25.1%) i/s  (498.96 μs/i) -      5.704k in   3.120598s
 
 Distribution Stats:
 Video: 334 (33.4%)
@@ -45,9 +45,9 @@ Article: 333 (33.3%)
 Benchmarking Large Dataset (10000 items)
 ruby 3.4.2 (2025-02-15 revision d2930f8e7a) +PRISM [aarch64-linux]
 Warming up --------------------------------------
- Ruby Implementation     1.000 i/100ms
+ Ruby Implementation    17.000 i/100ms
 Calculating -------------------------------------
- Ruby Implementation      0.212 (± 0.0%) i/s     (4.71 s/i) -      1.000 in   4.711867s
+ Ruby Implementation    264.183 (±10.6%) i/s    (3.79 ms/i) -    782.000 in   3.006879s
 
 Distribution Stats:
 Video: 3334 (33.34%)