map_decoding.m

该文件夹为空时块码－卷积码级联系统的仿真程序

function [LLR_app_d]=map_decoding(init_state,state_num,info_num,LLR_apr_c)
% MAP decoding for convolutional code


Infty = 1e10;

% load trellis
load next_out.mat;
load next_state.mat;
load last_out.mat;
load last_state.mat;

% Initialization of alpha, alpha need stage 0...K-1 (Alpha is the log version of alpha)
Alpha = -Infty*ones(state_num,info_num+1);  % actually alpha(:,infonum+1) need not calculated
Alpha(init_state,1) = 0;

% Initialization of beta, beta need stage 1...K (Beta is the log version of beta)
Beta = -Infty*ones(state_num,info_num);
Beta(init_state,info_num) = 0;

% Forward Recursive Calculation of alpha
for stage=2:info_num+1
    for state=1:state_num
        gamma = -Infty*ones(state_num,1); % transition probability from all prev state to this state
        gamma(last_state(state,1))=((2*last_out(state,1)-1)*LLR_apr_c(2*stage-3)+(2*last_out(state,2)-1)*LLR_apr_c(2*stage-2))/2;
        gamma(last_state(state,2))=((2*last_out(state,3)-1)*LLR_apr_c(2*stage-3)+(2*last_out(state,4)-1)*LLR_apr_c(2*stage-2))/2;
        
        if(sum(exp(gamma+Alpha(:,stage-1)))<1e-300)
            Alpha(state,stage)=-Infty;
        elseif(sum(exp(gamma+Alpha(:,stage-1)))<Inf)
            Alpha(state,stage) = log( sum( exp( gamma+Alpha(:,stage-1) ) ) );
        else    % Inf -- When (gamma+Alpha(:,stage-1)) is too large, use Max-Log approximation
            Alpha(state,stage) = max( gamma+Alpha(:,stage-1) );
            %Alpha(state,stage) = Infty;
        end
        
    end
    %tempmax(stage) = max(Alpha(:,stage));
    %Alpha(:,stage) = Alpha(:,stage) - tempmax(stage);
end

% Backward Recursive Calculation of beta
for stage=info_num-1:-1:1
    for state=1:state_num
        gamma = -Infty*ones(state_num,1);
        gamma(next_state(state,1))=((2*next_out(state,1)-1)*LLR_apr_c(2*stage+1)+(2*next_out(state,2)-1)*LLR_apr_c(2*stage+2))/2;   % input 0
        gamma(next_state(state,2))=((2*next_out(state,3)-1)*LLR_apr_c(2*stage+1)+(2*next_out(state,4)-1)*LLR_apr_c(2*stage+2))/2;   % input 1
        
        if(sum(exp(gamma+Beta(:,stage+1)))<1e-300)
            Beta(state,stage)=-Infty;
        elseif(sum(exp(gamma+Beta(:,stage+1)))<Inf)
            Beta(state,stage) = log(sum(exp(gamma+Beta(:,stage+1))));
        else    % Inf -- When (gamma+Beta(:,stage+1)) is too large, use Max-Log approximation
            Beta(state,stage) = max(gamma+Beta(:,stage+1));
            %Beta(state,stage) = Infty;
        end
        
    end
    %tempmax(stage) = max(Beta(:,stage));
    %Beta(:,stage) = Beta(:,stage) - tempmax(stage);
    %Beta(:,stage) = Beta(:,stage) - tempmax(stage+1);
end

% Compute the information bits soft output, log-likelihood ratio in this block
LLR_app_d=zeros(1,info_num);
temp1=zeros(1,state_num);
temp0=zeros(1,state_num);
for stage=1:info_num
    for state=1:state_num
        gamma1=((2*next_out(state,3)-1)*LLR_apr_c(2*stage-1)+(2*next_out(state,4)-1)*LLR_apr_c(2*stage))/2;
        %temp1(state) = exp(Alpha(state,stage) + Beta(next_state(state,2),stage) + gamma1);
        temp1(state) = Alpha(state,stage) + Beta(next_state(state,2),stage) + gamma1;   % Log
        
        gamma0=((2*next_out(state,1)-1)*LLR_apr_c(2*stage-1)+(2*next_out(state,2)-1)*LLR_apr_c(2*stage))/2;
        %temp0(state) = exp(Alpha(state,stage) + Beta(next_state(state,1),stage) + gamma0);
        temp0(state) = Alpha(state,stage) + Beta(next_state(state,1),stage) + gamma0;   % Log
    end
    LLR_app_d(stage) = max(temp1) - max(temp0);     % Max-Log approximation
    %LLR_app_d(stage) = log(sum(temp1)) - log(sum(temp0));
end