molframe-core 0.5.1

Core types, storage and analysis contracts for molframe
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
112
113
114

use super::*;

fn built(degrees: &[usize], items: &[(usize, u32)]) -> Csr<u32> {
    let mut builder = CsrBuilder::with_degrees(degrees);
    for (row, item) in items {
        builder.push(*row, *item);
    }
    builder.finish()
}

#[test]
fn an_empty_adjacency_has_no_rows_and_no_items() {
    let csr = Csr::<u32>::empty();

    assert!(csr.is_empty());
    assert_eq!(csr.rows(), 0);
    assert_eq!(csr.len(), 0);
    assert_eq!(csr.row(0), &[] as &[u32]);
}

#[test]
fn each_row_returns_exactly_the_items_scattered_into_it() {
    let csr = built(&[2, 0, 3], &[(0, 7), (2, 1), (0, 9), (2, 2), (2, 3)]);

    assert_eq!(csr.rows(), 3);
    assert_eq!(csr.len(), 5);
    assert_eq!(csr.row(0), &[7, 9]);
    assert_eq!(csr.row(1), &[] as &[u32]);
    assert_eq!(csr.row(2), &[1, 2, 3]);
}

#[test]
fn a_row_past_the_end_is_empty_rather_than_a_panic() {
    let csr = built(&[1], &[(0, 4)]);

    assert_eq!(csr.row(1), &[] as &[u32]);
    assert_eq!(csr.row(usize::MAX), &[] as &[u32]);
}

#[test]
fn items_beyond_a_declared_degree_never_reach_a_neighbouring_row() {
    let csr = built(&[1, 1], &[(0, 5), (0, 6), (0, 7), (1, 8)]);

    assert_eq!(csr.row(0), &[5]);
    assert_eq!(csr.row(1), &[8]);
}

#[test]
fn a_row_beyond_the_declared_count_is_dropped() {
    let csr = built(&[1], &[(0, 5), (9, 6)]);

    assert_eq!(csr.rows(), 1);
    assert_eq!(csr.row(0), &[5]);
}

#[test]
fn rows_can_be_sorted_in_place_through_row_mut() {
    let mut csr = built(&[3], &[(0, 9), (0, 2), (0, 5)]);
    csr.row_mut(0).sort_unstable();

    assert_eq!(csr.row(0), &[2, 5, 9]);
    assert_eq!(csr.row_mut(4), &mut [] as &mut [u32]);
}

#[test]
fn iterating_yields_every_row_in_order() {
    let csr = built(&[2, 0, 1], &[(0, 1), (0, 2), (2, 3)]);
    let rows: Vec<&[u32]> = csr.iter().collect();

    assert_eq!(rows, vec![&[1, 2][..], &[][..], &[3][..]]);
}

#[test]
fn a_degree_table_of_zeros_allocates_rows_but_no_items() {
    let csr = built(&[0, 0, 0], &[]);

    assert_eq!(csr.rows(), 3);
    assert_eq!(csr.len(), 0);
    assert!(csr.iter().all(<[u32]>::is_empty));
}

#[test]
fn an_under_filled_row_leaves_no_default_padding_behind() {
    let csr = built(&[3, 2], &[(0, 7), (1, 4)]);

    assert_eq!(csr.row(0), &[7]);
    assert_eq!(csr.row(1), &[4]);
    assert_eq!(csr.len(), 2);
}

#[test]
fn canonicalising_sorts_each_row_and_drops_repeated_items() {
    let mut builder = CsrBuilder::with_degrees(&[4, 2]);
    for (row, item) in [(0, 9), (0, 2), (0, 9), (0, 2), (1, 5), (1, 5)] {
        builder.push(row, item);
    }
    let csr = builder.finish_canonical();

    assert_eq!(csr.row(0), &[2, 9]);
    assert_eq!(csr.row(1), &[5]);
    assert_eq!(csr.len(), 3);
}

#[test]
fn canonicalising_keeps_distinct_items_that_repeat_across_rows() {
    let mut builder = CsrBuilder::with_degrees(&[2, 2]);
    for (row, item) in [(0, 1), (0, 1), (1, 1), (1, 3)] {
        builder.push(row, item);
    }
    let csr = builder.finish_canonical();

    assert_eq!(csr.row(0), &[1]);
    assert_eq!(csr.row(1), &[1, 3]);
}