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
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
115
116
117
118
119
120
121
122
123
124
125

//! Codeword bit interleaving.
//!
//! This module implements an interleaver and deinterleaver. The interleaver can
//! be used before modulating the codeword into symbols. The implementation is
//! compliant with the DVB-S2 interleaver.

use ndarray::{Array1, Array2, ArrayBase, Axis, Data, Ix1};
use num_traits::Zero;

/// Interleaver.
///
/// Implements matrix interleaving/deinterleaving of codeword bits following the
/// DVB-S2 standard.
#[derive(Debug, Clone)]
pub struct Interleaver {
    columns: usize,
    read_rows_backwards: bool,
}

impl Interleaver {
    /// Creates a new interleaver.
    ///
    /// The `columns` parameter defines the number of columns of the
    /// interleaver.Typically this is the number of bits per symbol.
    ///
    /// The `read_rows_backwards` parameter controls whether the rows should be
    /// read backwards. In DVB-S2 this option is only used in 8PSK rate 3/5.
    pub fn new(columns: usize, read_rows_backwards: bool) -> Interleaver {
        Interleaver {
            columns,
            read_rows_backwards,
        }
    }

    /// Interleaves a codeword.
    ///
    /// # Panics
    ///
    /// Panics if the codeword size is not divisible by the number of columns.
    pub fn interleave<S, T: Clone + Zero>(&self, codeword: &ArrayBase<S, Ix1>) -> Array1<T>
    where
        S: Data<Elem = T>,
    {
        assert_eq!(codeword.len() % self.columns, 0);
        let a2 = codeword
            .view()
            .into_shape_with_order((self.columns, codeword.len() / self.columns))
            .unwrap();
        let mut transpose = a2.t();
        if self.read_rows_backwards {
            transpose.invert_axis(Axis(1));
        }
        let mut a = Array2::zeros(transpose.raw_dim());
        a.assign(&transpose);
        a.view()
            .into_shape_with_order(codeword.len())
            .unwrap()
            .to_owned()
    }

    /// Deinterleaves a codeword.
    ///
    /// # Panics
    ///
    /// Panics if the codeword size is not divisible by the number of columns.
    pub fn deinterleave<T: Clone + Zero>(&self, codeword: &[T]) -> Vec<T> {
        assert_eq!(codeword.len() % self.columns, 0);
        let codeword = Array1::from_iter(codeword.iter().cloned());
        let a2 = codeword
            .view()
            .into_shape_with_order((codeword.len() / self.columns, self.columns))
            .unwrap();
        let mut transpose = a2.t();
        if self.read_rows_backwards {
            transpose.invert_axis(Axis(0));
        }
        let mut a = Array2::zeros(transpose.raw_dim());
        a.assign(&transpose);
        a.view()
            .into_shape_with_order(codeword.len())
            .unwrap()
            .iter()
            .cloned()
            .collect()
    }
}

#[cfg(test)]
mod test {
    use super::*;

    #[test]
    fn interleaver_3() {
        let interleaver = Interleaver::new(3, false);
        let interleaved = interleaver.interleave(&ndarray::arr1(&[0, 1, 2, 3, 4, 5]));
        let expected = [0, 2, 4, 1, 3, 5];
        assert_eq!(interleaved.as_slice().unwrap(), &expected);
    }

    #[test]
    fn interleaver_3_backwards() {
        let interleaver = Interleaver::new(3, true);
        let interleaved = interleaver.interleave(&ndarray::arr1(&[0, 1, 2, 3, 4, 5]));
        let expected = [4, 2, 0, 5, 3, 1];
        assert_eq!(interleaved.as_slice().unwrap(), &expected);
    }

    #[test]
    fn deinterleaver_3() {
        let interleaver = Interleaver::new(3, false);
        let original = [0, 1, 2, 3, 4, 5];
        let interleaved = interleaver.interleave(&ndarray::arr1(&original));
        let deinterleaved = interleaver.deinterleave(interleaved.as_slice().unwrap());
        assert_eq!(&deinterleaved, &original);
    }

    #[test]
    fn deinterleaver_3_backwards() {
        let interleaver = Interleaver::new(3, true);
        let original = [0, 1, 2, 3, 4, 5];
        let interleaved = interleaver.interleave(&ndarray::arr1(&original));
        let deinterleaved = interleaver.deinterleave(interleaved.as_slice().unwrap());
        assert_eq!(&deinterleaved, &original);
    }
}