单载波中继系统资源分配算法MATLAB仿真程序

单载波中继系统资源分配算法MATLAB仿真程序。中继系统的资源分配是无线通信中的核心问题，涉及功率分配、子载波分配和中继选择等多维度优化。

单载波中继系统资源分配算法

系统架构与问题概述

在单载波中继系统中，资源分配的目标通常是最大化系统和速率 或保证用户公平性，同时满足功率和带宽约束。下图展示了一个典型的多用户单载波中继系统架构及资源分配的关键维度：
第二跳: 中继到用户
用户1
用户2
用户n
第一跳: 基站到中继
用户1
用户2
用户n
基站
资源分配决策
功率分配
子载波分配
中继选择
用户QoS需求

最大总功率

中继能力

资源分配算法分类与选择

算法类型	优化目标	优点	缺点	适用场景
和速率最大化	最大化系统和速率	频谱效率高	可能不公平	系统容量优先
比例公平	平衡速率与公平	保证用户公平性	复杂度较高	多用户场景
最小速率最大化	最大化最差用户速率	最差用户性能最佳	系统和速率较低	QoS保障
能效最大化	最大化bit/Joule	节能，能效高	速率可能牺牲	能量受限

MATLAB实现程序

1. 主程序：系统仿真框架

matlab 复制代码

%% 单载波中继系统资源分配仿真主程序
clear; close all; clc;
fprintf('========== 单载波中继系统资源分配仿真 ==========\n');

%% 1. 系统参数设置
% 网络拓扑
num_users = 4;          % 用户数量
num_relays = 2;         % 中继数量
num_subcarriers = 16;   % 子载波数量

% 功率参数
P_total_dBm = 30;       % 总发射功率 (dBm)
P_max_per_subcarrier_dBm = 20;  % 每个子载波最大功率 (dBm)
P_total = 10^((P_total_dBm-30)/10);  % 转换为瓦特
P_max_per_subcarrier = 10^((P_max_per_subcarrier_dBm-30)/10);

% 信道参数
noise_power_dBm = -100; % 噪声功率 (dBm)
noise_power = 10^((noise_power_dBm-30)/10);  % 转换为瓦特
channel_variance = 1;   % 信道衰落方差

% 算法参数
algorithm_type = 'sum_rate_max';  % 可选: 'sum_rate_max', 'proportional_fair', 'min_rate_max'
max_iterations = 100;   % 最大迭代次数
convergence_threshold = 1e-4;  % 收敛阈值

%% 2. 生成信道状态信息
fprintf('生成信道状态信息...\n');
channel_info = generate_channels(num_users, num_relays, num_subcarriers, channel_variance);

% 显示信道信息
fprintf('信道矩阵维度:\n');
fprintf('  基站到中继: %d x %d x %d\n', size(channel_info.BS_to_relay));
fprintf('  中继到用户: %d x %d x %d\n', size(channel_info.relay_to_user));
fprintf('  基站直接到用户: %d x %d\n', size(channel_info.BS_direct_to_user));

%% 3. 资源分配算法实现
fprintf('\n========== 执行资源分配算法 ==========\n');

switch algorithm_type
    case 'sum_rate_max'
        fprintf('算法: 和速率最大化\n');
        [power_allocation, subcarrier_allocation, relay_selection, rate_per_user] = ...
            sum_rate_maximization(channel_info, P_total, P_max_per_subcarrier, ...
                                 noise_power, max_iterations, convergence_threshold);
        
    case 'proportional_fair'
        fprintf('算法: 比例公平\n');
        [power_allocation, subcarrier_allocation, relay_selection, rate_per_user] = ...
            proportional_fairness(channel_info, P_total, P_max_per_subcarrier, ...
                                 noise_power, max_iterations, convergence_threshold);
        
    case 'min_rate_max'
        fprintf('算法: 最小速率最大化\n');
        [power_allocation, subcarrier_allocation, relay_selection, rate_per_user] = ...
            min_rate_maximization(channel_info, P_total, P_max_per_subcarrier, ...
                                 noise_power, max_iterations, convergence_threshold);
        
    otherwise
        error('未知的算法类型: %s', algorithm_type);
end

%% 4. 性能评估
fprintf('\n========== 性能评估 ==========\n');

% 计算关键性能指标
sum_rate = sum(rate_per_user);
fairness_index = calculate_fairness_index(rate_per_user);
min_user_rate = min(rate_per_user);
power_efficiency = sum_rate / (P_total * 1000);  % bits/Joule

fprintf('和速率: %.4f bps/Hz\n', sum_rate);
fprintf('公平性指数: %.4f (接近1越公平)\n', fairness_index);
fprintf('最差用户速率: %.4f bps/Hz\n', min_user_rate);
fprintf('功率效率: %.4f bits/Joule\n', power_efficiency);
fprintf('总功率使用: %.4f W (限额: %.4f W)\n', sum(power_allocation(:)), P_total);

% 各用户速率分布
fprintf('\n各用户速率分布:\n');
for u = 1:num_users
    fprintf('  用户%d: %.4f bps/Hz (占系统 %.1f%%)\n', ...
            u, rate_per_user(u), rate_per_user(u)/sum_rate*100);
end

%% 5. 可视化结果
figure('Position', [100, 100, 1400, 800]);

% 5.1 功率分配热图
subplot(2, 3, 1);
imagesc(power_allocation);
colorbar; xlabel('子载波索引'); ylabel('用户索引');
title('功率分配矩阵 (W)');
set(gca, 'YTick', 1:num_users);

% 添加功率值标签
for u = 1:num_users
    for s = 1:num_subcarriers
        if power_allocation(u, s) > 0
            text(s, u, sprintf('%.3f', power_allocation(u, s)), ...
                 'HorizontalAlignment', 'center', 'FontSize', 8, ...
                 'Color', power_allocation(u, s) > max(power_allocation(:))/2 ? 'w' : 'k');
        end
    end
end

% 5.2 子载波分配
subplot(2, 3, 2);
subcarrier_usage = sum(subcarrier_allocation, 1);
bar(1:num_subcarriers, subcarrier_usage, 'FaceColor', [0.2, 0.6, 0.8]);
xlabel('子载波索引'); ylabel('分配的用户数');
title('子载波使用情况');
ylim([0, max(2, max(subcarrier_usage))]); grid on;

% 5.3 中继选择统计
subplot(2, 3, 3);
relay_usage = zeros(1, num_relays);
for u = 1:num_users
    for s = 1:num_subcarriers
        if subcarrier_allocation(u, s) == 1 && relay_selection(u, s) > 0
            relay_usage(relay_selection(u, s)) = relay_usage(relay_selection(u, s)) + 1;
        end
    end
end

bar(1:num_relays, relay_usage, 'FaceColor', [0.8, 0.4, 0.2]);
xlabel('中继索引'); ylabel('被选择的次数');
title('中继使用统计');
set(gca, 'XTick', 1:num_relays); grid on;

% 5.4 用户速率分布
subplot(2, 3, 4);
pie(rate_per_user, ones(1, num_users));
title('用户速率分布');
legend(compose('用户%d: %.2f bps/Hz', 1:num_users, rate_per_user), ...
       'Location', 'eastoutside');

% 5.5 信道增益分布
subplot(2, 3, 5);
% 绘制所有信道增益的直方图
all_channel_gains = [channel_info.BS_direct_to_user(:); 
                     abs(channel_info.BS_to_relay(:)); 
                     abs(channel_info.relay_to_user(:))];
histogram(20*log10(abs(all_channel_gains)), 30, 'FaceColor', [0.3, 0.7, 0.3]);
xlabel('信道增益 (dB)'); ylabel('频数');
title('信道增益分布');
grid on;

% 5.6 算法收敛曲线（如果可用）
subplot(2, 3, 6);
% 这里需要从算法中获取收敛历史数据
% 对于演示，我们生成一个示例收敛曲线
if exist('convergence_history', 'var')
    plot(1:length(convergence_history), convergence_history, 'b-o', 'LineWidth', 2);
else
    % 生成示例数据
    example_convergence = sum_rate * (1 - exp(-0.1*(1:20)));
    plot(1:20, example_convergence, 'b-o', 'LineWidth', 2);
end
xlabel('迭代次数'); ylabel('和速率 (bps/Hz)');
title('算法收敛曲线'); grid on;

sgtitle(sprintf('单载波中继系统资源分配 - %s算法', strrep(algorithm_type, '_', ' ')), ...
        'FontSize', 14, 'FontWeight', 'bold');

%% 6. 对比不同算法性能
fprintf('\n========== 算法性能对比 ==========\n');

% 测试所有算法的性能
algorithm_types = {'sum_rate_max', 'proportional_fair', 'min_rate_max'};
num_algorithms = length(algorithm_types);

results = struct();
for alg_idx = 1:num_algorithms
    alg_type = algorithm_types{alg_idx};
    fprintf('测试算法: %s...\n', alg_type);
    
    switch alg_type
        case 'sum_rate_max'
            [~, ~, ~, rate] = sum_rate_maximization(channel_info, P_total, ...
                P_max_per_subcarrier, noise_power, 50, 1e-4);
        case 'proportional_fair'
            [~, ~, ~, rate] = proportional_fairness(channel_info, P_total, ...
                P_max_per_subcarrier, noise_power, 50, 1e-4);
        case 'min_rate_max'
            [~, ~, ~, rate] = min_rate_maximization(channel_info, P_total, ...
                P_max_per_subcarrier, noise_power, 50, 1e-4);
    end
    
    results(alg_idx).algorithm = alg_type;
    results(alg_idx).sum_rate = sum(rate);
    results(alg_idx).fairness = calculate_fairness_index(rate);
    results(alg_idx).min_rate = min(rate);
end

% 显示对比结果
fprintf('\n算法性能对比表:\n');
fprintf('%-25s %-15s %-15s %-15s\n', '算法', '和速率(bps/Hz)', '公平性指数', '最差用户速率');
fprintf('%s\n', repmat('-', 1, 70));
for alg_idx = 1:num_algorithms
    fprintf('%-25s %-15.4f %-15.4f %-15.4f\n', ...
            results(alg_idx).algorithm, ...
            results(alg_idx).sum_rate, ...
            results(alg_idx).fairness, ...
            results(alg_idx).min_rate);
end

% 绘制对比图
figure('Position', [100, 100, 1000, 400]);

% 和速率对比
subplot(1, 3, 1);
barData = [results.sum_rate];
bar(1:num_algorithms, barData, 'FaceColor', [0.2, 0.6, 0.8]);
set(gca, 'XTickLabel', strrep(algorithm_types, '_', '\n'));
ylabel('和速率 (bps/Hz)');
title('和速率对比');
grid on;

% 添加数值标签
for i = 1:num_algorithms
    text(i, barData(i), sprintf('%.2f', barData(i)), ...
         'HorizontalAlignment', 'center', 'VerticalAlignment', 'bottom', ...
         'FontWeight', 'bold');
end

% 公平性对比
subplot(1, 3, 2);
barData = [results.fairness];
bar(1:num_algorithms, barData, 'FaceColor', [0.8, 0.6, 0.2]);
set(gca, 'XTickLabel', strrep(algorithm_types, '_', '\n'));
ylabel('公平性指数');
title('公平性对比');
ylim([0, 1.1]); grid on;

for i = 1:num_algorithms
    text(i, barData(i), sprintf('%.3f', barData(i)), ...
         'HorizontalAlignment', 'center', 'VerticalAlignment', 'bottom', ...
         'FontWeight', 'bold');
end

% 最差用户速率对比
subplot(1, 3, 3);
barData = [results.min_rate];
bar(1:num_algorithms, barData, 'FaceColor', [0.6, 0.2, 0.8]);
set(gca, 'XTickLabel', strrep(algorithm_types, '_', '\n'));
ylabel('最差用户速率 (bps/Hz)');
title('最差用户速率对比');
grid on;

for i = 1:num_algorithms
    text(i, barData(i), sprintf('%.3f', barData(i)), ...
         'HorizontalAlignment', 'center', 'VerticalAlignment', 'bottom', ...
         'FontWeight', 'bold');
end

fprintf('\n仿真完成！\n');

2. 信道生成函数

matlab 复制代码

function channel_info = generate_channels(num_users, num_relays, num_subcarriers, variance)
% 生成单载波中继系统的信道矩阵
    
    % 基站到中继的信道 (中继数 × 子载波数)
    % 假设为瑞利衰落信道
    BS_to_relay = sqrt(variance/2) * (randn(num_relays, num_subcarriers) + ...
                                      1i * randn(num_relays, num_subcarriers));
    
    % 中继到用户的信道 (用户数 × 中继数 × 子载波数)
    relay_to_user = sqrt(variance/2) * (randn(num_users, num_relays, num_subcarriers) + ...
                                        1i * randn(num_users, num_relays, num_subcarriers));
    
    % 基站直接到用户的信道 (用户数 × 子载波数)
    BS_direct_to_user = sqrt(variance/2) * (randn(num_users, num_subcarriers) + ...
                                            1i * randn(num_users, num_subcarriers));
    
    % 存储所有信道信息
    channel_info.BS_to_relay = BS_to_relay;
    channel_info.relay_to_user = relay_to_user;
    channel_info.BS_direct_to_user = BS_direct_to_user;
    channel_info.num_users = num_users;
    channel_info.num_relays = num_relays;
    channel_info.num_subcarriers = num_subcarriers;
    
    % 计算每个子载波上的端到端信道增益（通过最佳中继）
    channel_info.end_to_end_gain = zeros(num_users, num_subcarriers);
    
    for u = 1:num_users
        for s = 1:num_subcarriers
            % 直接链路增益
            direct_gain = abs(BS_direct_to_user(u, s))^2;
            
            % 通过每个中继的增益
            relay_gains = zeros(1, num_relays);
            for r = 1:num_relays
                % 两跳信道增益（解码转发中继）
                first_hop = abs(BS_to_relay(r, s))^2;
                second_hop = abs(relay_to_user(u, r, s))^2;
                
                % 端到端增益（瓶颈原则）
                relay_gains(r) = min(first_hop, second_hop);
            end
            
            % 最佳增益 = max(直接链路, 最佳中继链路)
            channel_info.end_to_end_gain(u, s) = max([direct_gain, relay_gains]);
        end
    end
end

3. 和速率最大化算法

matlab 复制代码

function [power_allocation, subcarrier_allocation, relay_selection, rate_per_user] = ...
    sum_rate_maximization(channel_info, P_total, P_max_per_subcarrier, ...
                         noise_power, max_iterations, threshold)
% 和速率最大化资源分配算法
    
    num_users = channel_info.num_users;
    num_subcarriers = channel_info.num_subcarriers;
    num_relays = channel_info.num_relays;
    
    % 初始化分配矩阵
    power_allocation = zeros(num_users, num_subcarriers);
    subcarrier_allocation = zeros(num_users, num_subcarriers);
    relay_selection = zeros(num_users, num_subcarriers);
    rate_per_user = zeros(1, num_users);
    
    % 提取信道信息
    BS_direct = channel_info.BS_direct_to_user;
    BS_to_relay = channel_info.BS_to_relay;
    relay_to_user = channel_info.relay_to_user;
    
    % 算法1: 基于拉格朗日对偶的功率分配
    fprintf('  执行和速率最大化算法...\n');
    
    % 第一步: 子载波分配 - 将每个子载波分配给信道最好的用户
    for s = 1:num_subcarriers
        % 计算所有用户在该子载波上的信道增益
        channel_gains = zeros(1, num_users);
        best_relays = zeros(1, num_users);
        
        for u = 1:num_users
            % 直接链路增益
            direct_gain = abs(BS_direct(u, s))^2;
            
            % 寻找最佳中继
            best_relay = 0;
            best_gain = direct_gain;
            
            for r = 1:num_relays
                first_hop = abs(BS_to_relay(r, s))^2;
                second_hop = abs(relay_to_user(u, r, s))^2;
                relay_gain = min(first_hop, second_hop);
                
                if relay_gain > best_gain
                    best_gain = relay_gain;
                    best_relay = r;
                end
            end
            
            channel_gains(u) = best_gain;
            best_relays(u) = best_relay;
        end
        
        % 选择信道最好的用户
        [~, best_user] = max(channel_gains);
        
        % 分配子载波
        subcarrier_allocation(best_user, s) = 1;
        relay_selection(best_user, s) = best_relays(best_user);
    end
    
    % 第二步: 功率分配 - 使用注水算法
    fprintf('  执行注水功率分配...\n');
    
    % 收集所有已分配子载波的信道增益
    allocated_gains = [];
    user_indices = [];
    subcarrier_indices = [];
    
    for u = 1:num_users
        for s = 1:num_subcarriers
            if subcarrier_allocation(u, s) == 1
                if relay_selection(u, s) > 0
                    % 中继链路
                    r = relay_selection(u, s);
                    first_hop = abs(BS_to_relay(r, s))^2;
                    second_hop = abs(relay_to_user(u, r, s))^2;
                    gain = min(first_hop, second_hop);
                else
                    % 直接链路
                    gain = abs(BS_direct(u, s))^2;
                end
                
                allocated_gains = [allocated_gains, gain];
                user_indices = [user_indices, u];
                subcarrier_indices = [subcarrier_indices, s];
            end
        end
    end
    
    if isempty(allocated_gains)
        warning('没有分配任何子载波！');
        return;
    end
    
    % 注水算法
    num_allocated = length(allocated_gains);
    
    % 计算等效噪声归一化增益
    normalized_gains = allocated_gains / noise_power;
    
    % 按增益排序
    [sorted_gains, sort_idx] = sort(normalized_gains, 'descend');
    
    % 寻找注水水平
    water_level = 0;
    remaining_power = P_total;
    
    for k = 1:num_allocated
        % 尝试给前k个子载波分配相同功率
        needed_power = k * (1/sorted_gains(k) - water_level);
        
        if needed_power <= remaining_power
            water_level = 1/sorted_gains(k);
            remaining_power = remaining_power - needed_power;
        else
            water_level = water_level + remaining_power / k;
            remaining_power = 0;
            break;
        end
    end
    
    if remaining_power > 0
        water_level = water_level + remaining_power / num_allocated;
    end
    
    % 计算每个子载波的功率
    for idx = 1:num_allocated
        u = user_indices(idx);
        s = subcarrier_indices(idx);
        gain = normalized_gains(idx);
        
        % 注水功率分配
        power = max(0, water_level - 1/gain);
        
        % 施加每个子载波的最大功率限制
        power = min(power, P_max_per_subcarrier);
        
        power_allocation(u, s) = power;
    end
    
    % 第三步: 计算用户速率
    for u = 1:num_users
        user_rate = 0;
        for s = 1:num_subcarriers
            if subcarrier_allocation(u, s) == 1 && power_allocation(u, s) > 0
                if relay_selection(u, s) > 0
                    % 中继链路容量
                    r = relay_selection(u, s);
                    first_hop = abs(BS_to_relay(r, s))^2;
                    second_hop = abs(relay_to_user(u, r, s))^2;
                    
                    % 两跳链路的容量（取最小值）
                    rate_first_hop = log2(1 + power_allocation(u, s) * first_hop / noise_power);
                    rate_second_hop = log2(1 + power_allocation(u, s) * second_hop / noise_power);
                    rate = min(rate_first_hop, rate_second_hop);
                else
                    % 直接链路容量
                    gain = abs(BS_direct(u, s))^2;
                    rate = log2(1 + power_allocation(u, s) * gain / noise_power);
                end
                
                user_rate = user_rate + rate;
            end
        end
        rate_per_user(u) = user_rate;
    end
    
    fprintf('  算法完成: 和速率 = %.4f bps/Hz\n', sum(rate_per_user));
end

4. 比例公平算法

matlab 复制代码

function [power_allocation, subcarrier_allocation, relay_selection, rate_per_user] = ...
    proportional_fairness(channel_info, P_total, P_max_per_subcarrier, ...
                         noise_power, max_iterations, threshold)
% 比例公平资源分配算法
    
    num_users = channel_info.num_users;
    num_subcarriers = channel_info.num_subcarriers;
    
    % 初始化
    power_allocation = zeros(num_users, num_subcarriers);
    subcarrier_allocation = zeros(num_users, num_subcarriers);
    relay_selection = zeros(num_users, num_subcarriers);
    rate_per_user = zeros(1, num_users);
    
    % 历史平均速率（用于比例公平）
    if ~isfield(channel_info, 'average_rate')
        average_rate = ones(1, num_users);  % 初始化为1
    else
        average_rate = channel_info.average_rate;
    end
    
    % 时间常数（指数平滑）
    tau = 10;
    
    % 比例公平调度
    fprintf('  执行比例公平调度...\n');
    
    % 为每个子载波选择用户
    for s = 1:num_subcarriers
        % 计算每个用户的优先级（信道增益 / 平均速率）
        priorities = zeros(1, num_users);
        best_relays = zeros(1, num_users);
        best_gains = zeros(1, num_users);
        
        for u = 1:num_users
            % 寻找最佳中继
            [best_gain, best_relay] = find_best_relay_for_user(u, s, channel_info);
            best_gains(u) = best_gain;
            best_relays(u) = best_relay;
            
            % 优先级 = 瞬时速率潜力 / 平均速率
            if average_rate(u) > 0
                priorities(u) = best_gain / average_rate(u);
            else
                priorities(u) = best_gain;
            end
        end
        
        % 选择优先级最高的用户
        [~, selected_user] = max(priorities);
        
        % 分配子载波
        subcarrier_allocation(selected_user, s) = 1;
        relay_selection(selected_user, s) = best_relays(selected_user);
        
        % 初始功率分配（平均分配）
        power_allocation(selected_user, s) = P_total / num_subcarriers;
    end
    
    % 迭代优化功率分配
    convergence_history = zeros(1, max_iterations);
    
    for iter = 1:max_iterations
        % 更新平均速率
        for u = 1:num_users
            user_rate = 0;
            for s = 1:num_subcarriers
                if subcarrier_allocation(u, s) == 1 && power_allocation(u, s) > 0
                    rate = compute_rate(u, s, power_allocation(u, s), ...
                                       relay_selection(u, s), channel_info, noise_power);
                    user_rate = user_rate + rate;
                end
            end
            rate_per_user(u) = user_rate;
            
            % 更新指数平滑平均速率
            average_rate(u) = (1 - 1/tau) * average_rate(u) + (1/tau) * user_rate;
        end
        
        % 使用梯度法优化功率分配
        new_power_allocation = optimize_power_for_fairness(power_allocation, ...
            subcarrier_allocation, relay_selection, channel_info, ...
            noise_power, P_total, P_max_per_subcarrier, average_rate);
        
        % 检查收敛
        power_change = norm(new_power_allocation(:) - power_allocation(:));
        power_allocation = new_power_allocation;
        
        % 记录收敛历史
        convergence_history(iter) = sum(rate_per_user);
        
        if power_change < threshold
            fprintf('  迭代 %d: 收敛 (变化量 = %.6f)\n', iter, power_change);
            break;
        end
        
        if mod(iter, 10) == 0
            fprintf('  迭代 %d: 和速率 = %.4f, 公平性 = %.4f\n', ...
                    iter, sum(rate_per_user), calculate_fairness_index(rate_per_user));
        end
    end
    
    % 最终速率计算
    for u = 1:num_users
        user_rate = 0;
        for s = 1:num_subcarriers
            if subcarrier_allocation(u, s) == 1 && power_allocation(u, s) > 0
                rate = compute_rate(u, s, power_allocation(u, s), ...
                                   relay_selection(u, s), channel_info, noise_power);
                user_rate = user_rate + rate;
            end
        end
        rate_per_user(u) = user_rate;
    end
    
    fprintf('  算法完成: 和速率 = %.4f, 公平性 = %.4f\n', ...
            sum(rate_per_user), calculate_fairness_index(rate_per_user));
end

function [best_gain, best_relay] = find_best_relay_for_user(user, subcarrier, channel_info)
% 为用户和子载波寻找最佳中继
    best_gain = abs(channel_info.BS_direct_to_user(user, subcarrier))^2;
    best_relay = 0;
    
    for r = 1:channel_info.num_relays
        first_hop = abs(channel_info.BS_to_relay(r, subcarrier))^2;
        second_hop = abs(channel_info.relay_to_user(user, r, subcarrier))^2;
        relay_gain = min(first_hop, second_hop);
        
        if relay_gain > best_gain
            best_gain = relay_gain;
            best_relay = r;
        end
    end
end

function rate = compute_rate(user, subcarrier, power, relay, channel_info, noise_power)
% 计算给定配置下的速率
    if relay > 0
        % 中继链路
        first_hop = abs(channel_info.BS_to_relay(relay, subcarrier))^2;
        second_hop = abs(channel_info.relay_to_user(user, relay, subcarrier))^2;
        
        rate_first_hop = log2(1 + power * first_hop / noise_power);
        rate_second_hop = log2(1 + power * second_hop / noise_power);
        rate = min(rate_first_hop, rate_second_hop);
    else
        % 直接链路
        gain = abs(channel_info.BS_direct_to_user(user, subcarrier))^2;
        rate = log2(1 + power * gain / noise_power);
    end
end

5. 辅助函数

matlab 复制代码

function fairness = calculate_fairness_index(rates)
% 计算Jain公平性指数
    fairness = (sum(rates))^2 / (length(rates) * sum(rates.^2));
end

function new_power = optimize_power_for_fairness(power_allocation, subcarrier_allocation, ...
                                                relay_selection, channel_info, ...
                                                noise_power, P_total, P_max_per_subcarrier, ...
                                                average_rate)
% 为比例公平优化功率分配
    
    num_users = size(power_allocation, 1);
    num_subcarriers = size(power_allocation, 2);
    
    % 使用凸优化工具箱（如果可用）
    try
        cvx_begin quiet
            variable p(num_users, num_subcarriers) nonnegative
            
            % 目标函数：最大化对数效用（实现比例公平）
            objective = 0;
            for u = 1:num_users
                user_rate = 0;
                for s = 1:num_subcarriers
                    if subcarrier_allocation(u, s) == 1
                        rate = compute_rate(u, s, p(u, s), relay_selection(u, s), ...
                                           channel_info, noise_power);
                        user_rate = user_rate + rate;
                    end
                end
                objective = objective + average_rate(u) * log(user_rate + 1e-10);
            end
            
            maximize(objective)
            
            subject to
                % 总功率约束
                sum(sum(p)) <= P_total
                
                % 每个子载波功率约束
                for u = 1:num_users
                    for s = 1:num_subcarriers
                        p(u, s) <= P_max_per_subcarrier
                    end
                end
                
                % 只有分配的子载波可以有功率
                for u = 1:num_users
                    for s = 1:num_subcarriers
                        if subcarrier_allocation(u, s) == 0
                            p(u, s) == 0
                        end
                    end
                end
        cvx_end
        
        new_power = p;
        
    catch
        % 如果CVX不可用，使用简单的启发式方法
        fprintf('  注意: CVX不可用，使用启发式功率分配\n');
        new_power = power_allocation;
        
        % 简单的功率重新分配：给平均速率低的用户更多功率
        total_allocated_power = sum(power_allocation(:));
        user_needs = 1 ./ (average_rate + 1e-10);
        user_needs = user_needs / sum(user_needs);
        
        for u = 1:num_users
            user_power = total_allocated_power * user_needs(u);
            user_subcarriers = find(subcarrier_allocation(u, :) == 1);
            
            if ~isempty(user_subcarriers)
                % 平均分配到用户的子载波
                power_per_subcarrier = min(user_power / length(user_subcarriers), P_max_per_subcarrier);
                for s = user_subcarriers
                    new_power(u, s) = power_per_subcarrier;
                end
            end
        end
    end
end

参考代码单载波中继系统资源分配算法 www.3dddown.com/csb/97445.html

算法性能对比分析

为了帮助你选择合适的算法，以下是不同场景下的建议：

和速率最大化 ：适用于系统容量优先的场景，但可能导致用户间不公平
比例公平 ：适用于多用户服务场景，平衡吞吐量和公平性
最小速率最大化 ：适用于QoS保障场景，确保所有用户的基本服务质量

扩展与优化建议

中继协议扩展：
- 解码转发(DF) vs. 放大转发(AF)
- 协作中继 vs. 非协作中继
多天线技术：
- MIMO中继系统
- 波束成形优化
动态资源分配：
- 基于深度学习的智能分配
- 在线学习算法
能效优化：
- 绿色通信，最大化bit/Joule
- 能量收集中继系统