irt_ruby 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3864e3faec7cbf0a1d96649b1493a843df0fcb029a2106b99e682f1770b9f499
-  data.tar.gz: e6901babf0c08c5de4e8d644ee4c5e8607f1213a965864874455af2e1ea5ead5
+  metadata.gz: 7c8164ec4d62622374ff79fa5110baf742d68544719088c9dcae2e8851838895
+  data.tar.gz: 973555d52fd8bef2cd912d2890222d3089af65e127336c4332b2ff1f5afe9638
 SHA512:
-  metadata.gz: 519eb1b5d1e5c74234482b83d72faacb85445b5259860278512a49f3212ce62840a8db8c801d6873be377b7b6cf808693af4456185bf2a64a679b20b6f21a33b
-  data.tar.gz: c6f4d4e13582c15045bc040815f88c5d07562ecbb1554daccd6ea6383462ff7c56f3c0adeecc8c4eb29f800faf865a896f0edba4a80979f35c5d46fd897ba72d
+  metadata.gz: 4d193d94c2ee5b365337e26efe6efe7dc8c48b08e1d3e1f1043f0c7d360634f2ed79ec0a5c72f094482056adc15f2ec867f5798d8fdd84a3a39db348d8e98282
+  data.tar.gz: 6e8ef3b3c8d9d8e4e4de7783f0c39bada144a72e542de180a36f9b7f5a1f6d9d7860d4d2235a03e6936ed4776816fae5ed2144e261e415b9b033cd51ca3859f8

data/CHANGELOG.md

@@ -0,0 +1,50 @@
+# Changelog
+
+All notable changes to this project are documented in this file.
+
+## [0.3.0] - 2025-01-14
+
+### Changed
+- **Code Quality**
+  - Updated RuboCop configuration to handle new cops and resolve style warnings
+  - Fixed operator precedence ambiguity in Three-Parameter Model calculations
+  - Added MFA requirement to gemspec metadata (RuboCop requirement)
+
+### Notes
+- This release maintains **full backward compatibility** with previous versions
+- All 46 existing tests continue to pass
+- Comprehensive performance benchmarking suite remains available via `bundle exec rake benchmark:all`
+
+---
+
+## [0.2.0] - 2025-03-01
+
+### Added
+- **Missing Data Strategies**
+    - Introduced a `missing_strategy` parameter for **Rasch**, **TwoParameterModel**, and **ThreeParameterModel** to handle `nil` responses:
+        - `:ignore` (default) – skip missing responses in log-likelihood and gradients.
+        - `:treat_as_incorrect` – interpret `nil` as `0`.
+        - `:treat_as_correct` – interpret `nil` as `1`.
+    - Updated RSpec tests to cover each strategy and ensure graceful handling of missing responses.
+
+- **Expanded Test Coverage**
+    - Added tests for repeated fits, deterministic seeding, larger random datasets, and new edge cases (all-correct/all-incorrect).
+    - Improved specs for parameter clamping (discriminations, guessing in 2PL/3PL).
+
+- **Adaptive Learning Rate Enhancements**
+    - Enhanced convergence checks combining log-likelihood changes and average parameter updates.
+    - Clearer revert-and-decay logic if the likelihood decreases on a given step.
+
+### Changed
+- **Documentation / README**
+    - Updated the README to reflect new missing data strategies, advanced usage (adaptive learning rate, parameter clamping), and test instructions.
+    - Added examples showcasing how to set `missing_strategy` for each model.
+
+### Notes
+- This release remains **backward-compatible** with `0.1.x` in terms of existing usage; the default `:ignore` missing-data approach matches prior behavior.
+- If upgrading, simply update your gem and enjoy the new features.
+- For more details, see the updated [README](./README.md) and expanded test suites.
+
+---
+
+*(If you have older versions below `0.2.0`, you can keep them documented similarly, e.g., `## [0.1.x] ...`, under this new entry.)*

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2024 Alex Kholodniak
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,168 @@
+# IrtRuby
+
+IrtRuby is a Ruby gem that provides implementations of the **Rasch model**, the **Two-Parameter (2PL)** model, and the **Three-Parameter (3PL)** model for Item Response Theory (IRT). It allows you to estimate the **abilities** of individuals and the **difficulties** (and optionally **discriminations** and **guessing** parameters) of items based on their responses.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'irt_ruby'
+```
+
+And then execute:
+
+```bash
+bundle install
+```
+
+Or install it yourself as:
+
+```bash
+gem install irt_ruby
+```
+
+## Usage
+
+Here's a quick example using the Rasch model:
+
+```ruby
+require 'irt_ruby'
+require 'matrix'
+
+# Create a sample response matrix
+data = Matrix[
+  [1, 0, 1],
+  [0, 1, 0],
+  [1, 1, 1]
+]
+
+# Initialize the Rasch model with the response data
+model = IrtRuby::RaschModel.new(data)
+
+# Fit the model to estimate abilities and difficulties
+result = model.fit
+
+# Output the estimated abilities and difficulties
+puts "Abilities:    #{result[:abilities]}"
+puts "Difficulties: #{result[:difficulties]}"
+```
+### Using 2PL and 3PL Models
+```ruby
+two_pl_model = IrtRuby::TwoParameterModel.new(data)
+two_pl_result = two_pl_model.fit
+puts two_pl_result[:abilities]
+puts two_pl_result[:difficulties]
+puts two_pl_result[:discriminations]
+
+three_pl_model = IrtRuby::ThreeParameterModel.new(data)
+three_pl_result = three_pl_model.fit
+puts three_pl_result[:abilities]
+puts three_pl_result[:difficulties]
+puts three_pl_result[:discriminations]
+puts three_pl_result[:guessings]
+```
+
+## Handling Missing Data
+Real-world data often has missing responses. Each model (Rasch, 2PL, 3PL) accepts a `missing_strategy: option` to handle nil entries:
+
+- `:ignore` (default): Skip `nil` responses entirely in the log-likelihood and gradient calculations.
+- `:treat_as_incorrect`: Interpret `nil` as `0`.
+- `:treat_as_correct`: Interpret `nil` as `1`.
+
+For example:
+```ruby
+data_with_missing = [
+  [1, nil, 0],
+  [nil, 1,  0],
+  [0,  1,  1]
+]
+
+model = IrtRuby::RaschModel.new(
+  data_with_missing,
+  max_iter: 300,
+  learning_rate: 0.01,
+  missing_strategy: :treat_as_incorrect
+)
+result = model.fit
+
+puts "Abilities:    #{result[:abilities]}"
+puts "Difficulties: #{result[:difficulties]}"
+```
+This flexibility helps you handle datasets where missingness might signify a skipped item or an unanswered question.
+
+## Advanced Usage
+
+### Adaptive Learning Rate & Convergence
+By default, each model uses a gradient ascent with:
+
+- An adaptive learning rate (if log-likelihood decreases, it reverts the step and reduces the rate).
+- Multiple convergence checks (change in log-likelihood and average parameter updates).
+
+You can customize:
+
+- `max_iter`: The maximum number of iterations.
+- `tolerance` and `param_tolerance`: Convergence thresholds for log-likelihood change and parameter updates.
+- `learning_rate`: Initial learning rate.
+- `decay_factor`: Factor by which the learning rate is reduced on a failed step.
+
+Example:
+```ruby
+IrtRuby::TwoParameterModel.new(
+  data,
+  max_iter: 500,
+  tolerance: 1e-7,
+  param_tolerance: 1e-7,
+  learning_rate: 0.05,
+  decay_factor: 0.5
+)
+```
+### Parameter Clamping
+For 2PL and 3PL:
+
+- **Discriminations** (`a`) are clamped between `0.01` and `5.0`.
+- **Guessings** (`c`, 3PL only) are clamped to `[0.0, 0.35]`.
+
+This prevents extreme or invalid parameter estimates.
+
+## Performance Benchmarks
+
+IRT Ruby includes comprehensive performance benchmarks to help you understand the computational characteristics of different models:
+
+```bash
+# Run all benchmarks (takes 8-15 minutes)
+bundle exec rake benchmark:all
+
+# Quick performance check (2-3 minutes)
+bundle exec rake benchmark:quick
+
+# Individual benchmark suites
+bundle exec rake benchmark:performance
+bundle exec rake benchmark:convergence
+```
+
+The benchmarks test:
+- **Performance**: Execution speed across dataset sizes (50 to 100,000 data points)
+- **Memory Usage**: Object allocation and memory efficiency
+- **Scaling**: How computational complexity grows with data size
+- **Convergence**: Optimization behavior under different conditions
+
+See `benchmarks/README.md` for detailed information about interpreting results.
+
+## 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.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/SyntaxSpirits/irt_ruby. 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/SyntaxSpirits/irt_ruby/blob/main/CODE_OF_CONDUCT.md).
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+
+## Code of Conduct
+
+Everyone interacting in the IrtRuby project's codebases, issue trackers, chat rooms, and mailing lists is expected to follow the [code of conduct](https://github.com/SyntaxSpirits/irt_ruby/blob/main/CODE_OF_CONDUCT.md).

data/benchmarks/README.md

@@ -0,0 +1,135 @@
+# IRT Ruby Performance Benchmarks
+
+This directory contains comprehensive performance benchmarks for the IRT Ruby gem, helping users understand the computational characteristics and scaling behavior of the different IRT models.
+
+## Available Benchmarks
+
+### 1. Performance Benchmark (`performance_benchmark.rb`)
+
+**Purpose**: Comprehensive performance analysis across different dataset sizes and model types.
+
+**What it measures**:
+- Execution time (iterations per second) for Rasch, 2PL, and 3PL models
+- Memory usage analysis (allocated/retained objects and memory)
+- Scaling behavior analysis (how performance changes with dataset size)
+- Impact of missing data strategies on performance
+
+**Dataset sizes tested**:
+- Tiny: 10 people × 5 items (50 data points)
+- Small: 50 people × 20 items (1,000 data points)
+- Medium: 100 people × 50 items (5,000 data points)
+- Large: 200 people × 100 items (20,000 data points)
+- XLarge: 500 people × 200 items (100,000 data points)
+
+### 2. Convergence Benchmark (`convergence_benchmark.rb`)
+
+**Purpose**: Detailed analysis of convergence behavior and optimization characteristics.
+
+**What it measures**:
+- Impact of tolerance settings on convergence time and success rate
+- Learning rate optimization analysis
+- Dataset characteristics impact on convergence
+- Missing data pattern effects on convergence
+
+**Key insights provided**:
+- Optimal hyperparameter settings for different scenarios
+- Convergence reliability across different conditions
+- Trade-offs between speed and accuracy
+
+## Running the Benchmarks
+
+### Prerequisites
+
+Install benchmark dependencies:
+```bash
+bundle install
+```
+
+### Running Individual Benchmarks
+
+```bash
+# Full performance benchmark suite (takes 5-10 minutes)
+ruby benchmarks/performance_benchmark.rb
+
+# Convergence analysis (takes 3-5 minutes)
+ruby benchmarks/convergence_benchmark.rb
+```
+
+### Running All Benchmarks
+
+```bash
+# Run both benchmark suites
+ruby benchmarks/performance_benchmark.rb && ruby benchmarks/convergence_benchmark.rb
+```
+
+## Understanding the Results
+
+### Performance Benchmark Output
+
+1. **Iterations per Second (IPS)**: Higher is better
+   - Shows relative speed between Rasch, 2PL, and 3PL models
+   - Includes confidence intervals and comparison ratios
+
+2. **Memory Usage**:
+   - Total allocated: Memory used during computation
+   - Total retained: Memory still held after computation
+   - Object counts: Number of Ruby objects created
+
+3. **Scaling Analysis**:
+   - Shows computational complexity (O(n^x))
+   - Helps predict performance for larger datasets
+
+### Convergence Benchmark Output
+
+1. **Convergence Rate**: Percentage of runs that converged within tolerance
+2. **Average Iterations**: Typical number of iterations needed
+3. **Time**: Wall-clock time to convergence
+
+## Interpreting Results for Your Use Case
+
+### For Educational Assessment (typical: 100-1000 students, 20-100 items)
+- Focus on Medium to Large dataset results
+- Rasch model typically fastest, 3PL slowest but most flexible
+- Missing data strategies have < 10% performance impact
+
+### For Psychological Testing (typical: 50-500 participants, 10-50 items)
+- Focus on Small to Medium dataset results
+- All models should complete in < 1 second
+- Consider convergence reliability for different tolerance settings
+
+### For Large-Scale Analysis (1000+ participants)
+- Review XLarge dataset results and scaling analysis
+- Consider batching or parallel processing for very large datasets
+- Monitor memory usage to avoid system limits
+
+## Customizing Benchmarks
+
+You can modify the benchmark scripts to test your specific scenarios:
+
+1. **Custom Dataset Sizes**: Edit `DATASET_CONFIGS` array
+2. **Different Hyperparameters**: Modify tolerance, learning rate configs
+3. **Specific Missing Data Patterns**: Adjust missing data generation
+4. **Model-Specific Tests**: Focus on particular IRT models
+
+## Performance Tips
+
+Based on benchmark results:
+
+1. **Choose the Right Model**: Rasch is fastest, use 2PL/3PL only when needed
+2. **Optimize Tolerance**: `1e-5` typically good balance of speed/accuracy
+3. **Adjust Learning Rate**: Start with `0.01`, increase for faster convergence
+4. **Handle Missing Data**: `:ignore` strategy typically fastest
+5. **Consider Iteration Limits**: 100-500 iterations usually sufficient
+
+## Comparing with Other IRT Libraries
+
+These benchmarks can help you compare IRT Ruby against other implementations. Key metrics to compare:
+
+- Time per data point processed
+- Memory efficiency
+- Convergence reliability
+- Scaling behavior with dataset size
+
+---
+
+*Note: Benchmark results will vary based on your hardware. Run benchmarks on your target deployment environment for most accurate performance estimates.* 

data/benchmarks/convergence_benchmark.rb

@@ -0,0 +1,265 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require "bundler/setup"
+require "irt_ruby"
+require "benchmark"
+
+# Enhanced model classes that track iterations and convergence
+class TrackedRaschModel < IrtRuby::RaschModel
+  attr_reader :iterations, :final_log_likelihood, :convergence_reason
+
+  def fit
+    @iterations = 0
+    prev_ll = log_likelihood
+    @final_log_likelihood = prev_ll
+    @convergence_reason = :max_iterations
+
+    @max_iter.times do
+      @iterations += 1
+      grad_abilities, grad_difficulties = compute_gradient
+
+      old_a, old_d = apply_gradient_update(grad_abilities, grad_difficulties)
+
+      current_ll = log_likelihood
+      param_delta = average_param_update(old_a, old_d)
+
+      if current_ll < prev_ll
+        @abilities = old_a
+        @difficulties = old_d
+        @learning_rate *= @decay_factor
+      else
+        ll_diff = (current_ll - prev_ll).abs
+        @final_log_likelihood = current_ll
+
+        if ll_diff < @tolerance && param_delta < @param_tolerance
+          @convergence_reason = :tolerance_reached
+          break
+        end
+
+        prev_ll = current_ll
+      end
+    end
+
+    { abilities: @abilities, difficulties: @difficulties }
+  end
+end
+
+def generate_data(num_people, num_items, difficulty_range: (-2..2), ability_range: (-2..2))
+  # Generate realistic IRT data based on known parameters
+  true_abilities = Array.new(num_people) { rand(ability_range) }
+  true_difficulties = Array.new(num_items) { rand(difficulty_range) }
+
+  data = Array.new(num_people) do |person|
+    Array.new(num_items) do |item|
+      prob = 1.0 / (1.0 + Math.exp(-(true_abilities[person] - true_difficulties[item])))
+      rand < prob ? 1 : 0
+    end
+  end
+
+  { data: data, true_abilities: true_abilities, true_difficulties: true_difficulties }
+end
+
+puts "=" * 70
+puts "IRT Ruby Convergence Analysis"
+puts "=" * 70
+puts
+
+# Test convergence with different tolerance settings
+tolerance_configs = [
+  { tolerance: 1e-3, param_tolerance: 1e-3, label: "Loose (1e-3)" },
+  { tolerance: 1e-4, param_tolerance: 1e-4, label: "Medium (1e-4)" },
+  { tolerance: 1e-5, param_tolerance: 1e-5, label: "Tight (1e-5)" },
+  { tolerance: 1e-6, param_tolerance: 1e-6, label: "Very Tight (1e-6)" }
+]
+
+dataset = generate_data(100, 50)
+data = dataset[:data]
+
+puts "Convergence Analysis - Impact of Tolerance Settings"
+puts "-" * 50
+
+tolerance_configs.each do |config|
+  puts "\nTolerance: #{config[:label]}"
+
+  times = []
+  iterations = []
+  convergence_reasons = []
+
+  5.times do
+    time = Benchmark.measure do
+      model = TrackedRaschModel.new(
+        data,
+        max_iter: 2000,
+        tolerance: config[:tolerance],
+        param_tolerance: config[:param_tolerance],
+        learning_rate: 0.01
+      )
+      model.fit
+      iterations << model.iterations
+      convergence_reasons << model.convergence_reason
+    end.real
+    times << time
+  end
+
+  avg_time = times.sum / times.size
+  avg_iterations = iterations.sum.to_f / iterations.size
+  convergence_rate = convergence_reasons.count(:tolerance_reached) / 5.0
+
+  printf("  Time: %6.3fs  Iterations: %6.1f  Convergence Rate: %4.0f%%\n",
+         avg_time, avg_iterations, convergence_rate * 100)
+end
+
+# Test convergence with different learning rates
+puts "\n#{"=" * 70}"
+puts "Learning Rate Impact Analysis"
+puts "-" * 50
+
+learning_rate_configs = [
+  { rate: 0.001, label: "Very Slow (0.001)" },
+  { rate: 0.01, label: "Slow (0.01)" },
+  { rate: 0.05, label: "Medium (0.05)" },
+  { rate: 0.1, label: "Fast (0.1)" },
+  { rate: 0.2, label: "Very Fast (0.2)" }
+]
+
+learning_rate_configs.each do |config|
+  puts "\nLearning Rate: #{config[:label]}"
+
+  times = []
+  iterations = []
+  convergence_reasons = []
+
+  5.times do
+    time = Benchmark.measure do
+      model = TrackedRaschModel.new(
+        data,
+        max_iter: 1000,
+        tolerance: 1e-5,
+        param_tolerance: 1e-5,
+        learning_rate: config[:rate]
+      )
+      model.fit
+      iterations << model.iterations
+      convergence_reasons << model.convergence_reason
+    end.real
+    times << time
+  end
+
+  avg_time = times.sum / times.size
+  avg_iterations = iterations.sum.to_f / iterations.size
+  convergence_rate = convergence_reasons.count(:tolerance_reached) / 5.0
+
+  printf("  Time: %6.3fs  Iterations: %6.1f  Convergence Rate: %4.0f%%\n",
+         avg_time, avg_iterations, convergence_rate * 100)
+end
+
+# Test convergence with different dataset characteristics
+puts "\n#{"=" * 70}"
+puts "Dataset Characteristics Impact"
+puts "-" * 50
+
+dataset_configs = [
+  { people: 50, items: 25, diff_range: (-1..1), ability_range: (-1..1), label: "Easy (narrow ranges)" },
+  { people: 100, items: 50, diff_range: (-2..2), ability_range: (-2..2), label: "Medium (standard ranges)" },
+  { people: 100, items: 50, diff_range: (-3..3), ability_range: (-3..3), label: "Hard (wide ranges)" },
+  { people: 200, items: 100, diff_range: (-2..2), ability_range: (-2..2), label: "Large (more data)" }
+]
+
+dataset_configs.each do |config|
+  puts "\nDataset: #{config[:label]}"
+
+  times = []
+  iterations = []
+  convergence_reasons = []
+
+  3.times do
+    dataset = generate_data(
+      config[:people],
+      config[:items],
+      difficulty_range: config[:diff_range],
+      ability_range: config[:ability_range]
+    )
+
+    time = Benchmark.measure do
+      model = TrackedRaschModel.new(
+        dataset[:data],
+        max_iter: 1000,
+        tolerance: 1e-5,
+        param_tolerance: 1e-5,
+        learning_rate: 0.01
+      )
+      model.fit
+      iterations << model.iterations
+      convergence_reasons << model.convergence_reason
+    end.real
+    times << time
+  end
+
+  avg_time = times.sum / times.size
+  avg_iterations = iterations.sum.to_f / iterations.size
+  convergence_rate = convergence_reasons.count(:tolerance_reached) / 3.0
+
+  printf("  Time: %6.3fs  Iterations: %6.1f  Convergence Rate: %4.0f%%\n",
+         avg_time, avg_iterations, convergence_rate * 100)
+end
+
+# Test different missing data patterns
+puts "\n#{"=" * 70}"
+puts "Missing Data Pattern Impact"
+puts "-" * 50
+
+missing_configs = [
+  { rate: 0.0, strategy: :ignore, label: "No Missing Data" },
+  { rate: 0.1, strategy: :ignore, label: "10% Missing (ignore)" },
+  { rate: 0.2, strategy: :ignore, label: "20% Missing (ignore)" },
+  { rate: 0.2, strategy: :treat_as_incorrect, label: "20% Missing (incorrect)" },
+  { rate: 0.2, strategy: :treat_as_correct, label: "20% Missing (correct)" }
+]
+
+missing_configs.each do |config|
+  puts "\nMissing Data: #{config[:label]}"
+
+  # Generate data with missing values
+  base_data = generate_data(100, 50)[:data]
+
+  data_with_missing = if (config[:rate]).positive?
+                        base_data.map do |row|
+                          row.map { |resp| rand < config[:rate] ? nil : resp }
+                        end
+                      else
+                        base_data
+                      end
+
+  times = []
+  iterations = []
+  convergence_reasons = []
+
+  3.times do
+    time = Benchmark.measure do
+      model = TrackedRaschModel.new(
+        data_with_missing,
+        max_iter: 1000,
+        tolerance: 1e-5,
+        param_tolerance: 1e-5,
+        learning_rate: 0.01,
+        missing_strategy: config[:strategy]
+      )
+      model.fit
+      iterations << model.iterations
+      convergence_reasons << model.convergence_reason
+    end.real
+    times << time
+  end
+
+  avg_time = times.sum / times.size
+  avg_iterations = iterations.sum.to_f / iterations.size
+  convergence_rate = convergence_reasons.count(:tolerance_reached) / 3.0
+
+  printf("  Time: %6.3fs  Iterations: %6.1f  Convergence Rate: %4.0f%%\n",
+         avg_time, avg_iterations, convergence_rate * 100)
+end
+
+puts "\n#{"=" * 70}"
+puts "Convergence Analysis Complete!"
+puts "=" * 70