mGold() { Parser p(std::string("config.txt")); numG=p.get_int("numG"); p1.set_length(25); p2.set_length(25); ps1.set_length(numG); ps2.set_length(numG); c1.set_length(numG); c2.set_length(numG); cv1.set_length(numG); cv2.set_length(numG); c.set_length(numG); cConjugate.set_length(numG); p1.zeros(); p2.zeros(); p1[0]=1; p2[0]=1; }
transmiter() { Parser p(std::string("config.txt")); DPCCH_NBits=p.get_int("DPCCH_NBits"); HS_DPCCH_NBits=p.get_int("HS_DPCCH_NBits"); E_DPCCH_NBits=p.get_int("E_DPCCH_NBits"); E_DPDCH1_NData=p.get_int("E_DPDCH1_NData"); E_DPDCH2_NData=p.get_int("E_DPDCH2_NData"); E_DPDCH3_NData=p.get_int("E_DPDCH3_NData"); E_DPDCH4_NData=p.get_int("E_DPDCH4_NData"); SF=p.get_int("SF"); SF_EDPDCH2=p.get_int("SF_EDPDCH2"); SF_EDPDCH3=p.get_int("SF_EDPDCH3"); DPCCH_SLOT0=p.get_int("DPCCH_SLOT0"); DPCCH_SLOT1=p.get_int("DPCCH_SLOT1"); DPCCH_SLOT2=p.get_int("DPCCH_SLOT2"); DPCCH_SLOT3=p.get_int("DPCCH_SLOT3"); DPCCH_SLOT4=p.get_int("DPCCH_SLOT4"); DPCCH_SLOT5=p.get_int("DPCCH_SLOT5"); DPCCH_SLOT6=p.get_int("DPCCH_SLOT6"); DPCCH_SLOT7=p.get_int("DPCCH_SLOT7"); DPCCH_SLOT8=p.get_int("DPCCH_SLOT8"); DPCCH_SLOT9=p.get_int("DPCCH_SLOT9"); DPCCH_SLOT10=p.get_int("DPCCH_SLOT10"); DPCCH_SLOT11=p.get_int("DPCCH_SLOT11"); DPCCH_SLOT12=p.get_int("DPCCH_SLOT12"); DPCCH_SLOT13=p.get_int("DPCCH_SLOT13"); DPCCH_SLOT14=p.get_int("DPCCH_SLOT14"); betaDPCCH=p.get_int("betaDPCCH"); betaE_DPDCH1=p.get_int("betaE_DPDCH1"); betaE_DPDCH2=p.get_int("betaE_DPDCH2"); betaE_DPDCH3=p.get_int("betaE_DPDCH3"); betaE_DPDCH4=p.get_int("betaE_DPDCH4"); betaE_DPCCH=p.get_int("betaE_DPCCH"); betaE_HS_DPCCH=p.get_int("betaE_HS_DPCCH"); betaDPCCHlin=pow10(betaDPCCH/10.0); betaE_DPDCH1lin=pow10(betaE_DPDCH1/10.0); betaE_DPDCH2lin=pow10(betaE_DPDCH2/10.0); betaE_DPDCH3lin=pow10(betaE_DPDCH3/10.0); betaE_DPDCH4lin=pow10(betaE_DPDCH4/10.0); betaE_DPCCHlin=pow10(betaE_DPCCH/10.0); betaE_HS_DPCCHlin=pow10(betaE_HS_DPCCH/10.0); OVSF=wcdma_spreading_codes (SF); OVSF4=wcdma_spreading_codes(SF_EDPDCH3); OVSF2=wcdma_spreading_codes(SF_EDPDCH2); OVSF256_0.set_length(SF,false); OVSF256_1.set_length(SF,false); OVSF256_33.set_length(SF,false); OVSF256_64.set_length(SF,false); OVSF4_1.set_length(SF_EDPDCH3,false); OVSF4_3.set_length(SF_EDPDCH3,false); OVSF2_1.set_length(SF_EDPDCH2,false); for(int i=0;i<OVSF.cols();i++) { OVSF256_0[i]=OVSF(0,i); OVSF256_1[i]=OVSF(1,i); OVSF256_33[i]=OVSF(33,i); OVSF256_64[i]=OVSF(64,i); } for(int i=0;i<OVSF4.cols();i++) { OVSF4_1[i]=OVSF4(1,i); } for(int i=0;i<OVSF2.cols();i++) { OVSF2_1[i]=OVSF2(1,i); } bvec DPCCH0=dec2bin(DPCCH_SLOT0,true); bvec DPCCH1=dec2bin(DPCCH_SLOT1,true); bvec DPCCH2=dec2bin(DPCCH_SLOT2,true); bvec DPCCH3=dec2bin(DPCCH_SLOT3,true); bvec DPCCH4=dec2bin(DPCCH_SLOT4,true); bvec DPCCH5=dec2bin(DPCCH_SLOT5,true); bvec DPCCH6=dec2bin(DPCCH_SLOT6,true); bvec DPCCH7=dec2bin(DPCCH_SLOT7,true); bvec DPCCH8=dec2bin(DPCCH_SLOT8,true); bvec DPCCH9=dec2bin(DPCCH_SLOT9,true); bvec DPCCH10=dec2bin(DPCCH_SLOT10,true); bvec DPCCH11=dec2bin(DPCCH_SLOT11,true); bvec DPCCH12=dec2bin(DPCCH_SLOT12,true); bvec DPCCH13=dec2bin(DPCCH_SLOT13,true); bvec DPCCH14=dec2bin(DPCCH_SLOT14,true); DPCCH.set_length(DPCCH_NBits,false); bvec conDPCCH0=concat(DPCCH0,DPCCH1,DPCCH2,DPCCH3,DPCCH4); bvec conDPCCH1=concat(DPCCH5,DPCCH6,DPCCH7,DPCCH8,DPCCH9); bvec conDPCCH2=concat(DPCCH10,DPCCH11,DPCCH12,DPCCH13,DPCCH14); DPCCH=concat(conDPCCH0,conDPCCH1,conDPCCH2); gold.generate(); }
bool Reed_Solomon::decode(const bvec &coded_bits, const ivec &erasure_positions, bvec &decoded_message, bvec &cw_isvalid) { bool decoderfailure, no_dec_failure; int j, i, kk, l, L, foundzeros, iterations = floor_i(static_cast<double>(coded_bits.length()) / (n * m)); bvec mbit(m * k); decoded_message.set_size(iterations * k * m, false); cw_isvalid.set_length(iterations); GFX rx(q, n - 1), cx(q, n - 1), mx(q, k - 1), ex(q, n - 1), S(q, 2 * t), Xi(q, 2 * t), Gamma(q), Lambda(q), Psiprime(q), OldLambda(q), T(q), Omega(q); GFX dummy(q), One(q, (char*)"0"), Omegatemp(q); GF delta(q), tempsum(q), rtemp(q), temp(q), Xk(q), Xkinv(q); ivec errorpos; if ( erasure_positions.length() ) { it_assert(max(erasure_positions) < iterations*n, "Reed_Solomon::decode: erasure position is invalid."); } no_dec_failure = true; for (i = 0; i < iterations; i++) { decoderfailure = false; //Fix the received polynomial r(x) for (j = 0; j < n; j++) { rtemp.set(q, coded_bits.mid(i * n * m + j * m, m)); rx[j] = rtemp; } // Fix the Erasure polynomial Gamma(x) // and replace erased coordinates with zeros rtemp.set(q, -1); ivec alphapow = - ones_i(2); Gamma = One; for (j = 0; j < erasure_positions.length(); j++) { rx[erasure_positions(j)] = rtemp; alphapow(1) = erasure_positions(j); Gamma *= (One - GFX(q, alphapow)); } //Fix the syndrome polynomial S(x). S.clear(); for (j = 1; j <= 2 * t; j++) { S[j] = rx(GF(q, b + j - 1)); } // calculate the modified syndrome polynomial Xi(x) = Gamma * (1+S) - 1 Xi = Gamma * (One + S) - One; // Apply Berlekam-Massey algorithm if (Xi.get_true_degree() >= 1) { //Errors in the received word // Iterate to find Lambda(x), which hold all error locations kk = 0; Lambda = One; L = 0; T = GFX(q, (char*)"-1 0"); while (kk < 2 * t) { kk = kk + 1; tempsum = GF(q, -1); for (l = 1; l <= L; l++) { tempsum += Lambda[l] * Xi[kk - l]; } delta = Xi[kk] - tempsum; if (delta != GF(q, -1)) { OldLambda = Lambda; Lambda -= delta * T; if (2 * L < kk) { L = kk - L; T = OldLambda / delta; } } T = GFX(q, (char*)"-1 0") * T; } // Find the zeros to Lambda(x) errorpos.set_size(Lambda.get_true_degree()); foundzeros = 0; for (j = q - 2; j >= 0; j--) { if (Lambda(GF(q, j)) == GF(q, -1)) { errorpos(foundzeros) = (n - j) % n; foundzeros += 1; if (foundzeros >= Lambda.get_true_degree()) { break; } } } if (foundzeros != Lambda.get_true_degree()) { decoderfailure = true; } else { // Forney algorithm... //Compute Omega(x) using the key equation for RS-decoding Omega.set_degree(2 * t); Omegatemp = Lambda * (One + Xi); for (j = 0; j <= 2 * t; j++) { Omega[j] = Omegatemp[j]; } //Find the error/erasure magnitude polynomial by treating them the same Psiprime = formal_derivate(Lambda*Gamma); errorpos = concat(errorpos, erasure_positions); ex.clear(); for (j = 0; j < errorpos.length(); j++) { Xk = GF(q, errorpos(j)); Xkinv = GF(q, 0) / Xk; // we calculate ex = - error polynomial, in order to avoid the // subtraction when recunstructing the corrected codeword ex[errorpos(j)] = (Xk * Omega(Xkinv)) / Psiprime(Xkinv); if (b != 1) { // non-narrow-sense code needs corrected error magnitudes int correction_exp = ( errorpos(j)*(1-b) ) % n; ex[errorpos(j)] *= GF(q, correction_exp + ( (correction_exp < 0) ? n : 0 )); } } //Reconstruct the corrected codeword. // instead of subtracting the error/erasures, we calculated // the negative error with 'ex' above cx = rx + ex; //Code word validation S.clear(); for (j = 1; j <= 2 * t; j++) { S[j] = cx(GF(q, b + j - 1)); } if (S.get_true_degree() >= 1) { decoderfailure = true; } } } else { cx = rx; decoderfailure = false; } //Find the message polynomial mbit.clear(); if (decoderfailure == false) { if (cx.get_true_degree() >= 1) { // A nonzero codeword was transmitted if (systematic) { for (j = 0; j < k; j++) { mx[j] = cx[j]; } } else { mx = divgfx(cx, g); } for (j = 0; j <= mx.get_true_degree(); j++) { mbit.replace_mid(j * m, mx[j].get_vectorspace()); } } } else { //Decoder failure. // for a systematic code it is better to extract the undecoded message // from the received code word, i.e. obtaining a bit error // prob. p_b << 1/2, than setting all-zero (p_b = 1/2) if (systematic) { mbit = coded_bits.mid(i * n * m, k * m); } else { mbit = zeros_b(k); } no_dec_failure = false; } decoded_message.replace_mid(i * m * k, mbit); cw_isvalid(i) = (!decoderfailure); } return no_dec_failure; }