写出针对上述编码器的解码器函数呗

以下是MATLAB实现Turbo码译码的函数：

function [decoded_bits] = turbo_decode(received_bits, N, K, R, interlvr_depth, max_iter)
% received_bits: 接收到的码字
% N: 编码器长度
% K: 信息比特数
% R: 编码速率
% interlvr_depth: 交织器的深度
% max_iter: 最大迭代次数

% 定义状态转移矩阵和 puncturing 矩阵
P = [0 2 1; 2 1 0; 1 0 2];
Punct = [1 1 0; 1 0 1; 0 1 1];

% 初始化译码器
dec_state1 = zeros(1, 8);
dec_state2 = zeros(1, 8);
LLR1 = zeros(1, N/2);
LLR2 = zeros(1, N/2);
soft_out1 = zeros(1, N/2);
soft_out2 = zeros(1, N/2);

% 初始化交织器
interlvr = randperm(N);

% 内部迭代次数
inner_iter = 5;

% 外部迭代
for iter = 1:max_iter
    % 交织
    deinterlvr = zeros(1, N);
    deinterlvr(interlvr) = 1:N;
    received_bits_int = received_bits(deinterlvr);
    
    % 硬判决
    LLR = 2*received_bits_int-1;
    
    % Turbo码译码器1
    [LLR1, dec_state1, soft_out1] = turbo_decode_iteration(LLR, LLR1, dec_state1, soft_out1, P, Punct, inner_iter);
    % 反交织
    soft_out1_int = soft_out1(interlvr);
    
    % Turbo码译码器2
    [LLR2, dec_state2, soft_out2] = turbo_decode_iteration(soft_out1_int, LLR2, dec_state2, soft_out2, P, Punct, inner_iter);
    % 反交织
    soft_out2_int = soft_out2(interlvr);
    
    % puncturing
    decoded_bits = zeros(1, K);
    for i = 1:K
        % 反交织
        interlvr_idx = mod(i-1, interlvr_depth)+1;
        interlvr_pos = interlvr(interlvr_idx);
        % 恢复信息比特
        if (mod(i-1, 3) ~= 0 || R == 1/2)
            decoded_bits(i) = soft_out1_int(interlvr_pos) < 0;
        else
            decoded_bits(i) = Punct(2-soft_out1_int(interlvr_pos)+1, 2-soft_out2_int(interlvr_pos)+1);
        end
    end
    
    % 检查译码是否正确
    if isequal(decoded_bits, (0:K-1 < K/2))
        break;
    end
end

% 输出译码结果
decoded_bits = decoded_bits(:).';
end

function [LLR, next_state, soft_out] = turbo_decode_iteration(LLR_in, cur_state, cur_soft_out, P, Punct, max_iter)
% LLR_in: 输入 LLR
% cur_state: 当前状态
% cur_soft_out: 当前软输出
% P: 状态转移矩阵
% Punct: puncturing 矩阵
% max_iter: 最大迭代次数

% 初始化 LLR 和软输出
LLR = LLR_in;
soft_out = cur_soft_out;

% 迭代
for iter = 1:max_iter
    % 更新左码器
    [LLR1, soft_out1] = conv_decode_iter(LLR, cur_state, P, Punct);
    % 更新右码器
    [LLR2, soft_out2] = conv_decode_iter(flip(LLR), flip(cur_state), P, Punct);
    LLR2 = flip(LLR2);
    soft_out2 = flip(soft_out2);
    % 计算软合并值
    soft_in = soft_out1 - soft_out2;
    % 更新软输出
    soft_out = soft_out1 + soft_out2;
    % 更新 LLR
    LLR = 2*atanh(tanh(0.5*soft_in).*tanh(0.5*LLR1)).*(LLR1 ~= Inf);
    % 更新状态
    next_state = zeros(1, length(cur_state)*2);
    for i = 1:length(cur_state)
        next_state(2*i-1:2*i+2) = bitxor(cur_state(i), [0 4 2 6]);
    end
    cur_state = next_state;
end
end

function [LLR, soft_out] = conv_decode_iter(LLR_in, cur_state, P, Punct)
% LLR_in: 输入 LLR
% cur_state: 当前状态
% P: 状态转移矩阵
% Punct: puncturing 矩阵

% 计算 LLR
LLR = zeros(1, length(LLR_in)/2);
for i = 1:length(LLR)
    output_bit1 = mod(sum(dec2bin(cur_state(2*i-1),3)-'0'.*P(1,:)),2);
    output_bit2 = mod(sum(dec2bin(cur_state(2*i),3)-'0'.*P(2,:)),2);
    output_bit3 = mod(sum(dec2bin(cur_state(2*i+1),3)-'0'.*P(3,:)),2);
    output_bit = Punct(output_bit1+1, output_bit2+1)*2-1;
    output_bit = output_bit*Punct(output_bit2+1, output_bit3+1)*2-1;
    soft_out = LLR_in(2*i-1) + LLR_in(2*i);
    LLR(i) = output_bit*soft_out;
end
end

该函数实现了Turbo码译码器，其中`received_bits`为接收到的码字，`N`为编码器长度，`K`为信息比特数，`R`为编码速率，`interlvr_depth`为交织器的深度，`max_iter`为最大迭代次数。

函数首先定义状态转移矩阵和 puncturing 矩阵，并初始化译码器和交织器。然后进行外部迭代，每次迭代先进行交织和硬判决，然后将结果输入到Turbo码译码器1中，再将其输出经过反交织后输入到Turbo码译码器2中，最后进行 puncturing 恢复信息比特，并检查译码是否正确。

在 Turbo 码译码器中，使用状态转移矩阵和 puncturing 矩阵计算输出比特和 LLR，然后进行软合并。在内部迭代中，先更新左码器和右码器，然后计算软合并值并更新 LLR 和状态。注意：该函数仅实现了 Turbo 码译码器，需要与编码器配合使用。