rip out some code

src/interleaver.rs

@@ -61,24 +61,6 @@ pub(crate) fn uninterleave<const N: usize>(
     Ok(())
 }
 
-pub(crate) fn interleave_soft<const N: usize, T: DecodeFrom>(
-    data: &[T],
-    out: &mut Buffer<N, T>,
-) -> Result<(), EncodeError> {
-    for i in 0..32 {
-        for j in (0..data.len()).step_by(32) {
-            if i + j >= data.len() {
-                continue;
-            }
-
-            out.try_push(data[i + j])
-                .map_err(|_| EncodeError::CatsOverflow)?;
-        }
-    }
-
-    Ok(())
-}
-
 pub(crate) fn uninterleave_soft<const N: usize, T: DecodeFrom>(
     data: &[T],
     out: &mut Buffer<N, T>,
@@ -130,43 +112,6 @@ mod tests {
         assert_eq!(*orig, *uninterleaved);
     }
 
-    #[test]
-    fn soft_interleaver_works() {
-        let mut data = [
-            57i16, 90, -103, -127, 85, -86, -43, -84, -116, -110, -36, -126, -74, 42, -28, -16, 93,
-            -22, -4, -110, -84, 84, -100, -109, 74, -86, 73, -64, -117, -93, 118, -26, 9, 69, -100,
-            80, -4, 26, -85, -118, 40, 64, -97, -7, 84, 118, 84, 127, -96, -18, 77, 1, 27, -20,
-            -95, -105, -120, 14, 119, -117, -103, 67, 58, -4, -98, 12, -5, -59, 74, -112, -9, 17,
-            -17, 67, -116, 12, -59, -118, 6, 99, 56, -27, -64, -87, -36, -51, 47, 19, -97, -63, 4,
-            5, 23, -38, -14, 16, -52, 54, -27, -90,
-        ];
-        let orig = Buffer::new_full(&mut data);
-
-        let mut interleaved = [0; 101];
-        let mut interleaved = Buffer::new(&mut interleaved, 0);
-
-        // check that existing data isn't mangled
-        interleaved.push(-1);
-
-        interleave_soft(&orig, &mut interleaved).unwrap();
-
-        let expected = [
-            -1, 57, 9, -98, -52, 90, 69, 12, 54, -103, -100, -5, -27, -127, 80, -59, -90, 85, -4,
-            74, -86, 26, -112, -43, -85, -9, -84, -118, 17, -116, 40, -17, -110, 64, 67, -36, -97,
-            -116, -126, -7, 12, -74, 84, -59, 42, 118, -118, -28, 84, 6, -16, 127, 99, 93, -96, 56,
-            -22, -18, -27, -4, 77, -64, -110, 1, -87, -84, 27, -36, 84, -20, -51, -100, -95, 47,
-            -109, -105, 19, 74, -120, -97, -86, 14, -63, 73, 119, 4, -64, -117, 5, -117, -103, 23,
-            -93, 67, -38, 118, 58, -14, -26, -4, 16,
-        ];
-        assert_eq!(expected, interleaved[..]);
-
-        let mut uninterleaved = [0; 101];
-        let mut uninterleaved = Buffer::new(&mut uninterleaved, 0);
-        uninterleave_soft(&interleaved[1..], &mut uninterleaved).unwrap();
-
-        assert_eq!(*orig, *uninterleaved);
-    }
-
     #[test]
     fn hard_interleave_soft_uninterleave() {
         let mut data = [0x84, 0x73, 0x12, 0xA3, 0xFF, 0x00, 0xC2, 0x1B, 0x77];

src/ldpc.rs

@@ -232,7 +232,7 @@ pub(crate) fn decode_soft<const N: usize, const M: usize, T: DecodeFrom>(
                     1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
                     1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
                 ]
-                .map(|x| T::from_hard_bit(x > 0)); // TODO !!
+                .map(|x| if x > 0 { -T::maxval() } else { T::maxval() });
                 code_data[..data.len()].copy_from_slice(data);
                 let code_parity = &parity.get_mut(..64)?;
 

src/whitener.rs

-use labrador_ldpc::decoder::DecodeFrom;
-
 const START_STATE: u16 = 0xE9CF;
 
 pub(crate) fn whiten(data: &mut [u8]) {
@@ -12,20 +10,6 @@ pub(crate) fn whiten(data: &mut [u8]) {
     }
 }
 
-// One bit per element
-pub(crate) fn whiten_soft<T: DecodeFrom>(data: &mut [T]) {
-    let mut state = START_STATE;
-
-    for d in data.iter_mut() {
-        let b = state & 1;
-        if b > 0 {
-            // flip the soft bit. In LLR speak, this just means flip the sign
-            *d = -*d;
-        }
-        state = lfsr(state);
-    }
-}
-
 // (byte, state)
 fn lfsr_byte(mut state: u16) -> (u8, u16) {
     let mut out = 0;
@@ -51,7 +35,6 @@ fn lfsr(mut state: u16) -> u16 {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::soft_bit::SoftBit;
 
     #[test]
     fn basic() {
@@ -67,44 +50,6 @@ mod tests {
         assert_eq!(orig, data);
     }
 
-    #[test]
-    fn basic_soft() {
-        let mut data = [-2.3, 4.7, 0.0, 2.7, 7.8, 45.2, -0.1, -0.82];
-        let orig = data;
-
-        whiten_soft(&mut data);
-        assert_eq!([2.3, -4.7, -0.0, -2.7, 7.8, 45.2, 0.1, 0.82], data);
-
-        whiten_soft(&mut data);
-        assert_eq!(orig, data);
-    }
-
-    #[test]
-    fn compare_soft_and_hard() {
-        let mut data = [0; 64];
-        data[0..57]
-            .clone_from_slice(&b"Hello world! The quick brown fox jumped over the lazy dog"[..]);
-        let orig = data;
-
-        whiten(&mut data);
-
-        let mut soft = [0.0; 64 * 8];
-        for (i, b) in data.iter().enumerate() {
-            for j in 0..8 {
-                soft[8 * i + j] = f32::from_hard_bit(b & (1 << (7 - j)) > 0);
-            }
-        }
-
-        whiten_soft(&mut soft);
-
-        assert_eq!(orig.len() * 8, soft.len());
-        for (i, b) in orig.iter().enumerate() {
-            for j in 0..8 {
-                assert_eq!(soft[8 * i + j].hard_bit(), *b & (1 << (7 - j)) > 0);
-            }
-        }
-    }
-
     #[test]
     fn test_lfsr() {
         let start = 0xACE1;