rustworkx-core 0.17.1

Rust APIs used for rustworkx algorithms
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111

use petgraph::graph::{DiGraph, UnGraph};
use petgraph::visit::EdgeRef;
use quickcheck::{quickcheck, TestResult};
use rustworkx_core::generators::cycle_graph;
use std::collections::HashSet;

#[test]
fn prop_cycle_graph_directed() {
    fn prop(n: usize) -> TestResult {
        let n = (n % 100).max(2);
        let g = match cycle_graph::<DiGraph<(), ()>, (), _, _, ()>(
            Some(n),
            None,
            || (),
            || (),
            false,
        ) {
            Ok(g) => g,
            Err(_) => return TestResult::error("Unexpected error in directed cycle_graph"),
        };

        if g.node_count() != n || g.edge_count() != n {
            return TestResult::failed();
        }

        // Expected edges in circular fashion 0→1, 1→2, ... n-1→0
        let expected_edges: HashSet<_> = (0..n).map(|i| (i, (i + 1) % n)).collect();

        let actual_edges: HashSet<_> = g
            .edge_references()
            .map(|e| (e.source().index(), e.target().index()))
            .collect();

        TestResult::from_bool(expected_edges == actual_edges)
    }

    quickcheck(prop as fn(usize) -> TestResult);
}

#[test]
fn prop_cycle_graph_bidirectional() {
    fn prop(n: usize) -> TestResult {
        let n = (n % 100).max(2);
        let g =
            match cycle_graph::<DiGraph<(), ()>, (), _, _, ()>(Some(n), None, || (), || (), true) {
                Ok(g) => g,
                Err(_) => {
                    return TestResult::error("Unexpected error in bidirectional cycle_graph")
                }
            };

        if g.node_count() != n || g.edge_count() != 2 * n {
            return TestResult::failed();
        }

        // For each directed edge, its reverse must exist
        for edge in g.edge_references() {
            let u = edge.source();
            let v = edge.target();
            if g.find_edge(v, u).is_none() {
                return TestResult::failed();
            }
        }

        TestResult::passed()
    }

    quickcheck(prop as fn(usize) -> TestResult);
}

#[test]
fn prop_cycle_graph_undirected() {
    fn prop(n: usize) -> TestResult {
        let n = (n % 100).max(2);
        let g = match cycle_graph::<UnGraph<(), ()>, (), _, _, ()>(
            Some(n),
            None,
            || (),
            || (),
            false,
        ) {
            Ok(g) => g,
            Err(_) => return TestResult::error("Unexpected error in undirected cycle_graph"),
        };

        if g.node_count() != n || g.edge_count() != n {
            return TestResult::failed();
        }

        let expected_edges: HashSet<_> = (0..n)
            .map(|i| {
                let u = i;
                let v = (i + 1) % n;
                (u.min(v), u.max(v))
            })
            .collect();

        let actual_edges: HashSet<_> = g
            .edge_references()
            .map(|e| {
                let u = e.source().index();
                let v = e.target().index();
                (u.min(v), u.max(v))
            })
            .collect();

        TestResult::from_bool(expected_edges == actual_edges)
    }

    quickcheck(prop as fn(usize) -> TestResult);
}