Index: libitpp/gtests/exit_test.cpp
===================================================================
--- libitpp.orig/gtests/exit_test.cpp
+++ libitpp/gtests/exit_test.cpp
@@ -77,7 +77,7 @@ TEST(EXIT, All)
   vec extrinsic_mutual_info_p(sigma2A_len);
   extrinsic_mutual_info.zeros();
   extrinsic_mutual_info_p.zeros();
-  register int en, n, nb_blocks;
+  int en, n, nb_blocks;
 
   //Recursive Systematic Convolutional Code
   Rec_Syst_Conv_Code rsc;
Index: libitpp/gtests/siso_test.cpp
===================================================================
--- libitpp.orig/gtests/siso_test.cpp
+++ libitpp/gtests/siso_test.cpp
@@ -83,7 +83,7 @@ TEST(SISO, all)
     int snr_len = EbN0_dB.length();
     mat ber(nb_iter,snr_len);
     ber.zeros();
-    register int en,n;
+    int en,n;
 
     //Recursive Systematic Convolutional Code
     Rec_Syst_Conv_Code cc;
Index: libitpp/gtests/stc_test.cpp
===================================================================
--- libitpp.orig/gtests/stc_test.cpp
+++ libitpp/gtests/stc_test.cpp
@@ -37,7 +37,7 @@ bool near(const itpp::cmat &M1, const it
 		return false;
 	}
 
-	register int n, k;
+	int n, k;
 	for (n = 0; n < M1.rows(); ++n)
 	{
 		for (k = 0; k < M1.cols(); ++k)
Index: libitpp/itpp/comm/sequence.h
===================================================================
--- libitpp.orig/itpp/comm/sequence.h
+++ libitpp/itpp/comm/sequence.h
@@ -37,7 +37,7 @@ namespace itpp
 {
 
 /*!
-  \brief Binary Linear Feedback Shift Register (LFSR)
+  \brief Binary Linear Feedback Shift (LFSR)
   \ingroup sequence
 
   - The LFSR is on Fibonacci form (see p. 104 in Peterson, Ziemer and
Index: libitpp/itpp/comm/siso.h
===================================================================
--- libitpp.orig/itpp/comm/siso.h
+++ libitpp/itpp/comm/siso.h
@@ -665,7 +665,7 @@ inline void SISO::set_scrambler_pattern(
     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;
+    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
 }
@@ -908,7 +908,7 @@ inline double SISO::threshold(const doub
 inline itpp::vec SISO::threshold(const itpp::vec &in, const double &value)
 {
     itpp::vec out(in.length());
-    register int n;
+    int n;
     for (n=0; n<in.length(); n++)
         out(n) = threshold(in(n), value);
     return out;
@@ -917,7 +917,7 @@ inline itpp::vec SISO::threshold(const i
 inline itpp::mat SISO::threshold(const itpp::mat &in, const double &value)
 {
     itpp::mat out(in.rows(),in.cols());
-    register int n;
+    int n;
     for (n=0; n<in.rows(); n++)
         out.set_row(n, threshold(in.get_row(n), value));
     return out;
Index: libitpp/itpp/comm/siso_dem.cpp
===================================================================
--- libitpp.orig/itpp/comm/siso_dem.cpp
+++ libitpp/itpp/comm/siso_dem.cpp
@@ -68,7 +68,7 @@ void SISO::find_half_const(int &select_h
         return;
     }
     itpp::bvec temp(nb_bits_symb);
-    register int n;
+    int n;
     for (n=0; n<2; n++)
     {
         temp = bin_constellation.get_row(idx(n));
@@ -129,7 +129,7 @@ void SISO::EquivCh(itpp::mat &H_eq, cons
     itpp::cmat temp(block_duration,nb_em_ant);
     itpp::vec h(2*nb_em_ant);
     itpp::mat AhBh(2*block_duration,2);
-    register int n,k;
+    int n,k;
     for (k=0; k<symbols_block; k++)
     {
         temp = ST_gen1.get(k*block_duration,k*block_duration+block_duration-1,0,nb_em_ant-1);
@@ -200,7 +200,7 @@ void SISO::Hassibi_maxlogMAP(itpp::vec &
     double temp;
     itpp::mat H_eq(2*nb_rec_ant*block_duration,2*symbols_block);//equivalent channel matrix
     itpp::vec x_eq(2*block_duration*nb_rec_ant);//equivalent received signal
-    register int ns,q,nb,n,k;
+    int ns,q,nb,n,k;
     int index;
     extrinsic_data.set_size(nb_bits_symb*nb_subblocks*symbols_block);
     //main loop
@@ -268,7 +268,7 @@ void SISO::GA(itpp::vec &extrinsic_data,
     itpp::mat CZeta_inv(2*block_duration*nb_rec_ant,2*block_duration*nb_rec_ant);
     double nom,denom;
     double temp;
-    register int ns,q,p,cs;
+    int ns,q,p,cs;
     int index;
     extrinsic_data.set_size(nb_bits_symb*nb_subblocks*symbols_block);
     for (ns=0; ns<nb_subblocks; ns++)//subblock by subblock
@@ -374,7 +374,7 @@ void SISO::sGA(itpp::vec &extrinsic_data
     itpp::vec CZeta(2*block_duration*nb_rec_ant);
     double nom,denom;
     double temp;
-    register int ns,q,p,cs;
+    int ns,q,p,cs;
     int index;
     extrinsic_data.set_size(nb_bits_symb*nb_subblocks*symbols_block);
     for (ns=0; ns<nb_subblocks; ns++)//subblock by subblock
@@ -467,7 +467,7 @@ void SISO::mmsePIC(itpp::vec &extrinsic_
     double sigma2_res;
     double nom,denom;
     double tmp;
-    register int ns,q,k,s;
+    int ns,q,k,s;
     int index;
 
     //correspondence between real and imaginary part of symbols and their binary representations
@@ -575,7 +575,7 @@ void SISO::zfPIC(itpp::vec &extrinsic_da
     double sigma2_res;
     double nom,denom;
     double tmp;
-    register int ns,q,k,s;
+    int ns,q,k,s;
     int index;
 
     //correspondence between real and imaginary part of symbols and their binary representations
@@ -668,7 +668,7 @@ void SISO::Alamouti_maxlogMAP(itpp::vec
     comb_sig.zeros();
     itpp::cmat conj_H = itpp::conj(c_impulse_response);
     itpp::cmat conj_X = itpp::conj(rec_sig);
-    register int nr,n,cs;
+    int nr,n,cs;
     for (nr=0; nr<nb_rec_ant; nr++)
     {
         for (n=0; n<(nb_symb/2); n++)
@@ -713,7 +713,7 @@ void SISO::demodulator_logMAP(itpp::vec
     int nb_symb = rec_sig.length();
     int const_size = itpp::pow2i(nb_bits_symb);
     double nom,denom,temp;
-    register int k,i,cs;
+    int k,i,cs;
     int index;
     extrinsic_data.set_size(nb_bits_symb*nb_symb);
     for (k=0; k<nb_symb; k++)
@@ -743,7 +743,7 @@ void SISO::demodulator_maxlogMAP(itpp::v
     int nb_symb = rec_sig.length();
     int const_size = itpp::pow2i(nb_bits_symb);
     double nom,denom,temp;
-    register int k,i,cs;
+    int k,i,cs;
     int index;
     extrinsic_data.set_size(nb_bits_symb*nb_symb);
     for (k=0; k<nb_symb; k++)
Index: libitpp/itpp/comm/siso_eq.cpp
===================================================================
--- libitpp.orig/itpp/comm/siso_eq.cpp
+++ libitpp/itpp/comm/siso_eq.cpp
@@ -42,7 +42,7 @@ void SISO::gen_chtrellis(void)
     int p_order = prec_gen.length()-1;//order of the precoder polynomial
 
     //other variables
-    register int n,k,j;
+    int n,k,j;
     double inputs[] = {1.0,-1.0};//1->-1, 0->+1
     int index;
     double feedback[2];
@@ -111,7 +111,7 @@ void SISO::equalizer_logMAP(itpp::vec &e
     //get parameters
     int N = rec_sig.length();//length of the received frame
     //other parameters
-    register int n,k,m;
+    int n,k,m;
     int pstates[2];
     int nstates[2];
     int inputs[2];
@@ -226,7 +226,7 @@ void SISO::equalizer_maxlogMAP(itpp::vec
     //get parameters
     int N = rec_sig.length();//length of the received frame
     //other parameters
-    register int n,k,m;
+    int n,k,m;
     int pstates[2];
     int nstates[2];
     int inputs[2];
Index: libitpp/itpp/comm/siso_mud.cpp
===================================================================
--- libitpp.orig/itpp/comm/siso_mud.cpp
+++ libitpp/itpp/comm/siso_mud.cpp
@@ -50,7 +50,7 @@ void SISO::descrambler(itpp::vec &extrin
     //implementation
     extrinsic_data.set_size(nb_bits);
     extrinsic_coded.set_size(nb_bits*Nc);
-    register int n,k;
+    int n,k;
 #pragma omp parallel for private(n,k)
     for (k=0; k<nb_bits; k++)
     {
@@ -73,7 +73,7 @@ void SISO::zpFIRfilter(itpp::vec &filt,
     int L = h.length()-1;
     int N = sig.length();
     //implementation
-    register int n,l;
+    int n,l;
 #pragma omp parallel for private(n,l)
     for (n=0; n<(N+L); n++)
     {
@@ -141,7 +141,7 @@ void SISO::gen_hyperTrellis(void)
     itpp::bin feedback;
 
     //create hypertrellis
-    register int n,k,p,r;
+    int n,k,p,r;
     int buffer;
     double hyper_ch_out;
     for (k=0; k<chtrellis.stateNb; k++)
@@ -219,7 +219,7 @@ void SISO::mud_maxlogMAP(itpp::mat &extr
         msg += itpp::to_str(block_len);
         print_err_msg(msg);
     }
-    register int n;
+    int n;
     A[0] = 0;
     B[block_len*chtrellis.stateNb] = 0;
     double buffer = (tail?-INFINITY:0);
@@ -231,7 +231,7 @@ void SISO::mud_maxlogMAP(itpp::mat &extr
     }
 
     //compute log(alpha) (forward recursion)
-    register int s,k;
+    int s,k;
     int sp,i;
     itpp::bvec in_chips(nb_usr);
 #pragma omp parallel sections private(n,buffer,s,k,sp,in_chips)
@@ -289,7 +289,7 @@ void SISO::mud_maxlogMAP(itpp::mat &extr
     //compute extrinsic information
     double nom, denom;
     extrinsic_data.set_size(nb_usr,block_len);
-    register int u;
+    int u;
 #pragma omp parallel for private(u,n,s,k,nom,denom,in_chips,buffer)
     for (u=0; u<nb_usr; u++)
     {
@@ -344,7 +344,7 @@ void SISO::GCD(itpp::mat &extrinsic_data
     int K = apriori_data.rows();//number of users
     int L = impulse_response.cols()-1;//channel order
     //other parameters
-    register int n,k;
+    int n,k;
 
     //mean and variance of each chip (NxK)
     itpp::mat Ex = -itpp::tanh(apriori_data/2.0);//take into account BPSK mapping
@@ -426,7 +426,7 @@ void SISO::sGCD(itpp::mat &extrinsic_dat
     int K = apriori_data.rows();//number of users
     int L = impulse_response.cols()-1;//channel order
     //other parameters
-    register int n,k;
+    int n,k;
 
     //mean and variance of each chip (NxK)
     itpp::mat Ex = -itpp::tanh(apriori_data/2.0);//take into account BPSK mapping
Index: libitpp/itpp/comm/siso_nsc.cpp
===================================================================
--- libitpp.orig/itpp/comm/siso_nsc.cpp
+++ libitpp/itpp/comm/siso_nsc.cpp
@@ -46,7 +46,7 @@ void SISO::gen_nsctrellis(void)
     int r = gen.rows();
     int mem_len = gen.cols()-1;
     //other parameters
-    register int n,k,j,p;
+    int n,k,j,p;
     itpp::bin inputs[] = {0,1};
     int index;
 
@@ -120,7 +120,7 @@ void SISO::nsc_logMAP(itpp::vec &extrins
     int Nc = scrambler_pattern.length();
     int r = gen.rows();//number of outputs of the CC
     //other parameters
-    register int n,k,m,mp,j,i;
+    int n,k,m,mp,j,i;
     int pstates[2];
     int nstates[2];
     int inputs[2];
@@ -312,7 +312,7 @@ void SISO::nsc_maxlogMAP(itpp::vec &extr
     int Nc = scrambler_pattern.length();
     int r = gen.rows();//number of outputs of the CC
     //other parameters
-    register int n,k,m,mp,j,i;
+    int n,k,m,mp,j,i;
     int pstates[2];
     int nstates[2];
     int inputs[2];
Index: libitpp/itpp/comm/siso_rsc.cpp
===================================================================
--- libitpp.orig/itpp/comm/siso_rsc.cpp
+++ libitpp/itpp/comm/siso_rsc.cpp
@@ -40,7 +40,7 @@ void SISO::gen_rsctrellis(void)
 //the states are numbered from 0
 {
     int mem_len = gen.cols()-1;
-    register int n,k,j;
+    int n,k,j;
     itpp::bin feedback,out;
     int buffer;
 
@@ -100,7 +100,7 @@ void SISO::rsc_logMAP(itpp::vec &extrins
     //get parameters
     int N = apriori_data.length();
     //other parameters
-    register int n,k;
+    int n,k;
     double buffer;
     int index;
     double A_min, A_max;
@@ -268,7 +268,7 @@ void SISO::rsc_maxlogMAP(itpp::vec &extr
     //get parameters
     int N = apriori_data.length();
     //other parameters
-    register int n,k;
+    int n,k;
     double buffer;
     int index;
     double A_min, A_max;
@@ -436,7 +436,7 @@ void SISO::rsc_sova(itpp::vec &extrinsic
     int nb_outputs = gen.rows();
 
     //setup internal variables based on RSC trellis
-    register int i,j,s;
+    int i,j,s;
     gen_rsctrellis();//trellis generation for 1/2 RSC codes
     int nb_states = rsctrellis.numStates;
     itpp::Array<itpp::mat> bin_out(2);//contains code output for each initial state and code input
@@ -603,7 +603,7 @@ void SISO::rsc_viterbi(itpp::vec &extrin
     int nb_outputs = gen.rows();
 
     //setup internal variables based on RSC trellis
-    register int i,j,s;
+    int i,j,s;
     gen_rsctrellis();//trellis generation for 1/2 RSC codes
     int nb_states = rsctrellis.numStates;
     itpp::Array<itpp::mat> bin_out(2);//contains code output for each initial state and code input
Index: libitpp/itpp/comm/stc.cpp
===================================================================
--- libitpp.orig/itpp/comm/stc.cpp
+++ libitpp/itpp/comm/stc.cpp
@@ -59,7 +59,7 @@ void STC::Hassibi_block_code(void)
         A.zeros();
         itpp::mat temp(channel_uses, em_antenna);
         temp.zeros();
-        register int tau,m;
+        int tau,m;
         for (tau=0; tau<channel_uses; tau++)
         {
             for (m=0; m<em_antenna; m++)
@@ -83,7 +83,7 @@ void STC::Hassibi_block_code(void)
         P(0,em_antenna-1) = 1;
         A.set_size(symb_block*channel_uses, em_antenna);
         A.zeros();
-        register int k,l;
+        int k,l;
         for (k=0; k<channel_uses; k++)
         {
             for (l=0; l<em_antenna; l++)
@@ -745,7 +745,7 @@ itpp::cmat STC::encode(const itpp::cvec
     itpp::cmat S(tx_duration,em_antenna);
     itpp::cmat temp(channel_uses,em_antenna);
     std::complex<double> j(0,1);
-    register int ns,k;
+    int ns,k;
     for (ns=0; ns<nb_subblocks; ns++)//encode block by block (symb_block symbols)
     {
         temp.zeros();
@@ -764,7 +764,7 @@ itpp::cmat STC::encode(const itpp::cvec
 itpp::cmat STC::diag_pow(const itpp::cmat &in_mat, double in_exp)
 //first input should be a diagonal square matrix with complex elements
 {
-    register int n;
+    int n;
     int dim = in_mat.rows();
     itpp::cmat out_mat(dim,dim);
     out_mat.zeros();
@@ -784,7 +784,7 @@ itpp::mat STC::mat_pow(const itpp::mat &
     }
     itpp::mat out = in_mat;
     int abs_in_exp = std::abs(in_exp);
-    register int n;
+    int n;
     for (n=1; n<abs_in_exp; n++)
     {
         out *= in_mat;