IT++ Logo Newcom Logo

itpp::LLR_calc_unit Class Reference

Log-likelihood algebra calculation unit. More...

#include <itpp/comm/llr.h>

List of all members.

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 (const double &l)
 Convert a "real" LLR value to an LLR type.
QLLRvec to_qllr (const vec &l)
 Convert a vector of "real" LLR values to an LLR type.
QLLRmat to_qllr (const mat &l)
 Convert a matrix of "real" LLR values to an LLR type.
double to_double (const QLLR &l) const
 Convert an LLR type to a "real" LLR.
vec to_double (const QLLRvec &l)
 Convert a vector of LLR types to a "real" LLR.
mat to_double (const QLLRmat &l)
 Convert a matrix of LLR types to a "real" LLR.
QLLR jaclog (QLLR a, QLLR b)
 Jacobian logarithm.
QLLR Boxplus (QLLR a, QLLR b)
 Hagenauer's "Boxplus" operator.
QLLR logexp (QLLR x)
 Logexp operator.
ivec get_Dint ()
 Retrieve the table resolution values.
void operator= (const LLR_calc_unit &)
 Assignment operator for LLR_calc_unit.

Friends

std::ostream & operator<< (std::ostream &os, const LLR_calc_unit &lcu)
 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< QLLRQLLRvec
typedef Mat< QLLRQLLRmat
const QLLR QLLR_MAX = (std::numeric_limits<QLLR>::max() >> 2)


Detailed Description

Log-likelihood algebra calculation unit.

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

\[ L = \log \frac{P(b=0)}{P(b=1)} \]

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

\[ \mbox{QLLR} = \mbox{round} ((1<<\mbox{Dint1})*\mbox{LLR}) \]

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.

Definition at line 117 of file llr.h.


Constructor & Destructor Documentation

itpp::LLR_calc_unit::LLR_calc_unit (  ) 

Constructor, using the default table resolution.

Definition at line 40 of file llr.cpp.

References init_llr_tables().

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 detail on the parameters.

Definition at line 45 of file llr.cpp.

References init_llr_tables().


Member Function Documentation

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.

Parameters:
Dint1 Determines the relation between LLR represented as real number and as integer. The relation is

\[ \mbox{QLLR} = \mbox{round} ((1<<\mbox{Dint1})*\mbox{LLR}) \]

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

\[ 2^{-(Dint1-Dint3)} \]

The default parameter values are chosen to give a performance practically indistinguishable from that of using floating point calculations.

Definition at line 69 of file llr.cpp.

Referenced by LLR_calc_unit().

QLLR itpp::LLR_calc_unit::to_qllr ( const double &  l  )  [inline]

Convert a "real" LLR value to an LLR type.

Definition at line 217 of file llr.h.

References itpp::floor(), it_assert0, QLLR_MAX, and to_double().

Referenced by itpp::Rec_Syst_Conv_Code::log_decode(), itpp::Rec_Syst_Conv_Code::log_decode_n2(), itpp::Modulator_NCD::map_demod(), itpp::Modulator_NRD::map_demod(), and to_qllr().

QLLRvec itpp::LLR_calc_unit::to_qllr ( const vec &  l  ) 

Convert a vector of "real" LLR values to an LLR type.

Definition at line 91 of file llr.cpp.

References itpp::length(), and to_qllr().

QLLRmat itpp::LLR_calc_unit::to_qllr ( const mat &  l  ) 

Convert a matrix of "real" LLR values to an LLR type.

Definition at line 109 of file llr.cpp.

References to_qllr().

double itpp::LLR_calc_unit::to_double ( const QLLR l  )  const [inline]

Convert an LLR type to a "real" LLR.

Definition at line 158 of file llr.h.

Referenced by itpp::Rec_Syst_Conv_Code::log_decode(), itpp::Rec_Syst_Conv_Code::log_decode_n2(), itpp::operator<<(), to_double(), and to_qllr().

vec itpp::LLR_calc_unit::to_double ( const QLLRvec l  ) 

Convert a vector of LLR types to a "real" LLR.

Definition at line 100 of file llr.cpp.

References itpp::length(), and to_double().

mat itpp::LLR_calc_unit::to_double ( const QLLRmat l  ) 

Convert a matrix of LLR types to a "real" LLR.

Definition at line 121 of file llr.cpp.

References itpp::Mat< Num_T >::cols(), itpp::Mat< Num_T >::rows(), and to_double().

QLLR itpp::LLR_calc_unit::jaclog ( QLLR  a,
QLLR  b 
) [inline]

Jacobian logarithm.

This function computes

\[ \log(\exp(a)+\exp(b)) \]

Definition at line 280 of file llr.h.

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().

QLLR itpp::LLR_calc_unit::Boxplus ( QLLR  a,
QLLR  b 
) [inline]

Hagenauer's "Boxplus" operator.

This function computes

\[ \mbox{sign}(a)*\mbox{sign}(b)*\mbox{min}(|a|,|b|)+f(|a+b|)-f(|a-b|) \]

where

\[ f(x) = \log(1+\exp(-x)) \]

Definition at line 224 of file llr.h.

References logexp(), and QLLR_MAX.

QLLR itpp::LLR_calc_unit::logexp ( QLLR  x  )  [inline]

Logexp operator.

This function computes

\[ f(x) = \log(1+\exp(-x)) \]

Definition at line 261 of file llr.h.

References it_assert0.

Referenced by Boxplus(), and jaclog().

ivec itpp::LLR_calc_unit::get_Dint (  ) 

Retrieve the table resolution values.

Definition at line 60 of file llr.cpp.

void itpp::LLR_calc_unit::operator= ( const LLR_calc_unit  ) 

Assignment operator for LLR_calc_unit.

Definition at line 51 of file llr.cpp.

References Dint1, Dint2, Dint3, and logexp_table.


Friends And Related Function Documentation

typedef signed int QLLR [related]

The quantized log-likelihood ratio (QLLR) representation, scalar form. See LLR_calc_unit.

Definition at line 50 of file llr.h.

typedef Vec<QLLR> QLLRvec [related]

The quantized log-likelihood ratio (QLLR) representation, vector form. See LLR_calc_unit.

Definition at line 55 of file llr.h.

typedef Mat<QLLR> QLLRmat [related]

The quantized log-likelihood ratio (QLLR) representation, matrix form. See LLR_calc_unit.

Definition at line 60 of file llr.h.

const QLLR QLLR_MAX = (std::numeric_limits<QLLR>::max() >> 2) [related]

The largest possible QLLR value

Definition at line 65 of file llr.h.

Referenced by Boxplus(), jaclog(), itpp::operator<<(), and to_qllr().

std::ostream & operator<< ( std::ostream &  os,
const LLR_calc_unit lcu 
) [friend]

Print some properties of the LLR calculation unit in plain text.

Definition at line 133 of file llr.cpp.


The documentation for this class was generated from the following files:
SourceForge Logo

Generated on Fri Jun 8 01:07:24 2007 for IT++ by Doxygen 1.5.2