release: 0.75.5

Added

- Add benchmark `biclique`.
- Add benchmark `circuit`.
- Add benchmark `complete`.
- Add benchmark `cycle`.
- Add benchmark `empty`.
- Add benchmark `path`.
- Add benchmark `random_tournament`.
- Add benchmark `star`.
- Add property test `random_tournament_has_arc` for `adjacency_list`.
- Add property test `random_tournament_has_arc` for `adjacency_matrix`.

Changed

- Improve performance of `Biclique::biclique` for `adjacency_list`.
- Remove `sample_size` attribute from `single_source_distances` benchmarks.

CHANGELOG.md

@@ -21,7 +21,26 @@
 - Implement `Debug` for `adjacency_list::Digraph` to show arcs.
 - Implement `Debug` for `adjacency_list_weighted::Digraph` to show arcs.
 - Implement `Debug` for `adjacency_matrix::Digraph` to show arcs.
-- Subsume traits with one super trait into the super trait?
+
+## [0.75.5] - 2024-08-03
+
+Added
+
+- Add benchmark `biclique`.
+- Add benchmark `circuit`.
+- Add benchmark `complete`.
+- Add benchmark `cycle`.
+- Add benchmark `empty`.
+- Add benchmark `path`.
+- Add benchmark `random_tournament`.
+- Add benchmark `star`.
+- Add property test `random_tournament_has_arc` for `adjacency_list`.
+- Add property test `random_tournament_has_arc` for `adjacency_matrix`.
+
+Changed
+
+- Improve performance of `Biclique::biclique` for `adjacency_list`.
+- Remove `sample_size` attribute from `single_source_distances` benchmarks.
 
 ## [0.75.4] - 2024-07-30
 

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "graaf"
-version = "0.75.4"
+version = "0.75.5"
 edition = "2021"
 authors = ["Bas Dirks <bas.dirks@protonmail.com>"]
 categories = ["algorithms", "data-structures", "mathematics"]
@@ -11,8 +11,6 @@ license = "MIT OR Apache-2.0"
 readme = "README.md"
 repository = "https://github.com/bsdrks/graaf"
 
-[dependencies]
-
 [lib]
 
 [dev-dependencies]
@@ -22,6 +20,46 @@ proptest = "1.4.0"
 [profile.test.package.proptest]
 opt-level = 3
 
+[[bench]]
+name = "biclique"
+path = "benches/gen/biclique.rs"
+harness = false
+
+[[bench]]
+name = "circuit"
+path = "benches/gen/circuit.rs"
+harness = false
+
+[[bench]]
+name = "complete"
+path = "benches/gen/complete.rs"
+harness = false
+
+[[bench]]
+name = "cycle"
+path = "benches/gen/cycle.rs"
+harness = false
+
+[[bench]]
+name = "empty"
+path = "benches/gen/empty.rs"
+harness = false
+
+[[bench]]
+name = "path"
+path = "benches/gen/path.rs"
+harness = false
+
+[[bench]]
+name = "random_tournament"
+path = "benches/gen/random_tournament.rs"
+harness = false
+
+[[bench]]
+name = "star"
+path = "benches/gen/star.rs"
+harness = false
+
 [[bench]]
 name = "single_source_distances"
 path = "benches/algo/single_source_distances.rs"

README.md

@@ -31,7 +31,7 @@ Add the following to your `Cargo.toml`:
 
 ```toml
 [dependencies]
-graaf = "0.75.4"
+graaf = "0.75.5"
 ```
 
 ## Digraph Types

benches/algo/single_source_distances.rs

@@ -28,7 +28,6 @@ fn main() {
     divan::main();
 }
 
-#[divan::bench_group(sample_size = 1000)]
 mod bang_jensen_94 {
     use super::*;
 
@@ -62,7 +61,6 @@ mod bang_jensen_94 {
     }
 }
 
-#[divan::bench_group(sample_size = 1000)]
 mod bang_jensen_96 {
     use super::*;
 
@@ -89,7 +87,6 @@ mod bang_jensen_96 {
     }
 }
 
-#[divan::bench_group(sample_size = 1000)]
 mod bang_jensen_99 {
     use super::*;
 
@@ -105,7 +102,6 @@ mod bang_jensen_99 {
     }
 }
 
-#[divan::bench_group(sample_size = 1000)]
 mod kattis_bryr_1 {
     use super::*;
 
@@ -132,7 +128,6 @@ mod kattis_bryr_1 {
     }
 }
 
-#[divan::bench_group(sample_size = 1000)]
 mod kattis_bryr_2 {
     use super::*;
 
@@ -159,7 +154,6 @@ mod kattis_bryr_2 {
     }
 }
 
-#[divan::bench_group(sample_size = 1000)]
 mod kattis_bryr_3 {
     use super::*;
 
@@ -186,7 +180,6 @@ mod kattis_bryr_3 {
     }
 }
 
-#[divan::bench_group(sample_size = 1000)]
 mod kattis_crosscountry {
     use super::*;
 
@@ -214,7 +207,6 @@ mod kattis_crosscountry {
     }
 }
 
-#[divan::bench_group(sample_size = 1000)]
 mod kattis_shortestpath1 {
     use super::*;
 
@@ -242,7 +234,6 @@ mod kattis_shortestpath1 {
     }
 }
 
-#[divan::bench_group(sample_size = 1000)]
 mod random_tournament {
     use {
         divan::Bencher,

benches/gen/biclique.rs

@@ -0,0 +1,76 @@
+//! Benchmark the `Biclique::biclique` implementation for different types.
+
+use graaf::{
+    adjacency_list,
+    adjacency_matrix,
+    gen::Biclique,
+    op::AddArc,
+    r#gen::Empty,
+};
+
+fn main() {
+    divan::main();
+}
+
+/// # Panics
+///
+/// * Panics if `m` is zero.
+/// * Panics if `n` is zero.
+fn biclique_adjacency_list_naive(
+    m: usize,
+    n: usize,
+) -> adjacency_list::Digraph {
+    assert!(m > 0, "m must be greater than zero");
+    assert!(n > 0, "n must be greater than zero");
+
+    let order = m + n;
+    let mut digraph = adjacency_list::Digraph::empty(order);
+
+    for u in 0..m {
+        for v in m..order {
+            digraph.add_arc(u, v);
+            digraph.add_arc(v, u);
+        }
+    }
+
+    digraph
+}
+
+#[divan::bench(args = [
+    (10, 10),
+    (10, 100),
+    (10, 1000),
+    (10, 10000),
+    (100, 100),
+    (100, 1000),
+    (100, 10000),
+])]
+fn adjacency_list_naive((m, n): (usize, usize)) {
+    let _ = biclique_adjacency_list_naive(m, n);
+}
+
+#[divan::bench(args = [
+    (10, 10),
+    (10, 100),
+    (10, 1000),
+    (10, 10000),
+    (100, 100),
+    (100, 1000),
+    (100, 10000),
+])]
+fn adjacency_list((m, n): (usize, usize)) {
+    let _ = adjacency_list::Digraph::biclique(m, n);
+}
+
+#[divan::bench(args = [
+    (10, 10),
+    (10, 100),
+    (10, 1000),
+    (10, 10000),
+    (100, 100),
+    (100, 1000),
+    (100, 10000),
+])]
+fn adjacency_matrix((m, n): (usize, usize)) {
+    let _ = adjacency_matrix::Digraph::biclique(m, n);
+}

benches/gen/circuit.rs

@@ -0,0 +1,21 @@
+//! Benchmark the `Circuit::circuit` implementation for different types.
+
+use graaf::{
+    adjacency_list,
+    adjacency_matrix,
+    gen::Circuit,
+};
+
+fn main() {
+    divan::main();
+}
+
+#[divan::bench(args = [10, 100, 1000, 10000, 100000])]
+fn adjacency_list(n: usize) {
+    let _ = adjacency_list::Digraph::circuit(n);
+}
+
+#[divan::bench(args = [10, 100, 1000, 10000, 100000])]
+fn adjacency_matrix(n: usize) {
+    let _ = adjacency_matrix::Digraph::circuit(n);
+}

benches/gen/complete.rs

@@ -0,0 +1,21 @@
+//! Benchmark the `Complete::complete` implementation for different types.
+
+use graaf::{
+    adjacency_list,
+    adjacency_matrix,
+    gen::Complete,
+};
+
+fn main() {
+    divan::main();
+}
+
+#[divan::bench(args = [10, 100, 1000, 10000, 100000])]
+fn adjacency_list(n: usize) {
+    let _ = adjacency_list::Digraph::complete(n);
+}
+
+#[divan::bench(args = [10, 100, 1000, 10000, 100000])]
+fn adjacency_matrix(n: usize) {
+    let _ = adjacency_matrix::Digraph::complete(n);
+}

benches/gen/cycle.rs

@@ -0,0 +1,21 @@
+//! Benchmark the `Cycle::cycle` implementation for different types.
+
+use graaf::{
+    adjacency_list,
+    adjacency_matrix,
+    gen::Cycle,
+};
+
+fn main() {
+    divan::main();
+}
+
+#[divan::bench(args = [10, 100, 1000, 10000, 100000])]
+fn adjacency_list(n: usize) {
+    let _ = adjacency_list::Digraph::cycle(n);
+}
+
+#[divan::bench(args = [10, 100, 1000, 10000, 100000])]
+fn adjacency_matrix(n: usize) {
+    let _ = adjacency_matrix::Digraph::cycle(n);
+}

benches/gen/empty.rs

@@ -0,0 +1,21 @@
+//! Benchmark the `Empty::empty` implementation for different types.
+
+use graaf::{
+    adjacency_list,
+    adjacency_matrix,
+    gen::Empty,
+};
+
+fn main() {
+    divan::main();
+}
+
+#[divan::bench(args = [10, 100, 1000, 10000])]
+fn adjacency_list(n: usize) {
+    let _ = adjacency_list::Digraph::empty(n);
+}
+
+#[divan::bench(args = [10, 100, 1000, 10000])]
+fn adjacency_matrix(n: usize) {
+    let _ = adjacency_matrix::Digraph::empty(n);
+}

benches/gen/path.rs

@@ -0,0 +1,21 @@
+//! Benchmark the `Path::path` implementation for different types.
+
+use graaf::{
+    adjacency_list,
+    adjacency_matrix,
+    gen::Path,
+};
+
+fn main() {
+    divan::main();
+}
+
+#[divan::bench(args = [10, 100, 1000, 10000, 100000])]
+fn adjacency_list(n: usize) {
+    let _ = adjacency_list::Digraph::path(n);
+}
+
+#[divan::bench(args = [10, 100, 1000, 10000, 100000])]
+fn adjacency_matrix(n: usize) {
+    let _ = adjacency_matrix::Digraph::path(n);
+}

benches/gen/random_tournament.rs

@@ -0,0 +1,22 @@
+//! Benchmark the `RandomTournament::random_tournament` implementation for
+//! different types.
+
+use graaf::{
+    adjacency_list,
+    adjacency_matrix,
+    gen::RandomTournament,
+};
+
+fn main() {
+    divan::main();
+}
+
+#[divan::bench(args = [10, 100, 1000])]
+fn adjacency_list(n: usize) {
+    let _ = adjacency_list::Digraph::random_tournament(n);
+}
+
+#[divan::bench(args = [10, 100, 1000])]
+fn adjacency_matrix(n: usize) {
+    let _ = adjacency_matrix::Digraph::random_tournament(n);
+}