Struct turbo::Code

pub struct Code {
    pub start_state: Vec<b1>,
    pub polys: Vec<b3>,
    pub code_type: CodeType,
}

A description of a binary convolutional code, either nonrecursive (FIR), or recursive (IIR), including start state.

Fields

start_state: Vec<b1>

The starting state of the registers.

polys: Vec<b3>

Storage of the binary polynomial coefficients. Each polynomial corresponds to an output bit in the order in which they are stored.

Coefficients are defined in order of increasing delay, e.g. polys[0][0] is applied to signal[n], and coefs[1] is applied to signal[n-1], and so on.

code_type: CodeType

Enum describing the type of the code (FIR or IIR).

Methods

impl Code

fn state_adjacency(&self) -> Vec<Vec<b1>>

Computes the adjacency matrix of states the code passes through. The output is a matrix indexed by [start_index][destination_index], with a unit binary digit in each position (1 if there is an edge, 0 if there is not).

This turns out to be easy for an FIR encoder, because the transitions can be expressed solely as "pushes" onto an array of previous states that only differ by the next input bit. For example, for a 3-digit state register, the adjacency matrix looks like this:

1 1 0 0 0 0 0 0
0 0 1 1 0 0 0 0
0 0 0 0 1 1 0 0
0 0 0 0 0 0 1 1
1 1 0 0 0 0 0 0
0 0 1 1 0 0 0 0
0 0 0 0 1 1 0 0
0 0 0 0 0 0 1 1

Examples

use turbo::{Code, CodeType, b3, ONE, ZERO};

let toy_code = Code {
  start_state: vec![ZERO, ZERO],
  polys: vec![b3::new([ZERO, ZERO, ONE]),
              b3::new([ONE, ONE, ZERO])],
  code_type: CodeType::FIRCode
};

assert_eq!(toy_code.state_adjacency(),
           vec![vec![ONE, ONE, ZERO, ZERO],
                vec![ZERO, ZERO, ONE, ONE],
                vec![ONE, ONE, ZERO, ZERO],
                vec![ZERO, ZERO, ONE, ONE]]);

fn next_states(&self, state_ind: usize) -> Vec<usize>

Computes the next states indices reachable given an index corresponding to an existing state index (numbered in monotonic ascending order).

Examples

use turbo::{Code, CodeType, b3, ONE, ZERO};

let toy_code = Code {
  start_state: vec![ZERO, ZERO],
  polys: vec![b3::new([ZERO, ZERO, ONE]),
              b3::new([ONE, ONE, ZERO])],
  code_type: CodeType::FIRCode
};

assert_eq!(toy_code.next_states(0),
           vec![0, 1]);
assert_eq!(toy_code.next_states(1),
           vec![2, 3]);
assert_eq!(toy_code.next_states(2),
           vec![0, 1]);
assert_eq!(toy_code.next_states(3),
           vec![2, 3]);

Trait Implementations

impl Encoder for Code

fn encode(&self, signal: &Vec<b1>) -> Vec<b1>

Encoder implementation for convolutional codes. Matches on code type, computing FIR and IIR codes separately.

impl MLDecoder for Code

fn estimate_states(
    &self,
    signal: &Vec<b1>
) -> (Dag<DecoderState, usize>, Vec<NodeIndex>)

Hard decision decoding, using the Hamming distance.

fn read_tree(
    &self,
    pruned_tree: (Dag<DecoderState, usize>, Vec<NodeIndex>)
) -> Vec<b1>

Reads back the maximum likelihood bits in reverse order from the pruned tree and the surviving leaf.

fn decode(&self, signal: &Vec<b1>) -> Vec<b1>

Runs the forward and backward steps of the decoder to produce the fully decoded string.