siso.h
Go to the documentation of this file.
#ifndef SISO_H
#define SISO_H
#include <itpp/itbase.h> //IT++ base module
#include <itpp/itexports.h>
namespace itpp
{
class ITPP_EXPORT SISO
{
public:
SISO();
void set_map_metric(const std::string &in_MAP_metric);
void set_precoder_generator(const itpp::bvec &in_prec_gen);
void set_precoder_generator(const int &in_prec_gen, const int &constraint_length);
void set_generators(const itpp::bmat &in_gen);
void set_generators(const itpp::ivec &in_gen, const int &constraint_length);
void set_tail(const bool &in_tail);
void set_viterbi_win_len(const int &win_len);
void set_sova_scaling_factor(const double &scaling_factor);
void set_sova_threshold(const double &threshold);
void set_viterbi_scaling_factors(const double &matching_scaling_factor,
const double &nonmatching_scaling_factor
);
void set_viterbi_hard_output_flag(const bool &flag);
//channel setup functions
void set_noise(const double &in_sigma2);
void set_impulse_response(const itpp::vec &h);
void set_impulse_response(const itpp::mat &H);
void set_impulse_response(const itpp::cvec &h);
void set_impulse_response(const itpp::cmat &cH);
void set_scrambler_pattern(const itpp::vec &phi);
void set_scrambler_pattern(const itpp::bvec &phi);
void set_mud_method(const std::string &method);
//demodulator and MIMO demapper setup
void set_constellation(const int &in_nb_bits_symb,
const itpp::cvec &in_constellation,
const itpp::bmat &in_bin_constellation
);
void set_constellation(const int &in_nb_bits_symb,
const itpp::cvec &in_constellation,
const itpp::ivec &in_int_constellation
);
void set_st_block_code(const int &Q,
const itpp::cmat &A,
const itpp::cmat &B,
const int &N
);
void set_demapper_method(const std::string &method);
void rsc(itpp::vec &extrinsic_coded,
itpp::vec &extrinsic_data,
const itpp::vec &intrinsic_coded,
const itpp::vec &apriori_data
);
void rsc(itpp::vec &extrinsic_coded,
itpp::vec &extrinsic_data,
const itpp::vec &intrinsic_coded,
const itpp::vec &apriori_data,
const bool &tail
);
void nsc(itpp::vec &extrinsic_coded,
itpp::vec &extrinsic_data,
const itpp::vec &intrinsic_coded,
const itpp::vec &apriori_data
);
void nsc(itpp::vec &extrinsic_coded,
itpp::vec &extrinsic_data,
const itpp::vec &intrinsic_coded,
const itpp::vec &apriori_data,
const bool &tail
);
void equalizer(itpp::vec &extrinsic_data,
const itpp::vec &rec_sig,
const itpp::vec &apriori_data
);
void equalizer(itpp::vec &extrinsic_data,
const itpp::vec &rec_sig,
const itpp::vec &apriori_data,
const bool &tail
);
void descrambler(itpp::vec &extrinsic_coded,
itpp::vec &extrinsic_data,
const itpp::vec &intrinsic_coded,
const itpp::vec &apriori_data
);
void mud(itpp::mat &extrinsic_data,
const itpp::vec &rec_sig,
const itpp::mat &apriori_data
);
void demapper(itpp::vec &extrinsic_data,
const itpp::cvec &rec_sig,
const itpp::vec &apriori_data
);
void demapper(itpp::vec &extrinsic_data,
const itpp::cmat &rec_sig,
const itpp::vec &apriori_data
);
static double threshold(const double &x, const double &value);
static itpp::vec threshold(const itpp::vec &in, const double &value);
static itpp::mat threshold(const itpp::mat &in, const double &value);
private:
void rsc_logMAP(itpp::vec &extrinsic_coded, itpp::vec &extrinsic_data,
const itpp::vec &intrinsic_coded, const itpp::vec &apriori_data);
void rsc_maxlogMAP(itpp::vec &extrinsic_coded, itpp::vec &extrinsic_data,
const itpp::vec &intrinsic_coded, const itpp::vec &apriori_data);
void rsc_sova(itpp::vec &extrinsic_data,
const itpp::vec &intrinsic_coded,
const itpp::vec &apriori_data,
const int &win_len
);
void rsc_viterbi(itpp::vec &extrinsic_coded,
itpp::vec &extrinsic_data,
const itpp::vec &intrinsic_coded,
const itpp::vec &apriori_data,
const int &win_len
);
void nsc_logMAP(itpp::vec &extrinsic_coded, itpp::vec &extrinsic_data,
const itpp::vec &intrinsic_coded, const itpp::vec &apriori_data);
void nsc_maxlogMAP(itpp::vec &extrinsic_coded, itpp::vec &extrinsic_data,
const itpp::vec &intrinsic_coded, const itpp::vec &apriori_data);
void equalizer_logMAP(itpp::vec &extrinsic_data, const itpp::vec &rec_sig,
const itpp::vec &apriori_data);
void equalizer_maxlogMAP(itpp::vec &extrinsic_data, const itpp::vec &rec_sig,
const itpp::vec &apriori_data);
void mud_maxlogMAP(itpp::mat &extrinsic_data, const itpp::vec &rec_sig,
const itpp::mat &apriori_data);
void mud_maxlogTMAP(itpp::mat &extrinsic_data, const itpp::vec &rec_sig,
const itpp::mat &apriori_data, const double &threshold=-5);
void GCD(itpp::mat &extrinsic_data, const itpp::vec &rec_sig,
const itpp::mat &apriori_data);
void sGCD(itpp::mat &extrinsic_data, const itpp::vec &rec_sig,
const itpp::mat &apriori_data);
void Hassibi_maxlogMAP(itpp::vec &extrinsic_data, const itpp::cmat &rec_sig,
const itpp::vec &apriori_data);
void GA(itpp::vec &extrinsic_data, const itpp::cmat &rec_sig,
const itpp::vec &apriori_data);
void sGA(itpp::vec &extrinsic_data, const itpp::cmat &rec_sig,
const itpp::vec &apriori_data);
void mmsePIC(itpp::vec &extrinsic_data, const itpp::cmat &rec_sig,
const itpp::vec &apriori_data);
void zfPIC(itpp::vec &extrinsic_data, const itpp::cmat &rec_sig,
const itpp::vec &apriori_data);
void Alamouti_maxlogMAP(itpp::vec &extrinsic_data, const itpp::cmat &rec_sig,
const itpp::vec &apriori_data);
void demodulator_logMAP(itpp::vec &extrinsic_data, const itpp::cvec &rec_sig,
const itpp::vec &apriori_data);
void demodulator_maxlogMAP(itpp::vec &extrinsic_data, const itpp::cvec &rec_sig,
const itpp::vec &apriori_data);
void print_err_msg(const std::string &msg) const;
// MAP algorithm variables
struct ITPP_EXPORT MAP_Metrics
{
enum Type {Unknown, logMAP, maxlogMAP, SOVA, Viterbi};
MAP_Metrics() : _t(Unknown) {}
MAP_Metrics(Type t) : _t(t) {}
operator Type () const {return _t;}
private:
Type _t;
template<typename T> operator T () const;
};
MAP_Metrics MAP_metric;
itpp::bmat gen;
itpp::bvec prec_gen;
bool tail;
// SOVA & Viterbi variables
int Viterbi_win_len;
double SOVA_scaling_factor;
double SOVA_threshold;
double Viterbi_scaling_factor[2];
bool Viterbi_hard_output_flag;
//channel variables
double sigma2;
itpp::mat impulse_response;
itpp::cmat c_impulse_response;
itpp::bvec scrambler_pattern;
struct ITPP_EXPORT MUD_Methods
{
enum Type {Unknown, sGCD, maxlogMAP, GCD};
MUD_Methods() : _t(Unknown) {}
MUD_Methods(Type t) : _t(t) {}
operator Type () const {return _t;}
private:
Type _t;
template<typename T> operator T () const;
};
MUD_Methods MUD_method;
//constellation variables
int nb_bits_symb;
itpp::cvec constellation;
itpp::bmat bin_constellation;
//Space Time block code variables
int symbols_block;
int nb_em_ant;
int nb_rec_ant;
int block_duration;
itpp::cmat ST_gen1;
itpp::cmat ST_gen2;
struct ITPP_EXPORT Demapper_Methods
{
enum Type {Unknown, GA, Hassibi_maxlogMAP, sGA, mmsePIC, zfPIC, Alamouti_maxlogMAP};
Demapper_Methods() : _t(Unknown) {}
Demapper_Methods(Type t) : _t(t) {}
operator Type () const {return _t;}
private:
Type _t;
template<typename T> operator T () const;
};
Demapper_Methods demapper_method;
//internal variables and functions
void zpFIRfilter(itpp::vec& filt,
const itpp::vec &h,
const itpp::vec &sig
);
void gen_chtrellis(void);
void gen_hyperTrellis(void);
struct
{
int numInputSymbols;
int stateNb;
int* prevState;
int* nextState;
double* output;
int* input;
} chtrellis;
void gen_rsctrellis(void);
struct
{
int numStates;
int* prevStates;
int* nextStates;
double* PARout;
itpp::bin* fm;
} rsctrellis;
void gen_nsctrellis(void);
struct
{
int stateNb;
int* prevState;
int* nextState;
double* output;
int* input;
} nsctrellis;
void find_half_const(int &select_half, itpp::vec &re_part,
itpp::bmat &re_bin_part, itpp::vec &im_part, itpp::bmat &im_bin_part);
void EquivRecSig(itpp::vec &x_eq, const itpp::cmat &rec_sig);
void EquivCh(itpp::mat &H_eq, const itpp::cvec &H);
void compute_symb_stats(itpp::vec &Es, itpp::vec &Vs,
int ns, int select_half, const itpp::vec &apriori_data,
const itpp::vec &re_part, const itpp::vec &im_part,
const itpp::bmat &re_bin_part, const itpp::bmat &im_bin_part);
static MAP_Metrics map_metric_from_string(const std::string &in_MAP_metric);
static MUD_Methods mud_method_from_string(const std::string &in_mud_method);
static Demapper_Methods demapper_method_from_string(const std::string &in_dem_method);
};
inline SISO::SISO()
{
tail = false;
MAP_metric = MAP_Metrics::maxlogMAP;
MUD_method = MUD_Methods::sGCD;
scrambler_pattern = "0";//corresponds to +1 using BPSK mapping
prec_gen = "1";
demapper_method = Demapper_Methods::GA;
Viterbi_win_len = 20;//should be set according to the generator polynomials
SOVA_scaling_factor = 0.8;//set according to Wang [2003]
SOVA_threshold = 10;//according to Wang [2003] an adaptive value should be used
Viterbi_scaling_factor[0] = 1.4;//according to Kerner [2009]
Viterbi_scaling_factor[1] = 0.4;
Viterbi_hard_output_flag = false;
}
inline SISO::MAP_Metrics SISO::map_metric_from_string(const std::string &in_MAP_metric)
{
if (in_MAP_metric=="logMAP")
{
return MAP_Metrics::logMAP;
} else if (in_MAP_metric=="maxlogMAP")
{
return MAP_Metrics::maxlogMAP;
} else if (in_MAP_metric=="SOVA")
{
return MAP_Metrics::SOVA;
} else if (in_MAP_metric=="Viterbi")
{
return MAP_Metrics::Viterbi;
} else
{
return MAP_Metrics::Unknown;
}
}
inline SISO::MUD_Methods SISO::mud_method_from_string(const std::string &in_mud_method)
{
if (in_mud_method=="maxlogMAP")
{
return MUD_Methods::maxlogMAP;
} else if (in_mud_method=="sGCD")
{
return MUD_Methods::sGCD;
} else if (in_mud_method=="GCD")
{
return MUD_Methods::GCD;
} else
{
return MUD_Methods::Unknown;
}
}
inline SISO::Demapper_Methods SISO::demapper_method_from_string(const std::string &in_dem_method)
{
if (in_dem_method=="Hassibi_maxlogMAP")
{
return Demapper_Methods::Hassibi_maxlogMAP;
} else if (in_dem_method=="Alamouti_maxlogMAP")
{
return Demapper_Methods::Alamouti_maxlogMAP;
} else if (in_dem_method=="GA")
{
return Demapper_Methods::GA;
} else if (in_dem_method=="sGA")
{
return Demapper_Methods::sGA;
} else if (in_dem_method=="mmsePIC")
{
return Demapper_Methods::mmsePIC;
} else if (in_dem_method=="zfPIC")
{
return Demapper_Methods::zfPIC;
} else
{
return Demapper_Methods::Unknown;
}
}
inline void SISO::set_map_metric(const std::string &in_MAP_metric)
{
MAP_metric = map_metric_from_string(in_MAP_metric);
}
inline void SISO::set_precoder_generator(const itpp::bvec &in_prec_gen)//set precoder polynomial
{
prec_gen = in_prec_gen;
}
inline void SISO::set_precoder_generator(const int &in_prec_gen,
const int &constraint_length)//set precoder polynomial
{
prec_gen = itpp::dec2bin(constraint_length, in_prec_gen);
}
inline void SISO::set_generators(const itpp::bmat &in_gen)
{
gen = in_gen;
}
inline void SISO::set_generators(const itpp::ivec &in_gen,
const int &constraint_length)
{
int nb_outputs = in_gen.length();
gen.set_size(nb_outputs, constraint_length);
for (int n=0; n<nb_outputs; n++)
gen.set_row(n, itpp::dec2bin(constraint_length, in_gen(n)));
}
inline void SISO::set_tail(const bool &in_tail)
{
tail = in_tail;
}
inline void SISO::set_viterbi_win_len(const int &win_len)
{
Viterbi_win_len = win_len;
}
inline void SISO::set_sova_scaling_factor(const double &scaling_factor)
{
SOVA_scaling_factor = scaling_factor;
}
inline void SISO::set_sova_threshold(const double &threshold)
{
SOVA_threshold = threshold;
}
inline void SISO::set_viterbi_scaling_factors(const double &matching_scaling_factor,
const double &nonmatching_scaling_factor)
{
Viterbi_scaling_factor[0] = matching_scaling_factor;
Viterbi_scaling_factor[1] = nonmatching_scaling_factor;
}
inline void SISO::set_viterbi_hard_output_flag(const bool &flag)
{
Viterbi_hard_output_flag = flag;
}
inline void SISO::set_noise(const double &in_sigma2)
{
sigma2 = in_sigma2;
}
inline void SISO::set_impulse_response(const itpp::vec &h)
{
impulse_response.set_size(1, h.length());
impulse_response.set_row(0, h);
}
inline void SISO::set_impulse_response(const itpp::mat &H)
{
impulse_response = H;
}
inline void SISO::set_impulse_response(const itpp::cvec &h)
{
c_impulse_response.set_size(1, h.length());
c_impulse_response.set_row(0, h);
}
inline void SISO::set_impulse_response(const itpp::cmat &cH)
{
c_impulse_response = cH;
}
inline void SISO::set_scrambler_pattern(const itpp::vec &phi)
{
int phi_len = phi.length();
scrambler_pattern.set_size(phi_len);
//scrambler_pattern = to_bvec((1-phi)/2);//BPSK mapping: 0->+1 and 1->-1
register int n;
for (n=0; n<phi_len; n++)
scrambler_pattern(n) = itpp::bin((1-int(phi(n)))/2);//BPSK mapping: 0->+1 and 1->-1
}
inline void SISO::set_scrambler_pattern(const itpp::bvec &phi)
{
scrambler_pattern = phi;
}
inline void SISO::set_mud_method(const std::string &method)
{
MUD_method = mud_method_from_string(method);
}
inline void SISO::set_constellation(const int &in_nb_bits_symb,
const itpp::cvec &in_constellation, const itpp::bmat &in_bin_constellation)
{
nb_bits_symb = in_nb_bits_symb;
constellation = in_constellation;
bin_constellation = in_bin_constellation;
}
inline void SISO::set_constellation(const int &in_nb_bits_symb,
const itpp::cvec &in_constellation, const itpp::ivec &in_int_constellation)
{
nb_bits_symb = in_nb_bits_symb;
int nb_symb = in_constellation.length();
constellation.set_size(nb_symb);
bin_constellation.set_size(nb_symb, nb_bits_symb);
for (int n=0; n<nb_symb; n++)
{
constellation(n) = in_constellation(in_int_constellation(n));
bin_constellation.set_row(n, itpp::dec2bin(nb_bits_symb, n));
}
}
inline void SISO::set_st_block_code(const int &Q, const itpp::cmat &A,
const itpp::cmat &B, const int &N)
{
symbols_block = Q;
nb_em_ant = A.cols();
nb_rec_ant = N;
block_duration = A.rows()/Q;
ST_gen1 = A;
ST_gen2 = B;
}
inline void SISO::set_demapper_method(const std::string &method)
{
demapper_method = demapper_method_from_string(method);
}
inline void SISO::rsc(itpp::vec &extrinsic_coded, itpp::vec &extrinsic_data,
const itpp::vec &intrinsic_coded, const itpp::vec &apriori_data, const bool &tail)
{
set_tail(tail);
rsc(extrinsic_coded, extrinsic_data, intrinsic_coded, apriori_data);
}
inline void SISO::rsc(itpp::vec &extrinsic_coded, itpp::vec &extrinsic_data,
const itpp::vec &intrinsic_coded, const itpp::vec &apriori_data)
{
if (gen.size()==0)
{
print_err_msg("SISO::rsc: generator polynomials not initialized");
return;
}
if (MAP_metric==MAP_Metrics::logMAP)
{
rsc_logMAP(extrinsic_coded, extrinsic_data, intrinsic_coded, apriori_data);
} else if (MAP_metric==MAP_Metrics::maxlogMAP)
{
rsc_maxlogMAP(extrinsic_coded, extrinsic_data, intrinsic_coded, apriori_data);
} else if (MAP_metric==MAP_Metrics::SOVA)
{
//no extrinsic information for coded bits is provided
rsc_sova(extrinsic_data, intrinsic_coded, apriori_data, Viterbi_win_len);
} else if (MAP_metric==MAP_Metrics::Viterbi)
{
rsc_viterbi(extrinsic_coded, extrinsic_data, intrinsic_coded, apriori_data, Viterbi_win_len);
} else
{
print_err_msg("SISO::rsc: unknown MAP metric. The MAP metric should be either logMAP or maxlogMAP or SOVA or Viterbi");
}
}
inline void SISO::nsc(itpp::vec &extrinsic_coded, itpp::vec &extrinsic_data,
const itpp::vec &intrinsic_coded, const itpp::vec &apriori_data, const bool &tail)
{
set_tail(tail);
nsc(extrinsic_coded, extrinsic_data, intrinsic_coded, apriori_data);
}
inline void SISO::nsc(itpp::vec &extrinsic_coded, itpp::vec &extrinsic_data,
const itpp::vec &intrinsic_coded, const itpp::vec &apriori_data)
{
if (gen.size()==0)
{
print_err_msg("SISO::nsc: generator polynomials not initialized");
return;
}
if (MAP_metric==MAP_Metrics::logMAP)
nsc_logMAP(extrinsic_coded, extrinsic_data, intrinsic_coded, apriori_data);
else if (MAP_metric==MAP_Metrics::maxlogMAP)
nsc_maxlogMAP(extrinsic_coded, extrinsic_data, intrinsic_coded, apriori_data);
else
print_err_msg("SISO::nsc: unknown MAP metric. The MAP metric should be either logMAP or maxlogMAP");
}
inline void SISO::equalizer(itpp::vec &extrinsic_data,
const itpp::vec &rec_sig,
const itpp::vec &apriori_data,
const bool &tail
)
{
set_tail(tail);
equalizer(extrinsic_data, rec_sig, apriori_data);
}
inline void SISO::equalizer(itpp::vec &extrinsic_data, const itpp::vec &rec_sig,
const itpp::vec &apriori_data)
{
if (impulse_response.size()==0)
{
print_err_msg("SISO::equalizer: channel impulse response not initialized");
return;
}
if ((impulse_response.size()==1)&&(prec_gen.length()==1))
{
print_err_msg("SISO::equalizer: flat fading channel and no precoder. Use the soft output of the channel (no need for a priori information)");
return;
}
if (MAP_metric==MAP_Metrics::logMAP)
equalizer_logMAP(extrinsic_data, rec_sig, apriori_data);
else if (MAP_metric==MAP_Metrics::maxlogMAP)
equalizer_maxlogMAP(extrinsic_data, rec_sig, apriori_data);
else
print_err_msg("SISO::equalizer: unknown MAP metric. The MAP metric should be either logMAP or maxlogMAP");
}
inline void SISO::mud(itpp::mat &extrinsic_data, const itpp::vec &rec_sig,
const itpp::mat &apriori_data)
{
if (impulse_response.size()==0)
{
print_err_msg("SISO::mud: channel impulse response not initialized");
return;
}
if (impulse_response.rows()!=apriori_data.rows())
{
print_err_msg("SISO::mud: channel impulse response must have the same number of rows as a priori info.");
return;
}
if (MUD_method==MUD_Methods::maxlogMAP)
mud_maxlogMAP(extrinsic_data, rec_sig, apriori_data);
else if (MUD_method==MUD_Methods::GCD)
GCD(extrinsic_data, rec_sig, apriori_data);
else if (MUD_method==MUD_Methods::sGCD)
sGCD(extrinsic_data, rec_sig, apriori_data);
else
print_err_msg("SISO::mud: unknown MUD method. The MUD method should be either maxlogMAP, GCD or sGCD");
}
inline void SISO::demapper(itpp::vec &extrinsic_data, const itpp::cvec &rec_sig,
const itpp::vec &apriori_data)
{
if (c_impulse_response.size()==0)
{
print_err_msg("SISO::demapper: channel impulse response not initialized");
return;
}
if ((constellation.size()==0) || (bin_constellation.size()==0))
{
print_err_msg("SISO::demapper: constellation not initialized");
return;
}
if (MAP_metric==MAP_Metrics::logMAP)
demodulator_logMAP(extrinsic_data, rec_sig, apriori_data);
else if (MAP_metric==MAP_Metrics::maxlogMAP)
demodulator_maxlogMAP(extrinsic_data, rec_sig, apriori_data);
else
print_err_msg("SISO::demapper: unknown MAP metric. The MAP metric should be either logMAP or maxlogMAP");
}
inline void SISO::demapper(itpp::vec &extrinsic_data, const itpp::cmat &rec_sig,
const itpp::vec &apriori_data)
{
if (c_impulse_response.size()==0)
{
print_err_msg("SISO::demapper: channel impulse response not initialized");
return;
}
if ((ST_gen1.size()==0) || (ST_gen2.size()==0))
{
print_err_msg("SISO::demapper: Space-Time generator polynomials not initialized");
return;
}
if ((constellation.size()==0) || (bin_constellation.size()==0))
{
print_err_msg("SISO::demapper: constellation not initialized");
return;
}
if (demapper_method==Demapper_Methods::Hassibi_maxlogMAP)
Hassibi_maxlogMAP(extrinsic_data, rec_sig, apriori_data);
else if (demapper_method==Demapper_Methods::GA)
GA(extrinsic_data, rec_sig, apriori_data);
else if (demapper_method==Demapper_Methods::sGA)
sGA(extrinsic_data, rec_sig, apriori_data);
else if (demapper_method==Demapper_Methods::mmsePIC)
mmsePIC(extrinsic_data, rec_sig, apriori_data);
else if (demapper_method==Demapper_Methods::zfPIC)
zfPIC(extrinsic_data, rec_sig, apriori_data);
else if (demapper_method==Demapper_Methods::Alamouti_maxlogMAP)
Alamouti_maxlogMAP(extrinsic_data, rec_sig, apriori_data);
else
print_err_msg("SISO::demapper: unknown demapper method. The demapper method should be either Hassibi_maxlogMAP, GA, sGA, mmsePIC, zfPIC or Alamouti_maxlogMAP");
}
inline void SISO::print_err_msg(const std::string &msg) const
{
#ifdef mex_h
mexErrMsgTxt(msg.c_str());
#else
std::cout << msg << std::endl;
#endif
}
inline double SISO::threshold(const double &x, const double &value)
{
if ((x>value)||(x<-value))
return (x>0?value:-value);
return x;
}
inline itpp::vec SISO::threshold(const itpp::vec &in, const double &value)
{
itpp::vec out(in.length());
register int n;
for (n=0; n<in.length(); n++)
out(n) = threshold(in(n), value);
return out;
}
inline itpp::mat SISO::threshold(const itpp::mat &in, const double &value)
{
itpp::mat out(in.rows(),in.cols());
register int n;
for (n=0; n<in.rows(); n++)
out.set_row(n, threshold(in.get_row(n), value));
return out;
}
}
#endif /*SISO_H_*/
itpp::SISO::demapper
void demapper(itpp::vec &extrinsic_data, const itpp::cvec &rec_sig, const itpp::vec &apriori_data)
SISO demapper (when only a modulator is used)
Definition: siso.h:836
itpp::SISO::set_map_metric
void set_map_metric(const std::string &in_MAP_metric)
Sets the metric for MAP algorithm (convolutional codes and multipath channels)
Definition: siso.h:574
itpp::SISO::set_mud_method
void set_mud_method(const std::string &method)
Sets Multi-User Detector method.
Definition: siso.h:678
itpp::SISO::nsc
void nsc(itpp::vec &extrinsic_coded, itpp::vec &extrinsic_data, const itpp::vec &intrinsic_coded, const itpp::vec &apriori_data)
SISO decoder for NSC codes
Definition: siso.h:763
itpp::SISO::set_tail
void set_tail(const bool &in_tail)
Signals whether the trellis used in the MAP algorithm is terminated or not (only for convolutional co...
Definition: siso.h:604
itpp::SISO::set_demapper_method
void set_demapper_method(const std::string &method)
Sets demapper method.
Definition: siso.h:716
itpp::SISO::set_sova_threshold
void set_sova_threshold(const double &threshold)
Sets the threshold value used to limit the reliability value computed by SOVA.
Definition: siso.h:619
itpp::SISO::set_scrambler_pattern
void set_scrambler_pattern(const itpp::vec &phi)
Sets scrambler pattern.
Definition: siso.h:663
itpp::SISO::set_impulse_response
void set_impulse_response(const itpp::vec &h)
Sets channel impulse response for equalizer.
Definition: siso.h:641
itpp::SISO::prevStates
int * prevStates
previous states
Definition: siso.h:462
itpp::SISO::stateNb
int stateNb
number of states
Definition: siso.h:450
itpp::SISO::nextStates
int * nextStates
next states
Definition: siso.h:463
itpp::SISO::set_constellation
void set_constellation(const int &in_nb_bits_symb, const itpp::cvec &in_constellation, const itpp::bmat &in_bin_constellation)
Sets symbol constellation.
Definition: siso.h:683
itpp::SISO::PARout
double * PARout
parity output bit
Definition: siso.h:464
itpp::SISO::set_viterbi_scaling_factors
void set_viterbi_scaling_factors(const double &matching_scaling_factor, const double &nonmatching_scaling_factor)
Sets the Viterbi algorithm scaling factors.
Definition: siso.h:624
itpp::SISO::prevState
int * prevState
previous states
Definition: siso.h:451
itpp
itpp namespace
Definition: itmex.h:36
itbase.h
Include file for the IT++ base module.
itpp::SISO::output
double * output
output
Definition: siso.h:453
itpp::dec2bin
ITPP_EXPORT bvec dec2bin(int length, int index)
Convert a decimal int index to bvec using length bits in the representation.
itpp::SISO::set_sova_scaling_factor
void set_sova_scaling_factor(const double &scaling_factor)
Sets the scaling factor used to normalize the reliability value computed by the SOVA.
Definition: siso.h:614
itpp::SISO::mud
void mud(itpp::mat &extrinsic_data, const itpp::vec &rec_sig, const itpp::mat &apriori_data)
SISO Multi-User Detector
Definition: siso.h:812
itpp::SISO::numInputSymbols
int numInputSymbols
number of input symbols
Definition: siso.h:449
itpp::SISO::set_noise
void set_noise(const double &in_sigma2)
Sets Additive White Gaussian Noise variance for each dimension.
Definition: siso.h:636
itpp::bin
Binary arithmetic (boolean) class.
Definition: binary.h:56
itpp::SISO::numStates
int numStates
number of states
Definition: siso.h:461
itpp::SISO::rsc
void rsc(itpp::vec &extrinsic_coded, itpp::vec &extrinsic_data, const itpp::vec &intrinsic_coded, const itpp::vec &apriori_data)
SISO decoder for RSC codes
Definition: siso.h:728
itpp::SISO::threshold
static double threshold(const double &x, const double &value)
Functions used to limit values at a given +- threshold.
Definition: siso.h:901
itpp::SISO::nextState
int * nextState
next states
Definition: siso.h:452
itpp::SISO::input
int * input
input
Definition: siso.h:454
itpp::SISO::SISO
SISO()
SISO class constructor
Definition: siso.h:495
itpp::SISO
Soft Input Soft Output (SISO) modules.
Definition: siso.h:71
itpp::SISO::equalizer
void equalizer(itpp::vec &extrinsic_data, const itpp::vec &rec_sig, const itpp::vec &apriori_data)
SISO equalizer
Definition: siso.h:790
itpp::SISO::set_viterbi_win_len
void set_viterbi_win_len(const int &win_len)
Sets the length of the trellis used by the SOVA.
Definition: siso.h:609
itpp::SISO::set_st_block_code
void set_st_block_code(const int &Q, const itpp::cmat &A, const itpp::cmat &B, const int &N)
Sets Space-Time block code parameters.
Definition: siso.h:705
itpp::SISO::set_viterbi_hard_output_flag
void set_viterbi_hard_output_flag(const bool &flag)
Sets the Viterbi algorithm hard output flag (true when only the hard output is needed) ...
Definition: siso.h:631
itpp::SISO::set_precoder_generator
void set_precoder_generator(const itpp::bvec &in_prec_gen)
Sets the precoder generator polynomial for turbo equalizer.
Definition: siso.h:579
bmat
Mat< bin > bmat
bin matrix
Definition: mat.h:508
itpp::SISO::set_generators
void set_generators(const itpp::bmat &in_gen)
Sets convolutional code generator polynomials.
Definition: siso.h:590

Generated on Sat Sep 30 2017 07:04:09 for IT++ by Doxygen 1.8.13