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

use {Code, CodeType, b3, b1};

pub trait Encoder {
  fn encode(code: Code, signal: Vec<b1>) -> Vec<b1>;
}

/// Encoder implementation for nonrecursive convolutional codes.
impl Encoder for Code {
  fn encode(code: Code, signal: Vec<b1>) -> Vec<b1> {
    match code.code_type {
      CodeType::FIRCode => encode_fir(code, signal),
      CodeType::IIRCode => encode_iir(code, signal)
    }
  }
}

fn encode_fir(code: Code, signal: Vec<b1>) -> Vec<b1> {
  let start_bits = code.start_state.bits().to_vec();
  let start_vec: Vec<&b1> = start_bits.iter()
                                      .chain(signal.iter())
                                      .collect();
  
  start_vec
    .chunks(code.polys[0].len()) // Looks clumsy but type has a fixed "length"
    .flat_map(|sig_chunk| {
      code.polys.iter().map(move |&code_poly| poly_add_ref(code_poly, sig_chunk))
    }).collect()
}

fn encode_iir(code: Code, signal: Vec<b1>) -> Vec<b1> {
  signal.chunks(code.polys[0].len()).scan(code.start_state, |state, sig_chunk| {
    // The initial state is given by the code, and as we compute new encoded
    // values, we'll push those into the state.
    let output = poly_add(*state, sig_chunk);
    *state = b3::new([state[1], state[2], output.clone()]);
      
    Some(output)
  }).collect()
}

fn poly_add_ref(code_vec: b3, sig_arr: &[&b1]) -> b1 {
  sig_arr.iter().rev().zip(code_vec.bits().iter())
                      .map(|(&&sig, &code)| sig & code)
                      .fold(b1(false), |accum, val| accum ^ val)
}

fn poly_add(code_vec: b3, sig_arr: &[b1]) -> b1 {
  sig_arr.iter().rev().zip(code_vec.bits().iter())
                      .map(|(&sig, &code)| sig & code)
                      .fold(b1(false), |accum, val| accum ^ val)
}