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;
}