ldpc-toolbox 0.12.0

Utilities to aid in LDPC code design
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

#[cfg(test)]
mod tests {
    use crate::sparse::Node::{Col, Row};
    use crate::sparse::SparseMatrix;

    #[test]
    fn test_local_girth_circulant() {
        for circulant_size in 2..5 {
            let mut h = SparseMatrix::new(10, 20);
            for j in 0..circulant_size {
                h.insert(j, j);
                h.insert(j, (j + 1) % circulant_size);
            }
            for j in 0..circulant_size {
                assert_eq!(
                    h.girth_at_node_with_max(Col(j), 10),
                    Some(2 * circulant_size)
                );
                assert_eq!(
                    h.girth_at_node_with_max(Row(j), 10),
                    Some(2 * circulant_size)
                );
            }
            for j in circulant_size..h.num_cols() {
                assert_eq!(h.girth_at_node_with_max(Col(j), 10), None);
            }
            for j in circulant_size..h.num_rows() {
                assert_eq!(h.girth_at_node_with_max(Row(j), 10), None);
            }
        }
    }

    #[test]
    fn test_girth_identity() {
        let size = 20;
        let mut h = SparseMatrix::new(size, size);
        for j in 0..size {
            h.insert(j, j);
        }
        assert_eq!(h.girth_with_max(100), None);
    }

    #[test]
    fn test_girth_double_circulant() {
        let mut h = SparseMatrix::new(20, 30);
        let circulant_sizes = (5, 3);
        for j in 0..circulant_sizes.0 {
            h.insert(j, j);
            h.insert(j, (j + 1) % circulant_sizes.0);
        }
        for j in 0..circulant_sizes.1 {
            h.insert(j + circulant_sizes.0, j + circulant_sizes.0);
            h.insert(
                j + circulant_sizes.0,
                (j + 1) % circulant_sizes.1 + circulant_sizes.0,
            );
        }
        assert_eq!(h.girth_with_max(100), Some(2 * circulant_sizes.1));
        for j in 0..circulant_sizes.0 {
            assert_eq!(
                h.girth_at_node_with_max(Col(j), 100),
                Some(2 * circulant_sizes.0)
            );
            assert_eq!(
                h.girth_at_node_with_max(Row(j), 100),
                Some(2 * circulant_sizes.0)
            );
        }
        for j in circulant_sizes.0..(circulant_sizes.0 + circulant_sizes.1) {
            assert_eq!(
                h.girth_at_node_with_max(Col(j), 100),
                Some(2 * circulant_sizes.1)
            );
            assert_eq!(
                h.girth_at_node_with_max(Row(j), 100),
                Some(2 * circulant_sizes.1)
            );
        }
        for j in (circulant_sizes.0 + circulant_sizes.1)..h.num_cols() {
            assert_eq!(h.girth_at_node_with_max(Col(j), 100), None);
        }
        for j in (circulant_sizes.0 + circulant_sizes.1)..h.num_rows() {
            assert_eq!(h.girth_at_node_with_max(Row(j), 100), None);
        }
    }
}