IT++ Logo
siso.h
Go to the documentation of this file.
00001 
00029 #ifndef SISO_H
00030 #define SISO_H
00031 
00032 #include <itpp/itbase.h> //IT++ base module
00033 
00034 namespace itpp
00035 {
00036 
00053 class SISO
00054 {
00055 public:
00057 
00064     SISO();
00066 
00074     void set_map_metric(const std::string &in_MAP_metric);
00076 
00079     void set_precoder_generator(const itpp::bvec &in_prec_gen);
00080     void set_precoder_generator(const int &in_prec_gen, const int &constraint_length);
00082 
00085     void set_generators(const itpp::bmat &in_gen);
00086     void set_generators(const itpp::ivec &in_gen, const int &constraint_length);
00088 
00092     void set_tail(const bool &in_tail);
00094     void set_viterbi_win_len(const int &win_len);
00096     void set_sova_scaling_factor(const double &scaling_factor);
00098     void set_sova_threshold(const double &threshold);
00100     void set_viterbi_scaling_factors(const double &matching_scaling_factor, 
00101                                      const double &nonmatching_scaling_factor 
00102                                     );
00104     void set_viterbi_hard_output_flag(const bool &flag);
00105     //channel setup functions
00107     void set_noise(const double &in_sigma2);
00109 
00111     void set_impulse_response(const itpp::vec &h);
00113 
00115     void set_impulse_response(const itpp::mat &H);
00117 
00119     void set_impulse_response(const itpp::cvec &h);
00121 
00142     void set_impulse_response(const itpp::cmat &cH);
00144 
00148     void set_scrambler_pattern(const itpp::vec &phi);
00149     void set_scrambler_pattern(const itpp::bvec &phi);
00151 
00156     void set_mud_method(const std::string &method);
00157     //demodulator and MIMO demapper setup
00159 
00161     void set_constellation(const int &in_nb_bits_symb, 
00162                            const itpp::cvec &in_constellation, 
00163                            const itpp::bmat &in_bin_constellation 
00164                           );
00165     void set_constellation(const int &in_nb_bits_symb, 
00166                            const itpp::cvec &in_constellation, 
00167                            const itpp::ivec &in_int_constellation 
00168                           );
00170 
00172     void set_st_block_code(const int &Q, 
00173                            const itpp::cmat &A, 
00174                            const itpp::cmat &B, 
00175                            const int &N 
00176                           );
00178 
00188     void set_demapper_method(const std::string &method);
00190     void rsc(itpp::vec &extrinsic_coded, 
00191              itpp::vec &extrinsic_data, 
00192              const itpp::vec &intrinsic_coded, 
00193              const itpp::vec &apriori_data 
00194             );
00196     void rsc(itpp::vec &extrinsic_coded, 
00197              itpp::vec &extrinsic_data, 
00198              const itpp::vec &intrinsic_coded, 
00199              const itpp::vec &apriori_data, 
00200              const bool &tail 
00201             );
00203     void nsc(itpp::vec &extrinsic_coded, 
00204              itpp::vec &extrinsic_data, 
00205              const itpp::vec &intrinsic_coded, 
00206              const itpp::vec &apriori_data 
00207             );
00209     void nsc(itpp::vec &extrinsic_coded, 
00210              itpp::vec &extrinsic_data, 
00211              const itpp::vec &intrinsic_coded, 
00212              const itpp::vec &apriori_data, 
00213              const bool &tail 
00214             );
00216 
00219     void equalizer(itpp::vec &extrinsic_data, 
00220                    const itpp::vec &rec_sig, 
00221                    const itpp::vec &apriori_data 
00222                   );
00224 
00227     void equalizer(itpp::vec &extrinsic_data, 
00228                    const itpp::vec &rec_sig, 
00229                    const itpp::vec &apriori_data,  
00230                    const bool &tail 
00231                   );
00233     void descrambler(itpp::vec &extrinsic_coded, 
00234                      itpp::vec &extrinsic_data, 
00235                      const itpp::vec &intrinsic_coded, 
00236                      const itpp::vec &apriori_data 
00237                     );
00239     void mud(itpp::mat &extrinsic_data, 
00240              const itpp::vec &rec_sig, 
00241              const itpp::mat &apriori_data 
00242             );
00244     void demapper(itpp::vec &extrinsic_data, 
00245                   const itpp::cvec &rec_sig, 
00246                   const itpp::vec &apriori_data 
00247                  );
00249     void demapper(itpp::vec &extrinsic_data, 
00250                   const itpp::cmat &rec_sig, 
00251                   const itpp::vec &apriori_data 
00252                  );
00254     static double threshold(const double &x, const double &value);
00255     static itpp::vec threshold(const itpp::vec &in, const double &value);
00256     static itpp::mat threshold(const itpp::mat &in, const double &value);
00257 private:
00259     void rsc_logMAP(itpp::vec &extrinsic_coded, itpp::vec &extrinsic_data,
00260                     const itpp::vec &intrinsic_coded, const itpp::vec &apriori_data);
00262     void rsc_maxlogMAP(itpp::vec &extrinsic_coded, itpp::vec &extrinsic_data,
00263                        const itpp::vec &intrinsic_coded, const itpp::vec &apriori_data);
00265     void rsc_sova(itpp::vec &extrinsic_data, 
00266                   const itpp::vec &intrinsic_coded, 
00267                   const itpp::vec &apriori_data, 
00268                   const int &win_len 
00269                  );
00271     void rsc_viterbi(itpp::vec &extrinsic_coded, 
00272                      itpp::vec &extrinsic_data, 
00273                      const itpp::vec &intrinsic_coded, 
00274                      const itpp::vec &apriori_data, 
00275                      const int &win_len 
00276                     );
00278     void nsc_logMAP(itpp::vec &extrinsic_coded, itpp::vec &extrinsic_data,
00279                     const itpp::vec &intrinsic_coded, const itpp::vec &apriori_data);
00281     void nsc_maxlogMAP(itpp::vec &extrinsic_coded, itpp::vec &extrinsic_data,
00282                        const itpp::vec &intrinsic_coded, const itpp::vec &apriori_data);
00284     void equalizer_logMAP(itpp::vec &extrinsic_data, const itpp::vec &rec_sig,
00285                           const itpp::vec &apriori_data);
00287     void equalizer_maxlogMAP(itpp::vec &extrinsic_data, const itpp::vec &rec_sig,
00288                              const itpp::vec &apriori_data);
00290     void mud_maxlogMAP(itpp::mat &extrinsic_data, const itpp::vec &rec_sig,
00291                        const itpp::mat &apriori_data);
00293     void mud_maxlogTMAP(itpp::mat &extrinsic_data, const itpp::vec &rec_sig,
00294                         const itpp::mat &apriori_data, const double &threshold=-5);
00296     void GCD(itpp::mat &extrinsic_data, const itpp::vec &rec_sig,
00297              const itpp::mat &apriori_data);
00299     void sGCD(itpp::mat &extrinsic_data, const itpp::vec &rec_sig,
00300               const itpp::mat &apriori_data);
00302     void Hassibi_maxlogMAP(itpp::vec &extrinsic_data, const itpp::cmat &rec_sig,
00303                            const itpp::vec &apriori_data);
00305     void GA(itpp::vec &extrinsic_data, const itpp::cmat &rec_sig,
00306             const itpp::vec &apriori_data);
00308     void sGA(itpp::vec &extrinsic_data, const itpp::cmat &rec_sig,
00309              const itpp::vec &apriori_data);
00311     void mmsePIC(itpp::vec &extrinsic_data, const itpp::cmat &rec_sig,
00312                  const itpp::vec &apriori_data);
00314     void zfPIC(itpp::vec &extrinsic_data, const itpp::cmat &rec_sig,
00315                const itpp::vec &apriori_data);
00317     void Alamouti_maxlogMAP(itpp::vec &extrinsic_data, const itpp::cmat &rec_sig,
00318                             const itpp::vec &apriori_data);
00320     void demodulator_logMAP(itpp::vec &extrinsic_data, const itpp::cvec &rec_sig,
00321                             const itpp::vec &apriori_data);
00323     void demodulator_maxlogMAP(itpp::vec &extrinsic_data, const itpp::cvec &rec_sig,
00324                                const itpp::vec &apriori_data);
00326 
00329     void print_err_msg(const std::string &msg) const;
00330 
00331     // MAP algorithm variables
00333     std::string MAP_metric;
00335     itpp::bmat gen;
00337     itpp::bvec prec_gen;
00339     bool tail;
00340     // SOVA & Viterbi variables
00342     int Viterbi_win_len;
00344     double SOVA_scaling_factor;
00346     double SOVA_threshold;
00348     double Viterbi_scaling_factor[2];
00350     bool Viterbi_hard_output_flag;
00351     //channel variables
00353     double sigma2;
00355     itpp::mat impulse_response;
00357     itpp::cmat c_impulse_response;
00359     itpp::bvec scrambler_pattern;
00361     std::string MUD_method;
00362     //constellation variables
00364     int nb_bits_symb;
00366     itpp::cvec constellation;
00368     itpp::bmat bin_constellation;
00369     //Space Time block code variables
00371     int symbols_block;
00373     int nb_em_ant;
00375     int nb_rec_ant;
00377     int block_duration;
00379     itpp::cmat ST_gen1;
00381     itpp::cmat ST_gen2;
00383     std::string demapper_method;
00384 
00385     //internal variables and functions
00387     void zpFIRfilter(itpp::vec& filt, 
00388                      const itpp::vec &h, 
00389                      const itpp::vec &sig 
00390                     );
00392     void gen_chtrellis(void);
00394     void gen_hyperTrellis(void);
00396     struct
00397     {
00398         int numInputSymbols;
00399         int stateNb;
00400         int* prevState;
00401         int* nextState;
00402         double* output;
00403         int* input;
00404     } chtrellis;
00406     void gen_rsctrellis(void);
00408     struct
00409     {
00410         int numStates;
00411         int* prevStates;
00412         int* nextStates;
00413         double* PARout;
00414         itpp::bin* fm;
00415     } rsctrellis;
00417     void gen_nsctrellis(void);
00419     struct
00420     {
00421         int stateNb;
00422         int* prevState;
00423         int* nextState;
00424         double* output;
00425         int* input;
00426     } nsctrellis;
00428     void find_half_const(int &select_half, itpp::vec &re_part,
00429                          itpp::bmat &re_bin_part, itpp::vec &im_part, itpp::bmat &im_bin_part);
00431     void EquivRecSig(itpp::vec &x_eq, const itpp::cmat &rec_sig);
00433     void EquivCh(itpp::mat &H_eq, const itpp::cvec &H);
00434 };
00435 
00436 inline SISO::SISO()
00437 {
00438     tail = false;
00439     MAP_metric = "maxlogMAP";
00440     MUD_method = "sGCD";
00441     scrambler_pattern = "0";//corresponds to +1 using BPSK mapping
00442     prec_gen = "1";
00443     demapper_method = "GA";
00444     Viterbi_win_len = 20;//should be set according to the generator polynomials
00445     SOVA_scaling_factor = 0.8;//set according to Wang [2003]
00446     SOVA_threshold = 10;//according to Wang [2003] an adaptive value should be used
00447     Viterbi_scaling_factor[0] = 1.4;//according to Kerner [2009]
00448     Viterbi_scaling_factor[1] = 0.4;
00449     Viterbi_hard_output_flag = false;
00450 }
00451 
00452 inline void SISO::set_map_metric(const std::string &in_MAP_metric)
00453 {
00454     MAP_metric = in_MAP_metric;
00455 }
00456 
00457 inline void SISO::set_precoder_generator(const itpp::bvec &in_prec_gen)//set precoder polynomial
00458 {
00459     prec_gen = in_prec_gen;
00460 }
00461 
00462 inline void SISO::set_precoder_generator(const int &in_prec_gen,
00463         const int &constraint_length)//set precoder polynomial
00464 {
00465     prec_gen = itpp::dec2bin(constraint_length, in_prec_gen);
00466 }
00467 
00468 inline void SISO::set_generators(const itpp::bmat &in_gen)
00469 {
00470     gen = in_gen;
00471 }
00472 
00473 inline void SISO::set_generators(const itpp::ivec &in_gen,
00474                                  const int &constraint_length)
00475 {
00476     int nb_outputs = in_gen.length();
00477     gen.set_size(nb_outputs, constraint_length);
00478     for (int n=0; n<nb_outputs; n++)
00479         gen.set_row(n, itpp::dec2bin(constraint_length, in_gen(n)));
00480 }
00481 
00482 inline void SISO::set_tail(const bool &in_tail)
00483 {
00484     tail = in_tail;
00485 }
00486 
00487 inline void SISO::set_viterbi_win_len(const int &win_len)
00488 {
00489     Viterbi_win_len = win_len;
00490 }
00491 
00492 inline void SISO::set_sova_scaling_factor(const double &scaling_factor)
00493 {
00494     SOVA_scaling_factor = scaling_factor;
00495 }
00496 
00497 inline void SISO::set_sova_threshold(const double &threshold)
00498 {
00499     SOVA_threshold = threshold;
00500 }
00501 
00502 inline void SISO::set_viterbi_scaling_factors(const double &matching_scaling_factor,
00503         const double &nonmatching_scaling_factor)
00504 {
00505     Viterbi_scaling_factor[0] = matching_scaling_factor;
00506     Viterbi_scaling_factor[1] = nonmatching_scaling_factor;
00507 }
00508 
00509 inline void SISO::set_viterbi_hard_output_flag(const bool &flag)
00510 {
00511     Viterbi_hard_output_flag = flag;
00512 }
00513 
00514 inline void SISO::set_noise(const double &in_sigma2)
00515 {
00516     sigma2 = in_sigma2;
00517 }
00518 
00519 inline void SISO::set_impulse_response(const itpp::vec &h)
00520 {
00521     impulse_response.set_size(1, h.length());
00522     impulse_response.set_row(0, h);
00523 }
00524 
00525 inline void SISO::set_impulse_response(const itpp::mat &H)
00526 {
00527     impulse_response = H;
00528 }
00529 
00530 inline void SISO::set_impulse_response(const itpp::cvec &h)
00531 {
00532     c_impulse_response.set_size(1, h.length());
00533     c_impulse_response.set_row(0, h);
00534 }
00535 
00536 inline void SISO::set_impulse_response(const itpp::cmat &cH)
00537 {
00538     c_impulse_response = cH;
00539 }
00540 
00541 inline void SISO::set_scrambler_pattern(const itpp::vec &phi)
00542 {
00543     int phi_len = phi.length();
00544     scrambler_pattern.set_size(phi_len);
00545     //scrambler_pattern = to_bvec((1-phi)/2);//BPSK mapping: 0->+1 and 1->-1
00546     register int n;
00547     for (n=0; n<phi_len; n++)
00548         scrambler_pattern(n) = itpp::bin((1-int(phi(n)))/2);//BPSK mapping: 0->+1 and 1->-1
00549 }
00550 
00551 inline void SISO::set_scrambler_pattern(const itpp::bvec &phi)
00552 {
00553     scrambler_pattern = phi;
00554 }
00555 
00556 inline void SISO::set_mud_method(const std::string &method)
00557 {
00558     MUD_method = method;
00559 }
00560 
00561 inline void SISO::set_constellation(const int &in_nb_bits_symb,
00562                                     const itpp::cvec &in_constellation, const itpp::bmat &in_bin_constellation)
00563 {
00564     nb_bits_symb = in_nb_bits_symb;
00565     constellation = in_constellation;
00566     bin_constellation = in_bin_constellation;
00567 }
00568 
00569 inline void SISO::set_constellation(const int &in_nb_bits_symb,
00570                                     const itpp::cvec &in_constellation, const itpp::ivec &in_int_constellation)
00571 {
00572     nb_bits_symb = in_nb_bits_symb;
00573     int nb_symb = in_constellation.length();
00574     constellation.set_size(nb_symb);
00575     bin_constellation.set_size(nb_symb, nb_bits_symb);
00576     for (int n=0; n<nb_symb; n++)
00577     {
00578         constellation(n) = in_constellation(in_int_constellation(n));
00579         bin_constellation.set_row(n, itpp::dec2bin(nb_bits_symb, n));
00580     }
00581 }
00582 
00583 inline void SISO::set_st_block_code(const int &Q, const itpp::cmat &A,
00584                                     const itpp::cmat &B, const int &N)
00585 {
00586     symbols_block = Q;
00587     nb_em_ant = A.cols();
00588     nb_rec_ant = N;
00589     block_duration = A.rows()/Q;
00590     ST_gen1 = A;
00591     ST_gen2 = B;
00592 }
00593 
00594 inline void SISO::set_demapper_method(const std::string &method)
00595 {
00596     demapper_method = method;
00597 }
00598 
00599 inline void SISO::rsc(itpp::vec &extrinsic_coded, itpp::vec &extrinsic_data,
00600                       const itpp::vec &intrinsic_coded, const itpp::vec &apriori_data, const bool &tail)
00601 {
00602     set_tail(tail);
00603     rsc(extrinsic_coded, extrinsic_data, intrinsic_coded, apriori_data);
00604 }
00605 
00606 inline void SISO::rsc(itpp::vec &extrinsic_coded, itpp::vec &extrinsic_data,
00607                       const itpp::vec &intrinsic_coded, const itpp::vec &apriori_data)
00608 {
00609     if (gen.size()==0)
00610     {
00611         print_err_msg("SISO::rsc: generator polynomials not initialized");
00612         return;
00613     }
00614 
00615     if (MAP_metric=="logMAP")
00616     {
00617         rsc_logMAP(extrinsic_coded, extrinsic_data, intrinsic_coded, apriori_data);
00618     } else if (MAP_metric=="maxlogMAP")
00619     {
00620         rsc_maxlogMAP(extrinsic_coded, extrinsic_data, intrinsic_coded, apriori_data);
00621     } else if (MAP_metric=="SOVA")
00622     {
00623         //no extrinsic information for coded bits is provided
00624         rsc_sova(extrinsic_data, intrinsic_coded, apriori_data, Viterbi_win_len);
00625     } else if (MAP_metric=="Viterbi")
00626     {
00627         rsc_viterbi(extrinsic_coded, extrinsic_data, intrinsic_coded, apriori_data, Viterbi_win_len);
00628     } else
00629     {
00630         print_err_msg("SISO::rsc: unknown MAP metric. The MAP metric should be either logMAP or maxlogMAP or SOVA or Viterbi");
00631     }
00632 }
00633 
00634 inline void SISO::nsc(itpp::vec &extrinsic_coded, itpp::vec &extrinsic_data,
00635                       const itpp::vec &intrinsic_coded, const itpp::vec &apriori_data, const bool &tail)
00636 {
00637     set_tail(tail);
00638     nsc(extrinsic_coded, extrinsic_data, intrinsic_coded, apriori_data);
00639 }
00640 
00641 inline void SISO::nsc(itpp::vec &extrinsic_coded, itpp::vec &extrinsic_data,
00642                       const itpp::vec &intrinsic_coded, const itpp::vec &apriori_data)
00643 {
00644     if (gen.size()==0)
00645     {
00646         print_err_msg("SISO::nsc: generator polynomials not initialized");
00647         return;
00648     }
00649 
00650     if (MAP_metric=="logMAP")
00651         nsc_logMAP(extrinsic_coded, extrinsic_data, intrinsic_coded, apriori_data);
00652     else if (MAP_metric=="maxlogMAP")
00653         nsc_maxlogMAP(extrinsic_coded, extrinsic_data, intrinsic_coded, apriori_data);
00654     else
00655         print_err_msg("SISO::nsc: unknown MAP metric. The MAP metric should be either logMAP or maxlogMAP");
00656 }
00657 
00658 inline void SISO::equalizer(itpp::vec &extrinsic_data, 
00659                             const itpp::vec &rec_sig, 
00660                             const itpp::vec &apriori_data,  
00661                             const bool &tail 
00662                            )
00663 {
00664     set_tail(tail);
00665     equalizer(extrinsic_data, rec_sig, apriori_data);
00666 }
00667 
00668 inline void SISO::equalizer(itpp::vec &extrinsic_data, const itpp::vec &rec_sig,
00669                             const itpp::vec &apriori_data)
00670 {
00671     if (impulse_response.size()==0)
00672     {
00673         print_err_msg("SISO::equalizer: channel impulse response not initialized");
00674         return;
00675     }
00676     if ((impulse_response.size()==1)&&(prec_gen.length()==1))
00677     {
00678         print_err_msg("SISO::equalizer: flat fading channel and no precoder. Use the soft output of the channel (no need for a priori information)");
00679         return;
00680     }
00681 
00682     if (MAP_metric=="logMAP")
00683         equalizer_logMAP(extrinsic_data, rec_sig, apriori_data);
00684     else if (MAP_metric=="maxlogMAP")
00685         equalizer_maxlogMAP(extrinsic_data, rec_sig, apriori_data);
00686     else
00687         print_err_msg("SISO::equalizer: unknown MAP metric. The MAP metric should be either logMAP or maxlogMAP");
00688 }
00689 
00690 inline void SISO::mud(itpp::mat &extrinsic_data, const itpp::vec &rec_sig,
00691                       const itpp::mat &apriori_data)
00692 {
00693     if (impulse_response.size()==0)
00694     {
00695         print_err_msg("SISO::mud: channel impulse response not initialized");
00696         return;
00697     }
00698     if (impulse_response.rows()!=apriori_data.rows())
00699     {
00700         print_err_msg("SISO::mud: channel impulse response must have the same number of rows as a priori info.");
00701         return;
00702     }
00703 
00704     if (MUD_method=="maxlogMAP")
00705         mud_maxlogMAP(extrinsic_data, rec_sig, apriori_data);
00706     else if (MUD_method=="GCD")
00707         GCD(extrinsic_data, rec_sig, apriori_data);
00708     else if (MUD_method=="sGCD")
00709         sGCD(extrinsic_data, rec_sig, apriori_data);
00710     else
00711         print_err_msg("SISO::mud: unknown MUD method. The MUD method should be either maxlogMAP, GCD or sGCD");
00712 }
00713 
00714 inline void SISO::demapper(itpp::vec &extrinsic_data, const itpp::cvec &rec_sig,
00715                            const itpp::vec &apriori_data)
00716 {
00717     if (c_impulse_response.size()==0)
00718     {
00719         print_err_msg("SISO::demapper: channel impulse response not initialized");
00720         return;
00721     }
00722     if ((constellation.size()==0) || (bin_constellation.size()==0))
00723     {
00724         print_err_msg("SISO::demapper: constellation not initialized");
00725         return;
00726     }
00727     if (MAP_metric=="logMAP")
00728         demodulator_logMAP(extrinsic_data, rec_sig, apriori_data);
00729     else if (MAP_metric=="maxlogMAP")
00730         demodulator_maxlogMAP(extrinsic_data, rec_sig, apriori_data);
00731     else
00732         print_err_msg("SISO::demapper: unknown MAP metric. The MAP metric should be either logMAP or maxlogMAP");
00733 }
00734 
00735 inline void SISO::demapper(itpp::vec &extrinsic_data, const itpp::cmat &rec_sig,
00736                            const itpp::vec &apriori_data)
00737 {
00738     if (c_impulse_response.size()==0)
00739     {
00740         print_err_msg("SISO::demapper: channel impulse response not initialized");
00741         return;
00742     }
00743     if ((ST_gen1.size()==0) || (ST_gen2.size()==0))
00744     {
00745         print_err_msg("SISO::demapper: Space-Time generator polynomials not initialized");
00746         return;
00747     }
00748     if ((constellation.size()==0) || (bin_constellation.size()==0))
00749     {
00750         print_err_msg("SISO::demapper: constellation not initialized");
00751         return;
00752     }
00753 
00754     if (demapper_method=="Hassibi_maxlogMAP")
00755         Hassibi_maxlogMAP(extrinsic_data, rec_sig, apriori_data);
00756     else if (demapper_method=="GA")
00757         GA(extrinsic_data, rec_sig, apriori_data);
00758     else if (demapper_method=="sGA")
00759         sGA(extrinsic_data, rec_sig, apriori_data);
00760     else if (demapper_method=="mmsePIC")
00761         mmsePIC(extrinsic_data, rec_sig, apriori_data);
00762     else if (demapper_method=="zfPIC")
00763         zfPIC(extrinsic_data, rec_sig, apriori_data);
00764     else if (demapper_method=="Alamouti_maxlogMAP")
00765         Alamouti_maxlogMAP(extrinsic_data, rec_sig, apriori_data);
00766     else
00767         print_err_msg("SISO::demapper: unknown demapper method. The demapper method should be either Hassibi_maxlogMAP, GA, sGA, mmsePIC, zfPIC or Alamouti_maxlogMAP");
00768 }
00769 
00770 inline void SISO::print_err_msg(const std::string &msg) const
00771 {
00772 #ifdef mex_h
00773     mexErrMsgTxt(msg.c_str());
00774 #else
00775     std::cout << msg << std::endl;
00776 #endif
00777 }
00778 
00779 inline double SISO::threshold(const double &x, const double &value)
00780 {
00781     if ((x>value)||(x<-value))
00782         return (x>0?value:-value);
00783     return x;
00784 }
00785 
00786 inline itpp::vec SISO::threshold(const itpp::vec &in, const double &value)
00787 {
00788     itpp::vec out(in.length());
00789     register int n;
00790     for (n=0; n<in.length(); n++)
00791         out(n) = threshold(in(n), value);
00792     return out;
00793 }
00794 
00795 inline itpp::mat SISO::threshold(const itpp::mat &in, const double &value)
00796 {
00797     itpp::mat out(in.rows(),in.cols());
00798     register int n;
00799     for (n=0; n<in.rows(); n++)
00800         out.set_row(n, threshold(in.get_row(n), value));
00801     return out;
00802 }
00803 
00804 }
00805 
00806 #endif /*SISO_H_*/
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines
SourceForge Logo

Generated on Wed Jul 27 2011 16:27:05 for IT++ by Doxygen 1.7.4