#include <llr.h>
Public Member Functions | |
LLR_calc_unit () | |
Constructor, using the default table resolution. | |
LLR_calc_unit (short int Dint1, short int Dint2, short int Dint3) | |
Constructor, using a specific table resolution. | |
void | init_llr_tables (short int Dint1=12, short int Dint2=300, short int Dint3=7) |
Set the quantization and table parameters. | |
QLLR | to_qllr (double l) const |
Convert a "real" LLR value to an LLR type. | |
QLLRvec | to_qllr (const vec &l) const |
Convert a vector of "real" LLR values to an LLR type. | |
QLLRmat | to_qllr (const mat &l) const |
Convert a matrix of "real" LLR values to an LLR type. | |
double | to_double (QLLR l) const |
Convert an LLR type to a "real" LLR. | |
vec | to_double (const QLLRvec &l) const |
Convert a vector of LLR types to a "real" LLR. | |
mat | to_double (const QLLRmat &l) const |
Convert a matrix of LLR types to a "real" LLR. | |
QLLR | jaclog (QLLR a, QLLR b) const |
Jacobian logarithm. | |
QLLR | Boxplus (QLLR a, QLLR b) const |
Hagenauer's "Boxplus" operator. | |
QLLR | logexp (QLLR x) const |
Logexp operator. | |
ivec | get_Dint () |
Retrieve the table resolution values. | |
Friends | |
std::ostream & | operator<< (std::ostream &os, const LLR_calc_unit &l) |
Print some properties of the LLR calculation unit in plain text. | |
Related Functions | |
(Note that these are not member functions.) | |
typedef signed int | QLLR |
typedef Vec< QLLR > | QLLRvec |
typedef Mat< QLLR > | QLLRmat |
const QLLR | QLLR_MAX = (std::numeric_limits<QLLR>::max() >> 4) |
This class contains functions for algebra with log-likelihood ratios (LLRs). The (sole) purpose of this class is to provide numerically efficient functions for turbo and LDPC codes, which rely on certain nonlinear operations on LLRs.
An LLR for an information bit b is defined according to
and it is in general a real number.
LLR values are represented via the special type, "quantized LLR" (QLLR). The relation between the quantized representation and the real (floating-point) LLR value is
The user parameter Dint1 determines the granularity of the quantization, and it can be set arbitrarily. The functions to_double() and to_qllr() can be used to perform conversions between the two representations (QLLR to floating-point, and vice versa).
The class provides functions for the computation of the Jacobian logarithm and Hagenauer's "boxplus" operator. These functions are based on a table-lookup. The resolution of the table is determined by the parameters Dint2 and Dint3. See the class constructor for more detail. When an object of LLR_calc_unit is created, corresponding lookup-tables are also generated. The resolution of these tables can be adjusted by providing parameters to the constructor.
The variable table resolution allows one to study complexity versus accuracy (i.e., how different table resolutions would degrade performance) to some extent. Yet the main purpose of the QLLR representation is to provide a tool for writing efficient simulation code, rather than to provide for bit-level (fixed-point) simulations. For bit-level simulations, a true fixed point representation of LLRs would be preferred/required. With the default setting of the table parameters, using the QLLR type is practically as accurate (but much faster) as using "double" to represent LLRs. Decoder implementations may then provide functions using QLLR, fixed-point, or double (for compatibility reasons) representations of LLR values.
Note: the QLLR type does not check that the correct quantization level is used. I.e., in theory it would be possible to add two QLLR types with different quantization (Dint) parameters. This is intentionally implemented this way to achieve maximum runtime efficiency.
itpp::LLR_calc_unit::LLR_calc_unit | ( | short int | Dint1, | |
short int | Dint2, | |||
short int | Dint3 | |||
) |
Constructor, using a specific table resolution.
See init_llr_tables() for more details on the parameters.
References init_llr_tables().
Hagenauer's "Boxplus" operator.
This function computes:
where
References it_info_debug, logexp(), and QLLR_MAX.
Referenced by itpp::LDPC_Code::bp_decode().
void itpp::LLR_calc_unit::init_llr_tables | ( | short int | Dint1 = 12 , |
|
short int | Dint2 = 300 , |
|||
short int | Dint3 = 7 | |||
) |
Set the quantization and table parameters.
Dint1 | Determines the relation between LLR represented as real number and as integer. The relation is
| |
Dint2 | Number of entries in the table. If this is zero, then logmap becomes logmax. | |
Dint3 | Determines the table resolution. The spacing between each entry is
|
Example: (recommended settings with "exact" computation via high resolution lookup table)
LLR_calc_unit lcalc(12, 300, 7);
Example: (recommended settings with logmax, i.e. no table lookup)
LLR_calc_unit lcalc(12, 0, 7);
Referenced by LLR_calc_unit().
Jacobian logarithm.
This function computes
References logexp(), and QLLR_MAX.
Referenced by itpp::Rec_Syst_Conv_Code::log_decode(), itpp::Rec_Syst_Conv_Code::log_decode_n2(), itpp::Modulator_ND::probabilities(), and itpp::Modulator_ND::update_LLR().
typedef signed int QLLR [related] |
The quantized log-likelihood ratio (QLLR) representation, scalar form. See LLR_calc_unit
.
The quantized log-likelihood ratio (QLLR) representation, matrix form. See LLR_calc_unit
.
The quantized log-likelihood ratio (QLLR) representation, vector form. See LLR_calc_unit
.