decode_rs.m

由RS码、卷积码构成的级联码

function y=decode_rs(x)
%rs译码
m=8;        
N=2^m-1;   
t=16;         
K=N-2*t;
pp = 285;
alpha = gf(2, m, pp);
zero = gf(0, m, pp);
one = gf(1, m, pp);
%creating alpha array
alpha_tb=gf(zeros(1, 2*t), m, pp);
for i=1:2*t;
    alpha_tb(i)=alpha^i;
end;
%syndrome
syndrome_o = gf(zeros(1, 2*t), m, pp);
syndrome = gf(zeros(1, 2*t), m, pp);
for i = 1:N,
    syndrome_o = syndrome_o.*alpha_tb +x(i);
    cat = 1;
end;
%reverse s(2t-1)...s(0)
for i=1:2*t,
    syndrome(i)=syndrome_o(2*t+1-i);
end;
%ibma
lamda = gf([1, zeros(1, t)], m, pp);
lamda0 = gf([1, zeros(1, t)], m, pp);
b = gf([0, 1, zeros(1, t)], m, pp);
k = 0;
gamma = one;
delta = zero;
syndrome_array1 = gf(zeros(1, t+1), m, pp);

for r = 1:2*t,
    %step 1:
    r1 = 2*t-r+1;
    r2 = min(r1+t, 2*t);
    num = r2-r1+1;
    syndrome_array1(1:num) = syndrome(r1:r2);
    delta = syndrome_array1*lamda';  
    %step 2:
    lamda0 = lamda;
    lamda = gamma*lamda-delta*b(1:t+1);  
    %step 3:
    if((delta ~= zero) && (K>=0))
        b(2:2+t)=lamda0;
        gamma = delta;
        k=-k-1;
    else
        b(2:2+t) = b(1:t+1);
        gamma = gamma;
        k=k+1;
    end    
   mini=1;
end 
omega = gf(zeros(1, t), m, pp);
syndrome_array2 = gf(zeros(1, t), m, pp);
for i= 1:t,
    i1 = 2*t-i+1;
    syndrome_array2(1:i) = syndrome(i1: 2*t);
    omega(i) = syndrome_array2*lamda(1:t)';    
end;
%separate the even and the odd parts of lamda and omega
even=floor(t/2)*2;
if(even==t)
    odd=t-1;
else
    odd=t;
end
%lamda_even=lamda(1:2:even+1);
%lamda_odd=lamda(2:2:odd+1);

%inverstable
inverse_tb = gf(zeros(1, t+1), m, pp);
for i=1:t+1,
    inverse_tb(i) = alpha^(-i+1);
end;
%inverse_omega=inverse_tb(1:t);

%iteratively compute omega 迭代算法 
lamda_v=gf(0, m, pp);
lamda_ov=gf(0, m, pp);
omega_v=gf(0, m, pp);
accu_tb=gf(ones(1, t+1), m,pp);
accu_tb1=gf(ones(1, t), m, pp);
for i=1:N,
    root=alpha^(1-i);
    lamda_v=lamda*accu_tb';
    lamda_ov=lamda(2:2:odd+1)*accu_tb(2:2:odd+1)';
    omega_v=omega*accu_tb1';
    
    accu_tb=accu_tb.*inverse_tb;
    accu_tb1=accu_tb1.*inverse_tb(1:t);
    
    if(lamda_v==zero)
        error(1,N-i+1)=1;
        ev=(omega_v/lamda_ov)*root;
        evv=ev.x;
        error(2, N-i+1)=double(evv);
    else
        error(1, N-i+1)=0;
        error(2, N-i+1)=0;
    end
    kk=1;
end

found = find(error(1,:)~=0);
error(2, found);
error=error(2,:);
codeout=x+error;
z=codeout(:,1:223);
z_x=z.x;
y=double(z_x);