convolutional_map_decoder.m

20072010.rar:tubor,LDPC,convolution的部分代码

function [uncoded_LLR, coded_LLR] = convolutional_map_decoder(input_data, trellis, system_info)



% This function takes in the input_data to be equalised
% as well as the trellis structure of the channel
% and the system information

% It returns the LLR


prob(1,:) = 1 ./ (1 + exp(input_data)); % probability of zero
prob(2,:) = 1 - prob(1, :); % probability of one

% alpha initialisation
alpha = zeros(trellis.numStates, system_info.uncoded_frame_length + 1);
alpha(1,1) = 1;

% beta initialisation
beta = zeros(trellis.numStates, system_info.uncoded_frame_length);
beta(1:trellis.numStates, system_info.uncoded_frame_length) = 1/trellis.numStates;

% Trace forward to compute gamma and alpha
for uncoded_bit = 1:system_info.uncoded_frame_length
    
    for state = 1:trellis.numStates
        for bit = 1:2
            last_outputs = de2bi(trellis.lastOutputs(state, bit), 2, 'left-msb');
            gamma(state, bit, uncoded_bit) = 0.5 .* prob(last_outputs(1) + 1, (uncoded_bit - 1) .* system_info.n + 1) .* prob(last_outputs(2) + 1, uncoded_bit .* system_info.n);
            alpha(state, uncoded_bit + 1) = alpha(state, uncoded_bit + 1) + gamma(state, bit, uncoded_bit) * alpha(trellis.lastStates(state, bit) + 1, uncoded_bit); 
        end
    end
    normalised_factor = sum(alpha(:,uncoded_bit + 1));
    alpha(:, uncoded_bit + 1) = alpha(:, uncoded_bit + 1) ./ normalised_factor;
end

uncoded_bit = system_info.uncoded_frame_length;
numerator = 0;
denominator = 0;

for state = 1:trellis.numStates
    for bit = 1:2
        if trellis.lastBits(state, bit) == 1
             numerator = numerator + gamma(state, bit, uncoded_bit) * alpha(trellis.lastStates(state, bit) + 1, uncoded_bit) * beta(state, uncoded_bit);
         else
             denominator = denominator + gamma(state, bit, uncoded_bit) * alpha(trellis.lastStates(state, bit) + 1, uncoded_bit) * beta(state, uncoded_bit);
         end
     end
 end

uncoded_LLR(uncoded_bit) = log(numerator/denominator);

numerator = zeros(1, system_info.n);
denominator = zeros(1, system_info.n);
    
for state = 1:trellis.numStates
    for input_bit = 1:2
        last_bits = de2bi(trellis.lastOutputs(state, input_bit), system_info.n, 'left-msb');
        for bit = 1:system_info.n
            if last_bits(bit) == 1
                numerator(bit) = numerator(bit) + gamma(state, input_bit, uncoded_bit) * alpha(trellis.lastStates(state, input_bit) + 1, uncoded_bit) * beta(state, uncoded_bit);
            else
                denominator(bit) = denominator(bit) + gamma(state, input_bit, uncoded_bit) * alpha(trellis.lastStates(state, input_bit) + 1, uncoded_bit) * beta(state, uncoded_bit);
            end
        end
    end
end

for bit = 1:system_info.n
    coded_LLR((uncoded_bit - 1) .* system_info.n + bit) = log(numerator(bit)/denominator(bit));
end

% Trace backward to compute beta
for uncoded_bit = system_info.uncoded_frame_length - 1:-1:1
    
    for state = 1:trellis.numStates
        for bit = 1:2
            beta(trellis.lastStates(state, bit) + 1, uncoded_bit) = beta(trellis.lastStates(state, bit) + 1, uncoded_bit) + gamma(state, bit, uncoded_bit + 1) * beta(state, uncoded_bit + 1);
        end
    end
    normalised_factor = sum(beta(:,uncoded_bit));
    beta(:, uncoded_bit) = beta(:, uncoded_bit) ./ normalised_factor;
    
    numerator = 0;
    denominator = 0;
    
    for state = 1:trellis.numStates
        for bit = 1:2
            if trellis.lastBits(state, bit) == 1
                numerator = numerator + gamma(state, bit, uncoded_bit) * alpha(trellis.lastStates(state, bit) + 1, uncoded_bit) * beta(state, uncoded_bit);
            else
                denominator = denominator + gamma(state, bit, uncoded_bit) * alpha(trellis.lastStates(state, bit) + 1, uncoded_bit) * beta(state, uncoded_bit);
            end
        end
    end

    uncoded_LLR(uncoded_bit) = log(numerator/denominator);
    
    numerator = zeros(1, system_info.n);
    denominator = zeros(1, system_info.n);
    
    for state = 1:trellis.numStates
        for input_bit = 1:2
            last_bits = de2bi(trellis.lastOutputs(state, input_bit), 2, 'left-msb');
            for bit = 1:system_info.n
                if last_bits(bit) == 1
                    numerator(bit) = numerator(bit) + gamma(state, input_bit, uncoded_bit) * alpha(trellis.lastStates(state, input_bit) + 1, uncoded_bit) * beta(state, uncoded_bit);
                else
                    denominator(bit) = denominator(bit) + gamma(state, input_bit, uncoded_bit) * alpha(trellis.lastStates(state, input_bit) + 1, uncoded_bit) * beta(state, uncoded_bit);
                end
            end
        end
    end
    
    for bit = 1:system_info.n
        coded_LLR((uncoded_bit - 1) .* system_info.n + bit) = log(numerator(bit)/denominator(bit));
    end
end