nsga2算法matlab代码

以下是NSGA-II算法的MATLAB代码示例：

% NSGA-II Algorithm
% f: Objective function array (each row represents an individual)
% nPop: Population size
% nVar: Number of decision variables (objective function parameters)
% nObj: Number of objective functions
% lb: Lower bound of decision variables
% ub: Upper bound of decision variables
% MaxIt: Maximum number of iterations
% pc: Crossover probability
% nc: Number of offsprings produced by crossover
% pm: Mutation probability
% nm: Number of offsprings produced by mutation
function [X, F] = nsga2(f, nPop, nVar, nObj, lb, ub, MaxIt, pc, nc, pm, nm)

    % Parameters
    p = 1;                      % Initial generation
    mu = nPop;                  % Parent population size
    lambda = nPop;              % Offspring population size
    pc = pc;                    % Crossover probability
    nc = nc;                    % Number of offsprings produced by crossover
    pm = pm;                    % Mutation probability
    nm = nm;                    % Number of offsprings produced by mutation
    
    % Initialization
    X = lhsdesign(nPop, nVar, 'criterion', 'maximin', 'iterations', 100)';
    X = repmat(lb, 1, nPop) + repmat((ub-lb), 1, nPop).*X;
    F = evaluate(f, X);
    [F, R] = non_dominated_sorting(F);
    F1 = F{1};
    Q = binary_tournament_selection(mu, R);
    
    % Main Loop
    while p <= MaxIt
        
        % Generate Offsprings
        Y = [];
        for i = 1:nc
            p1 = Q(randi([1, mu], 1));
            p2 = Q(randi([1, mu], 1));
            [y1, y2] = crossover(X(:, p1), X(:, p2), lb, ub, pc);
            Y = [Y, y1, y2];
        end
        for i = 1:nm
            p = Q(randi([1, mu], 1));
            y = mutation(X(:, p), lb, ub, pm);
            Y = [Y, y];
        end
        
        % Combine Parent and Offspring Populations
        X = [X, Y];
        F = evaluate(f, X);
        
        % Non-dominated Sorting
        [F, R] = non_dominated_sorting(F);
        F1 = F{1};
        
        % Truncation
        if length(F1) >= nPop
            X = X(:, R{1}(1:nPop));
            F = F{1}(1:nPop, :);
            break
        end
        
        % Parent Selection
        Q = binary_tournament_selection(mu, R);
        
        % Increase Generation Count
        p = p + 1;
        
    end
    
end

% Non-dominated Sorting
function [F, R] = non_dominated_sorting(F)
    
    nObj = size(F, 2);
    nPop = size(F, 1);
    
    S = cell(nPop, 1);
    n = zeros(nPop, 1);
    F1 = [];
    for i = 1:nPop
        S{i} = [];
        n(i) = 0;
        for j = 1:nPop
            if i ~= j
                flag = 0;
                for k = 1:nObj
                    if F(i, k) > F(j, k)
                        flag = 1;
                        break
                    end
                end
                if flag == 0
                    S{i} = [S{i}, j];
                elseif flag == 1
                    n(i) = n(i) + 1;
                end
            end
        end
        if n(i) == 0
            F1 = [F1; F(i, :)];
        end
    end
    
    F = {};
    R = {};
    F{1} = F1;
    i = 1;
    while ~isempty(F{i})
        Q = [];
        for j = 1:size(F{i}, 1)
            p = find(all(bsxfun(@eq, F{i}(j, :), F), 2));
            for k = 1:length(S{p})
                n(S{p}(k)) = n(S{p}(k)) - 1;
                if n(S{p}(k)) == 0
                    Q = [Q, S{p}(k)];
                end
            end
        end
        i = i + 1;
        F{i} = F(Q, :);
        R{i} = Q;
    end
    
end

% Binary Tournament Selection
function Q = binary_tournament_selection(mu, R)
    
    nPop = length(R{1});
    Q = zeros(1, mu);
    for i = 1:mu
        p1 = randi([1, nPop], 1);
        p2 = randi([1, nPop], 1);
        if length(R{p1}) < length(R{p2})
            Q(i) = R{p1}(randi([1, length(R{p1})], 1));
        elseif length(R{p1}) > length(R{p2})
            Q(i) = R{p2}(randi([1, length(R{p2})], 1));
        else
            if rand < 0.5
                Q(i) = R{p1}(randi([1, length(R{p1})], 1));
            else
                Q(i) = R{p2}(randi([1, length(R{p2})], 1));
            end
        end
    end
    
end

% Evaluate Objective Functions
function F = evaluate(f, X)
    
    nPop = size(X, 2);
    nObj = size(f(X(:, 1)), 2);
    F = zeros(nPop, nObj);
    for i = 1:nPop
        F(i, :) = f(X(:, i))';
    end
    
end

% Crossover
function [y1, y2] = crossover(x1, x2, lb, ub, pc)
    
    nVar = length(x1);
    y1 = x1;
    y2 = x2;
    if rand < pc
        j = randi([1, nVar-1], 1);
        for i = j:nVar
            y1(i) = x2(i);
            y2(i) = x1(i);
        end
    end
    y1 = bound(y1, lb, ub);
    y2 = bound(y2, lb, ub);
    
end

% Mutation
function y = mutation(x, lb, ub, pm)
    
    nVar = length(x);
    y = x;
    for i = 1:nVar
        if rand < pm
            y(i) = lb(i) + (ub(i)-lb(i))*rand(1);
        end
    end
    y = bound(y, lb, ub);
    
end

% Bound
function y = bound(x, lb, ub)
    
    y = max(x, lb');
    y = min(y, ub');
    
end

这是一个基本的NSGA-II算法实现，你可以根据自己的需求进行修改和扩展。