Add kuhn_munkres_complexity example for experimental O(n³) complexity analysis

[Copilot]

The repository lacked a demonstration program to experimentally verify the documented O(n³) complexity of the Kuhn-Munkres algorithm implementation.

Changes

• New example: examples/kuhn_munkres_complexity.rs
  • Tests matrix sizes: 5×5, 10×10, 20×20, 30×30, 40×40, 50×50, 60×60, 80×80, 100×100, 120×120, 150×150, 200×200 (12 data points)
  • Averages 20 iterations per size using fixed seed for reproducibility
  • Outputs two analyses:
    • Time/n³ ratio table: Shows execution time normalized by n³ (should remain relatively constant for O(n³))
    • Growth rate comparison: Compares actual vs. theoretical growth (e.g., 2× size → 8× time for cubic)

Usage

# Run with optimizations for accurate measurements
cargo run --release --example kuhn_munkres_complexity

Example output shows Time/n³ ratios ranging from 0.012400 (5×5) to 0.000232 (200×200), with growth rates of ~2-4× for various size progressions (vs. theoretical expectations based on cubic complexity), typical for optimized code with cache effects.

Original prompt

---

This section details on the original issue you should resolve

<issue_title>Design a new example to experimentally compute the complexity of Kuhn-Munkres</issue_title>
<issue_description>There exist various implementation of the Kuhn-Munkres algorithm. We would benefit from having an example program which experimentally tries our implementation with various input sizes and tries to experimentally determine its complexity.</issue_description>

Comments on the Issue (you are @copilot in this section)

• Fixes Design a new example to experimentally compute the complexity of Kuhn-Munkres #736

---

✨ Let Copilot coding agent set things up for you — coding agent works faster and does higher quality work when set up for your repo.

Summary by CodeRabbit

Documentation

• Added a new example demonstrating performance measurement and complexity analysis for the Kuhn-Munkres algorithm, including execution timing results and growth-rate comparisons across different problem sizes.

_{✏️ Tip: You can customize this high-level summary in your review settings.}

[coderabbitai]

📝 Walkthrough

Walkthrough

A new example program is added to experimentally measure the computational complexity of the Kuhn-Munkres algorithm implementation. The program generates random weighted matrices of varying sizes, measures execution times, and performs empirical complexity analysis comparing observed performance to O(n³) bounds.

Changes

Cohort / File(s)	Summary
New Example Program examples/kuhn_munkres_complexity.rs	Introduces experimental complexity analysis tool for Kuhn-Munkres algorithm; measures execution time across configurable matrix sizes with fixed-seed RNG for reproducibility; outputs per-size timing statistics and growth-rate analysis

Estimated code review effort

🎯 2 (Simple) | ⏱️ ~8 minutes

Poem

🐰 A rabbit hops through matrices of might,
Measuring Hungarian paths just right,
O(n³) secrets to the light,
Complexity revealed with each new test,
Performance benchmarks put to the test! ✨

Pre-merge checks and finishing touches

❌ Failed checks (1 warning)

Check name	Status	Explanation	Resolution
Docstring Coverage	⚠️ Warning	Docstring coverage is 0.00% which is insufficient. The required threshold is 80.00%.	You can run @coderabbitai generate docstrings to improve docstring coverage.

✅ Passed checks (4 passed)

Check name	Status	Explanation
Description Check	✅ Passed	Check skipped - CodeRabbit’s high-level summary is enabled.
Title check	✅ Passed	The title clearly and specifically describes the main change: adding a new example file for Kuhn-Munkres complexity analysis with O(n³) focus.
Linked Issues check	✅ Passed	The pull request fully addresses issue #736 by providing an example program that experimentally evaluates Kuhn-Munkres complexity across multiple input sizes and infers cubic behavior.
Out of Scope Changes check	✅ Passed	All changes are scoped to the new example file with no modifications to existing APIs, public entities, or unrelated code.

✨ Finishing touches

• 📝 Generate docstrings

---

📜 Recent review details

Configuration used: defaults

Review profile: CHILL

Plan: Pro

📥 Commits

Reviewing files that changed from the base of the PR and between 5be0140 and 4c3224a.

📒 Files selected for processing (1)

• examples/kuhn_munkres_complexity.rs

🧰 Additional context used

📓 Path-based instructions (1)

**/*.rs

📄 CodeRabbit inference engine (.github/copilot-instructions.md)

**/*.rs: Run unit and integration tests with cargo test --tests --benches before committing
Run documentation tests with cargo test --doc before committing
Run formatting check with cargo +stable fmt --all -- --check before committing, auto-fix with cargo +stable fmt --all
Run clippy with nightly toolchain using cargo +nightly clippy --all-targets -- -D warnings before committing, treating all warnings as errors
Use cargo +stable fmt for code formatting, not nightly rustfmt
Use cargo +nightly clippy for linting, not stable clippy
Run tests in both debug and release modes on stable, beta, nightly, and MSRV toolchains
Maintain MSRV 1.87.0 compatibility - avoid using features not available in Rust 1.87.0 or later

Files:

• examples/kuhn_munkres_complexity.rs

🧠 Learnings (4)

📚 Learning: 2026-01-03T01:10:43.081Z

Learnt from: CR
Repo: evenfurther/pathfinding PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T01:10:43.081Z
Learning: Applies to src/lib.rs : Export new public modules and types from lib.rs when adding new algorithms or data structures

Applied to files:

• examples/kuhn_munkres_complexity.rs

📚 Learning: 2026-01-03T01:10:43.081Z

Learnt from: CR
Repo: evenfurther/pathfinding PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T01:10:43.081Z
Learning: Applies to src/{directed,undirected}/mod.rs : Update module declarations in mod.rs when adding new algorithm files to directed/ or undirected/ modules

Applied to files:

• examples/kuhn_munkres_complexity.rs

📚 Learning: 2026-01-03T01:10:43.081Z

Learnt from: CR
Repo: evenfurther/pathfinding PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T01:10:43.081Z
Learning: Applies to src/**/*.rs : Include documentation examples in public API functions that can be tested with `cargo test --doc`

Applied to files:

• examples/kuhn_munkres_complexity.rs

📚 Learning: 2026-01-03T01:10:43.081Z

Learnt from: CR
Repo: evenfurther/pathfinding PR: 0
File: .github/copilot-instructions.md:0-0
Timestamp: 2026-01-03T01:10:43.081Z
Learning: Applies to src/{directed,undirected}/**/*.rs : Add new algorithms in appropriate modules: src/directed/ for directed graph algorithms, src/undirected/ for undirected graph algorithms

Applied to files:

• examples/kuhn_munkres_complexity.rs

🧬 Code graph analysis (1)

examples/kuhn_munkres_complexity.rs (1)

src/kuhn_munkres.rs (1)

• kuhn_munkres (117-228)

⏰ Context from checks skipped due to timeout of 90000ms. You can increase the timeout in your CodeRabbit configuration to a maximum of 15 minutes (900000ms). (1)

• GitHub Check: Extra tests in release mode

🔇 Additional comments (6)

examples/kuhn_munkres_complexity.rs (6)

1-11: LGTM! Clear documentation and appropriate imports.

The documentation clearly explains the purpose and the O(n³) complexity being analyzed. The imports are appropriate for the experimental analysis task.

---

13-17: Constants provide good coverage for complexity analysis.

The 12 test sizes span a reasonable range (5 to 200), and 20 iterations should provide adequate averaging for stable measurements. This aligns well with the PR objectives for experimental complexity verification.

---

25-43: Good use of fixed seed for reproducibility.

The fixed seed for XorShiftRng ensures that the complexity analysis is reproducible across runs, which is essential for consistent benchmarking.

---

65-73: Appropriate handling of precision loss in timing calculations.

The #[expect(clippy::cast_precision_loss)] annotation correctly acknowledges the intentional cast from integer to float for averaging. The precision of f64 is more than adequate for microsecond-level timing measurements.

---

75-117: Excellent complexity analysis methodology.

The analysis approach is well-designed:

• The Time/n³ ratio table effectively demonstrates constant-factor behavior for O(n³) complexity.
• The growth rate analysis provides intuitive verification (e.g., doubling size → 8× time).
• The formatting and conclusion are clear and educational.

---

44-63: The code is correct. Rand crate version 0.9.2 uses random_range() for range sampling; the older gen_range() method was deprecated and renamed in version 0.9.0+. Line 48's usage of rng.random_range(1..=100) is the correct API for this crate version.

Likely an incorrect or invalid review comment.

---

Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out.

❤️ Share

• X
• Mastodon
• Reddit
• LinkedIn

_{Comment @coderabbitai help to get the list of available commands and usage tips.}

[samueltardieu]

@copilot Since it runs quite fast, maybe you should include more datapoints and bigger sample sizes

[Copilot]

@copilot Since it runs quite fast, maybe you should include more datapoints and bigger sample sizes

Done in d4fdb8c. Updated to include:

• 12 data points (up from 6): [5, 10, 20, 30, 40, 50, 60, 80, 100, 120, 150, 200]
• Maximum size increased from 100×100 to 200×200 matrices
• 20 iterations per size (up from 10) for more stable measurements

Example output now shows more comprehensive complexity analysis with finer-grained growth rate comparisons.

[samueltardieu]

@coderabbitai review

[coderabbitai]

✅ Actions performed

Review triggered.

Note: CodeRabbit is an incremental review system and does not re-review already reviewed commits. This command is applicable only when automatic reviews are paused.