log_map.m

用Matlab仿真turbocode的算法

function [L_ud,L_cd]=log_MAP(L_u,L_c,L_start_alpha,L_end_beta,ST)

%
%ST-->4xm matrix; n=4, m=qu^K
%ST(1,:)-->input
%ST(2,:)-->output
%ST(3,:)-->left state
%ST(4,:)-->right state


[qu,N_info]=size(L_u); 
[qc,N_code]=size(L_c);
N_st=size(L_start_alpha,1); %number of states; for binary inputs-->2^(K-1)
m=size(ST,2); 
Inf=1e10;
% initialization of L_ud/L_cd
L_ud=-Inf*ones(size(L_u));
L_cd=-Inf*ones(size(L_c));

% initialization of log alpha/beta
%total N_info+1 columns for alpha; L_alpha-->column 1:N_info; L_alpha_next-->colummn 2:N_info+1
L_alpha=-Inf*ones(N_st,N_info);
L_alpha_next=L_alpha;
L_alpha(:,1)=L_start_alpha;
%total N_info+1 columns for beta; L_beta-->column 2:N_info+1; L_alpha_former-->colummn 1:N_info
L_beta=-Inf*ones(N_st,N_info);
L_beta_former=L_beta;
L_beta(:,end)=L_end_beta;


%MAP: forward recursion
L_alpha_s=L_alpha(:,1);       
for i=1:N_info %for all input info
    L_u_s=L_u(:,i); %for single input info, i.e. one column of L_U
    L_c_s=L_c(:,i);
    
    L_alpha_next_s=L_alpha_next(:,i);
    
    for j=1:m %for all branches 
        ST_s=ST(:,j); %for single branch
        f_z=L_u_s(ST_s(1))+L_c_s(ST_s(2))+L_alpha_s(ST_s(3));
        L_alpha_next_s(ST_s(4))=max(L_alpha_next_s(ST_s(4)),f_z)+log(1+exp(-abs(f_z-L_alpha_next_s(ST_s(4)))));
    end%end of j
    
    L_alpha_next(:,i)= L_alpha_next_s;
    L_alpha_s=L_alpha_next_s;
end%end of i

L_alpha(:,2:end)=L_alpha_next(:,1:end-1);%rebuild L_alpha


%MAP: backward recursion
L_beta_s=L_beta(:,end);
for i=N_info:-1:1
    L_u_s=L_u(:,i); 
    L_ud_s=L_ud(:,i);
    L_c_s=L_c(:,i);
    L_cd_s=L_cd(:,i);
    L_beta_former_s=L_beta_former(:,i);
    
    for j=1:m 
        ST_s=ST(:,j);
        f_z=L_u_s(ST_s(1))+L_c_s(ST_s(2))+L_beta_s(ST_s(4));
        L_beta_former_s(ST_s(3))=max(L_beta_former_s(ST_s(3)),f_z)+log(1+exp(-abs(f_z-L_beta_former_s(ST_s(3)))));
                
        f_z=f_z+L_alpha(ST_s(3),i);
        %f_z=L_beta_former_s(ST_s(3))+L_alpha(ST(3),i);
        L_ud_s(ST_s(1))=max(L_ud_s(ST_s(1)),f_z)+log(1+exp(-abs(f_z-L_ud_s(ST_s(1)))));
        L_cd_s(ST_s(2))=max(L_cd_s(ST_s(2)),f_z)+log(1+exp(-abs(f_z-L_cd_s(ST_s(2)))));
        
    end%end of j
        
    L_beta_s=L_beta_former_s;
    
    L_ud_nom=L_ud_s(1);
    for x=2:qu
        L_ud_nom=max(L_ud_nom,L_ud_s(x))+log(1+exp(-abs(L_ud_s(x)-L_ud_nom)));
      
    end
    L_ud_s=L_ud_s-L_ud_nom;
    L_ud(:,i)=L_ud_s;
    
    
    L_cd_nom=L_cd_s(1);
    for x=2:qc
        L_cd_nom=max(L_cd_nom,L_cd_s(x))+log(1+exp(-abs(L_cd_s(x)-L_cd_nom)));
        
    end
    L_cd_s=L_cd_s-L_cd_nom;
    L_cd(:,i)=L_cd_s;
    
    
end%end of i