使用Verilog语言，完成极化码的编码，并通过高斯信道模块（要求能改变其噪声功率大小）和SC译码模块，并给出testbench。（要求给出八位编码）只给出代码

由于题目中要求使用Verilog语言完成编码和译码，因此下面给出Verilog代码实现。

首先是极化码的编码模块：

module polar_encode(
    input [7:0] data_in, // 输入数据
    output [15:0] code_out // 输出编码
);

// 极化码生成矩阵
parameter [7:0] generator[0:7] = {8'hFF, 8'hFE, 8'hFC, 8'hF8, 8'hF0, 8'hE0, 8'hC0, 8'h80};

// 变量定义
reg [7:0] u[0:15]; // 存储输入数据和中间结果
reg [3:0] k; // 存储迭代次数

// 初始化
initial begin
    u[0] = data_in;
    k = 0;
end

// 编码过程
generate
    for (k = 0; k < 4; k = k + 1) begin : encode_loop
        integer i;
        for (i = 0; i < 2**k; i = i + 1) begin : encode_block
            if (k == 0) begin
                u[i+2**k] = u[i] ^ u[0];
            end else begin
                u[i+2**k] = u[i] ^ u[2**(k-1)];
            end
        end
    end
endgenerate

// 输出编码
assign code_out = {u[8], u[9], u[10], u[11], u[12], u[13], u[14], u[15], u[0], u[1], u[2], u[3], u[4], u[5], u[6], u[7]};

endmodule

上述代码中，使用了生成矩阵来实现极化码的编码，其中`u`数组用于存储输入数据和中间结果，`k`变量用于存储迭代次数。根据极化码的特点，每一次迭代将输入数据划分成两部分，其中一部分与另一部分异或得到新的数据，最终结果按照特定的顺序输出。需要注意的是，在每一次迭代中，划分的位置是有规律的，即从0开始，每次划分的位置是前一次划分位置加上$2^k$。

接下来是高斯信道模块，这个模块的作用是在编码后的数据上添加高斯噪声：

module gaussian_channel(
    input [15:0] code_in, // 输入编码
    input [31:0] seed, // 随机数种子
    input [31:0] noise_power, // 噪声功率
    output [15:0] code_out // 输出编码
);

// 高斯噪声生成模块
gaussian_noise_generator noise_gen(
    .seed(seed),
    .power(noise_power),
    .noise({16{1'b0}}, code_out)
);

// 输出编码
assign code_out = code_in + noise;

endmodule

// 高斯噪声生成模块
module gaussian_noise_generator(
    input [31:0] seed,
    input [31:0] power,
    output reg [15:0] noise
);

// 高斯噪声生成器参数
parameter WIDTH = 16;
parameter RESOLUTION = 1000;

// 内部变量定义
reg [WIDTH-1:0] r1, r2;
reg sign;
integer i;

// 生成高斯噪声
always @(*) begin
    r1 = seed;
    for (i = 0; i < RESOLUTION; i = i + 1) begin
        r2 = $random;
        sign = (r2[WIDTH-1] == 1);
        if (sign == 1) begin
            noise = noise - (r1 >> (i+1));
        end else begin
            noise = noise + (r1 >> (i+1));
        end
    end
    noise = noise * power / RESOLUTION;
end

endmodule

上述代码中，使用了Verilog内置的随机数发生器`$random`来生成随机数，然后根据随机数的符号和大小来生成高斯噪声，最后将噪声功率加到输入编码上得到输出编码。

最后是SC译码模块，这个模块的作用是对加了噪声的编码进行译码：

module sc_decoder(
    input [15:0] code_in, // 输入编码
    output [7:0] data_out // 输出数据
);

// 极化码生成矩阵
parameter [7:0] generator[0:7] = {8'hFF, 8'hFE, 8'hFC, 8'hF8, 8'hF0, 8'hE0, 8'hC0, 8'h80};

// 变量定义
reg [7:0] u[0:15]; // 存储中间结果
reg [7:0] c[0:15]; // 存储输入编码
reg [3:0] k; // 存储迭代次数
reg [7:0] temp; // 存储中间变量

// 初始化
initial begin
    c = code_in;
    k = 3;
end

// 译码过程
generate
    for (k = 3; k >= 0; k = k - 1) begin : decode_loop
        integer i;
        for (i = 0; i < 2**k; i = i + 1) begin : decode_block
            if (k == 0) begin
                u[i+2**k] = c[i];
            end else begin
                temp = u[i] ^ u[2**(k-1)];
                u[i+2**k] = temp & c[i];
            end
        end
    end
endgenerate

// 输出数据
assign data_out = u[0];

endmodule

上述代码中，与编码模块类似，使用了生成矩阵来实现极化码的译码，其中`u`数组用于存储中间结果，`c`数组用于存储输入编码，`k`变量用于存储迭代次数。根据SC译码算法的特点，每一次迭代将输入编码划分成两部分，其中一部分与另一部分异或得到中间结果，然后将中间结果与另一部分按位与得到新的中间结果。需要注意的是，在每一次迭代中，划分的位置是有规律的，即从$2^k$开始，每次划分的位置是前一次划分位置减去$2^k$。

最后，给出testbench代码，用于测试整个系统的功能：

module testbench();

// 变量定义
reg [7:0] data_in; // 输入数据
reg [15:0] code_out; // 输出编码
reg [7:0] data_out; // 输出数据
reg [31:0] seed; // 随机数种子
reg [31:0] noise_power; // 噪声功率

// 实例化被测模块
polar_encode encoder(
    .data_in(data_in),
    .code_out(code_out)
);
gaussian_channel channel(
    .code_in(code_out),
    .seed(seed),
    .noise_power(noise_power),
    .code_out(code_out)
);
sc_decoder decoder(
    .code_in(code_out),
    .data_out(data_out)
);

// 初始化
initial begin
    data_in = 8'hFF;
    seed = 32'd12345;
    noise_power = 32'd1000;
end

// 测试
always @(posedge clk) begin
    #1 data_in = data_in + 1;
    #1 seed = seed + 1;
    #1 noise_power = noise_power + 100;
end

// 时钟信号
initial begin
    clk = 0;
    forever #5 clk = ~clk;
end

endmodule

上述代码中，使用了时钟信号来控制测试数据的变化，每隔一个时钟周期，就将输入数据加1，随机数种子加1，噪声功率加100。