Enum ldpc_toolbox::decoder::factory::DecoderImplementation

pub enum DecoderImplementation {
    Phif64,
    Phif32,
    Tanhf64,
    Tanhf32,
    Minstarapproxf64,
    Minstarapproxf32,
    Minstarapproxi8,
    Minstarapproxi8Jones,
    Minstarapproxi8PartialHardLimit,
    Minstarapproxi8JonesPartialHardLimit,
    Minstarapproxi8Deg1Clip,
    Minstarapproxi8JonesDeg1Clip,
    Minstarapproxi8PartialHardLimitDeg1Clip,
    Minstarapproxi8JonesPartialHardLimitDeg1Clip,
    Aminstarf64,
    Aminstarf32,
    Aminstari8,
    Aminstari8Jones,
    Aminstari8PartialHardLimit,
    Aminstari8JonesPartialHardLimit,
    Aminstari8Deg1Clip,
    Aminstari8JonesDeg1Clip,
    Aminstari8PartialHardLimitDeg1Clip,
    Aminstari8JonesPartialHardLimitDeg1Clip,
    HLPhif64,
    HLPhif32,
    HLTanhf64,
    HLTanhf32,
    HLMinstarapproxf64,
    HLMinstarapproxf32,
    HLMinstarapproxi8,
    HLMinstarapproxi8PartialHardLimit,
    HLAminstarf64,
    HLAminstarf32,
    HLAminstari8,
    HLAminstari8PartialHardLimit,
}

LDPC decoder implementation.

This enum lists the LDPC decoder implementations corresponding to different arithmetic rules.

Variants

Phif64

The Phif64 implementation, using f64 and the involution phi(x). This uses a flooding schedule.

Phif32

The Phif32 implementation, using f32 and the involution phi(x). This uses a flooding schedule.

Tanhf64

The Tanhf64 implementation, using f64 and the tanh rule. This uses a flooding schedule.

Tanhf32

The Tanhf32 implementation, using f32 and the tanh rule. This uses a flooding schedule.

Minstarapproxf64

The Minstarapproxf64 implementation, using f64 and an approximation to the min* function. This uses a flooding schedule.

Minstarapproxf32

The Minstarapproxf32 implementation, using f32 and an approximation to the min* function. This uses a flooding schedule.

Minstarapproxi8

The Minstarapproxi8 implementation, using 8-bit quantization and a quantized approximation to the min* function (implemented using small table lookup). This uses a flooding schedule.

Minstarapproxi8Jones

The Minstarapproxi8Jones implementation, using 8-bit quantization, a quantized approximation to the min* function (implemented using small table lookup), and Jones clipping for variable nodes. This uses a flooding schedule.

Minstarapproxi8PartialHardLimit

The Minstarapproxi8PartialHardLimit implementation, using 8-bit quantization, a quantized approximation to the min* function (implemented using small table lookup), and partial hard-limiting for check nodes. This uses a flooding schedule.

Minstarapproxi8JonesPartialHardLimit

The Minstarapproxi8JonesPartialHardLimit implementation, using 8-bit quantization, a quantized approximation to the min* function (implemented using small table lookup), Jones clipping for variable nodes, and partial hard-limiting for check nodes. This uses a flooding schedule.

Minstarapproxi8Deg1Clip

The Minstarapproxi8Deg1Clip implementation, using 8-bit quantization, a quantized approximation to the min* function (implemented using small table lookup), and degree-1 variable node clipping. This uses a flooding schedule.

Minstarapproxi8JonesDeg1Clip

The Minstarapproxi8JonesDeg1Clip implementation, using 8-bit quantization, a quantized approximation to the min* function (implemented using small table lookup), Jones clipping for variable nodes, and degree-1 variable node clipping. This uses a flooding schedule.

Minstarapproxi8PartialHardLimitDeg1Clip

The Minstarapproxi8PartialHardLimitDeg1Clip implementation, using 8-bit quantization, a quantized approximation to the min* function (implemented using small table lookup), partial hard-limiting for check nodes, and degree-1 variable node clipping. This uses a flooding schedule.

Minstarapproxi8JonesPartialHardLimitDeg1Clip

The Minstarapproxi8JonesPartialHardLimitDeg1Clip implementation, using 8-bit quantization, a quantized approximation to the min* function (implemented using small table lookup), Jones clipping for variable nodes, partial hard-limiting for check nodes, and degree-1 variable node clipping. This uses a flooding schedule.

Aminstarf64

The Aminstarf64 implementation, using f64 and an approximation to the min* function. This uses a flooding schedule.

Aminstarf32

The Aminstarf32 implementation, using f32 and an approximation to the min* function. This uses a flooding schedule.

Aminstari8

The Aminstari8 implementation, using 8-bit quantization and a quantized approximation to the min* function (implemented using small table lookup). This uses a flooding schedule.

Aminstari8Jones

The Aminstari8Jones implementation, using 8-bit quantization, a quantized approximation to the min* function (implemented using small table lookup), and Jones clipping for variable nodes. This uses a flooding schedule.

Aminstari8PartialHardLimit

The Aminstari8PartialHardLimit implementation, using 8-bit quantization, a quantized approximation to the min* function (implemented using small table lookup), and partial hard-limiting for check nodes. This uses a flooding schedule.

Aminstari8JonesPartialHardLimit

The Aminstari8JonesPartialHardLimit implementation, using 8-bit quantization, a quantized approximation to the min* function (implemented using small table lookup), Jones clipping for variable nodes, and partial hard-limiting for check nodes. This uses a flooding schedule.

Aminstari8Deg1Clip

The Aminstari8Deg1Clip implementation, using 8-bit quantization, a quantized approximation to the min* function (implemented using small table lookup), and degree-1 variable node clipping. This uses a flooding schedule.

Aminstari8JonesDeg1Clip

The Aminstari8JonesDeg1Clip implementation, using 8-bit quantization, a quantized approximation to the min* function (implemented using small table lookup), Jones clipping for variable nodes, and degree-1 variable node clipping. This uses a flooding schedule.

Aminstari8PartialHardLimitDeg1Clip

The Aminstari8PartialHardLimitDeg1Clip implementation, using 8-bit quantization, a quantized approximation to the min* function (implemented using small table lookup), partial hard-limiting for check nodes, and degree-1 variable node clipping. This uses a flooding schedule.

Aminstari8JonesPartialHardLimitDeg1Clip

The Aminstari8JonesPartialHardLimitDeg1Clip implementation, using 8-bit quantization, a quantized approximation to the min* function (implemented using small table lookup), Jones clipping for variable nodes, partial hard-limiting for check nodes, and degree-1 variable node clipping. This uses a flooding schedule.

HLPhif64

The Phif64 implementation, using f64 and the involution phi(x). This uses a horizontal layered schedule.

HLPhif32

The Phif32 implementation, using f32 and the involution phi(x). This uses a horizontal layered schedule.

HLTanhf64

The Tanhf64 implementation, using f64 and the tanh rule. This uses a horizontal layered schedule.

HLTanhf32

The Tanhf32 implementation, using f32 and the tanh rule. This uses a horizontal layered schedule.

HLMinstarapproxf64

The Minstarapproxf64 implementation, using f64 and an approximation to the min* function. This uses a horizontal layered schedule.

HLMinstarapproxf32

The Minstarapproxf32 implementation, using f32 and an approximation to the min* function. This uses a horizontal layered schedule.

HLMinstarapproxi8

The Minstarapproxi8 implementation, using 8-bit quantization and a quantized approximation to the min* function (implemented using small table lookup). This uses a horizontal layered schedule.

HLMinstarapproxi8PartialHardLimit

The Minstarapproxi8PartialHardLimit implementation, using 8-bit quantization, a quantized approximation to the min* function (implemented using small table lookup), and partial hard-limiting for check nodes. This uses a horizontal layered schedule.

HLAminstarf64

The Aminstarf64 implementation, using f64 and an approximation to the min* function. This uses a horizontal layered schedule.

HLAminstarf32

The Aminstarf32 implementation, using f32 and an approximation to the min* function. This uses a horizontal layered schedule.

HLAminstari8

The Aminstari8 implementation, using 8-bit quantization and a quantized approximation to the min* function (implemented using small table lookup). This uses a horizontal layered schedule.

HLAminstari8PartialHardLimit

The Aminstari8PartialHardLimit implementation, using 8-bit quantization, a quantized approximation to the min* function (implemented using small table lookup), and partial hard-limiting for check nodes. This uses a horizontal layered schedule.

Implementations

impl DecoderImplementation

pub fn build_decoder(&self, h: SparseMatrix) -> Box<dyn LdpcDecoder>

Builds and LDPC decoder.

Given a parity check matrix, this function builds an LDPC decoder corresponding to this decoder implementation.

Trait Implementations

impl Clone for DecoderImplementation

fn clone(&self) -> DecoderImplementation

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for DecoderImplementation

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for DecoderImplementation

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl FromStr for DecoderImplementation

type Err = &'static str

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl Hash for DecoderImplementation

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq<DecoderImplementation> for DecoderImplementation

fn eq(&self, other: &DecoderImplementation) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for DecoderImplementation

impl Eq for DecoderImplementation

impl StructuralEq for DecoderImplementation

impl StructuralPartialEq for DecoderImplementation