maea_main_1.m

基于MATLAB的遗传算法的源程序,有需要的可以参考下

% 该算法中进化代数设定为Tmax,完成则终止,而不用误差作为终止条件
%%%%% 初始化智能体网格L %%%%%
% 网格规模Lsize*Lsize,维数dim
clc
clear all
Lsize=input('请输入智能体网格行列数目(整数)以确定其规模: ');
num=input('请输入参与负荷分配的机组数目(整数): ');
global code
code=input('请输入编码位数： ');
dim=code*num;
Tmax=20;%设置进化代数
L=rand(Lsize,Lsize,dim);
for i=1:Lsize
    for j=1:Lsize
        for k=1:dim
            if L(i,j,k)<=0.5
                L(i,j,k)=0;
            else
                L(i,j,k)=1;
            end
        end
    end
end
clear i;
clear j;
clear k;
for T=1:Tmax
    %%%%% 竞争行为 %%%%%
    % 设定参数：竞争感知范围Rs，本次参考点坐标I、J
    Rs=1;
    for I=1:Lsize
        for J=1:Lsize
            % 计算参考点的目标函数值
            for i=1:dim
                A(i)=L(I,J,i);
            end
            RefTag=MAEA_Result(A);
            clear i;
            % 循环求取竞争邻域坐标
            for i=(I-Rs):(I+Rs)
                for j=(J-Rs):(J+Rs)
                    if i<1
                        i=i+Lsize;
                    end
                    if i>Lsize
                        i=i-Lsize;
                    end                
                    if j<1
                        j=j+Lsize;
                    end
                    if j>Lsize
                        j=j-Lsize;
                    end
                    for k=1:dim
                        B(k)=L(i,j,k);
                    end
                    % 计算某一竞争邻域元素的目标函数值
                    NeibTag=MAEA_Result(B);
                    % 比较参考点与该竞争邻域元素的目标值大小，确定大能量智能体的坐标
                    if RefTag<NeibTag
                        RefTag=NeibTag;
                        imax=i;% 能量较大智能体的i坐标
                        jmax=j;% 能量较大智能体的j坐标
                    else
                        imax=I;
                        jmax=J;
                    end
                end
            end
            clear i;
            clear j;
            clear k;
            % 竞争行为的子代的产生
            if imax~=I|jmax~=J
                for i=1:dim
                    C(i)=L(I,J,i);% 参考点第三维向量
                end
                for j=1:dim
                    D(j)=L(imax,jmax,j);% 最大竞争邻域智能体第三维向量
                end
                % 引入参数Dh，确定采用何种竞争方式
                Dh=0.5;
                HD=0;% 向量C和D的海明距离
                for h=1:dim
                    if C(h)~=D(h)
                        HD=HD+1;
                    end
                end
                if HD/dim>Dh
                    % 第一种竞争方式
                    for k=1:dim
                        Rdm1=randint;
                        if C(k)==D(k)
                            L(I,J,k)=L(imax,jmax,k);
                        elseif Rdm1==0
                            L(I,J,k)=L(imax,jmax,k);
                        else
                            L(I,J,k)=1-L(imax,jmax,k);
                        end
                    end
                else
                    % 第二种竞争方式
                    for l=1:dim
                        Rdm2=rand;
                        if Rdm2>1/dim
                            L(I,J,l)=L(imax,jmax,l);
                        else
                            L(I,J,l)=1-L(imax,jmax,l);
                        end
                    end
                end
            else
                for m=1:dim
                    L(I,J,m)=L(I,J,m);
                end
            end
        end
    end
    clear h;
    clear i;
    clear j;
    clear k;
    clear l;
    clear m;
    clear imax;
    clear jmax;
    %%%%% 自学习行为 %%%%%
    % 构造总学习表
    LL=zeros(dim*(dim+1)/2,2);
    h=0;
    for i=1:dim
        for j=i:dim
            h=h+1;
            LL(h,1)=i;
            LL(h,2)=j;
        end
    end
    clear h;
    clear i;
    clear j;
    % 设定参数：自学习感知范围LRs，本次参考点坐标LI、LJ
    LRs=2;
    for LI=1:Lsize
        for LJ=1:Lsize
            % 计算参考点的目标函数值
            for i=1:dim
                E(i)=L(LI,LJ,i);
            end
            LRefTag=MAEA_Result(E);
            clear i;
            % 循环求取自学习邻域目标函数值
            LNeibTag=zeros(1,(1+2*LRs)^2);% 自学习邻域目标函数值向量
            h=0;
            for i=(LI-LRs):(LI+LRs)
                for j=(LJ-LRs):(LJ+LRs)
                    h=h+1;
                    if i<1
                        i=i+Lsize;
                    end
                    if i>Lsize
                        i=i-Lsize;
                    end                
                    if j<1
                        j=j+Lsize;
                    end
                    if j>Lsize
                        j=j-Lsize;
                    end
                    % 计算某一自学习邻域元素的目标函数值
                    for k=1:dim
                        F(k)=L(i,j,k);
                    end                  
                    LNeibTag(h)=MAEA_Result(F);
                end
            end
            clear h;
            clear i;
            clear j;
            clear k;
            h=0;
            for i=1:(1+2*LRs)^2
                if LRefTag>=LNeibTag(i)
                    h=h+1;
                end
            end
            if h==(1+2*LRs)^2% 判断参考点是否可以获得自学习机会
                j=0;
                x=0;% 随机选择行的存储变量
                y=0;% 迭加变量，用于判断是否遍历整个总学习表
                while 1
                    y=y+1;
                    if y==dim*(dim+1)/2+1
                        Learning=1;% 第一种自学习方法的自学习布尔标值位
                        break;
                    end
                    while 1
                        if j~=x
                            break;
                        end
                        j=randint(1,1,[1,dim*(dim+1)/2]);% 随机选择一行
                    end
                    x=j;% 存储本次循环所选择的j行，用于和下次比较
                    % 第一种自学习方式
                    New=zeros(1,dim);% 初始化新智能体New
                    for k=1:dim
                        if k<LL(j,1)|k>LL(j,2)
                            New(k)=L(LI,LJ,k);
                        else
                            New(k)=1-L(LI,LJ,k);
                        end
                    end
                    % 计算新智能体New的目标函数值
                    NewTag=MAEA_Result(New);
                    if NewTag>LRefTag
                        Learning=0;% 第一种自学习方法的自学习布尔标值位
                        break;
                    end
                end
                clear h;
                clear i;
                clear j;
                clear k;
                clear x;
                clear y;
                switch Learning
                    case 0
                        for i=1:dim
                            L(LI,LJ,i)=New(i);
                        end
                    case 1
                        % 随机产生1:n整数的一个排列
                        for h=1:dim
                            G(h)=h;
                        end
                        for j=dim:-1:2
                            k=randint(1,1,[1,j]);
                            l=G(j);G(j)=G(k);G(k)=l;
                        end
                        clear h;
                        clear i;
                        clear j;
                        clear k;
                        clear l;
                        j=0;
                        x=0;% 随机选择行的存储变量
                        y=0;% 迭加变量，用于判断是否遍历整个总学习表
                        while 1
                            y=y+1;
                            if y==dim*(dim+1)/2+1
                                Learning1=1;% 第二种自学习方法的自学习布尔标值位
                                break;
                            end
                            while 1
                                if j~=x
                                    break;
                                end
                                j=randint(1,1,[1,dim*(dim+1)/2]);% 随机选择一行
                            end
                            x=j;% 存储本次循环所选择的j行，用于和下次比较
                            % 第二种自学习方式
                            Newer=zeros(1,dim);% 初始化新智能体Newer
                            for k=1:dim
                                if k<LL(j,1)|k>LL(j,2)
                                    Newer(G(k))=L(LI,LJ,G(k));
                                else
                                    Newer(G(k))=1-L(LI,LJ,G(k));
                                end
                            end
                            % 计算新智能体Newer的目标函数值
                            NewerTag=MAEA_Result(Newer);
                            if NewerTag>LRefTag
                                Learning1=0;% 第二种自学习方法的自学习布尔标值位
                                break;
                            end
                        end
                        clear h;
                        clear i;
                        clear j;
                        clear k;
                        clear x;
                        clear y;
                        switch Learning1
                            case 0
                                for i=1:dim
                                    L(LI,LJ,i)=Newer(i);
                                end
                            otherwise
                                for j=1:dim
                                    L(LI,LJ,j)=L(LI,LJ,j);
                                end
                        end
                end
            else
                for k=1:dim
                    L(LI,LJ,k)=L(LI,LJ,k);
                end
            end
        end
    end
    clear j;
    clear k;
    m=0;
    for h=1:Lsize
        for k=1:Lsize
            for j=1:dim
                H(j)=L(h,k,j);
            end
            m=m+1;
            % 最终网格目标值向量
            LTTag(m)=MAEA_Result(H);
        end
    end
    LTTag_max=LTTag(1);
    for n=1:m
        if LTTag(n)>LTTag_max
            LTTag_max=LTTag(n);
        end
    end
    LTag_max(T)=LTTag_max;% 当前代进化完成时的最优个体
    abso(T)=abs(LTag_max(T));% 当前最优个体与最优值的误差绝对值
end
figure(1);
subplot(211);
plot(LTag_max);
title('最优值随进化代数的变化趋势');
xlabel('进化代数');
ylabel('最优值');
subplot(212);
plot(abso);
title('当前解与最优值的误差');
xlabel('进化代数');
ylabel('误差');
clear h;
clear i;
clear j;
clear k;
clear m;
clear n;
for i=1:dim
    K(i)=L(1,1,i);
end
[Tag_final,x1max,x2max]=MAEA_Result(K);
for h=1:Lsize
    for k=1:Lsize
        for j=1:dim
            M(j)=L(h,k,j);
        end
        [Tag,x1,x2]=MAEA_Result(M);
        if Tag>Tag_final
            Tag_final=Tag;
            x1max=x1;
            x2max=x2;
        end
    end
end
disp('函数全局最优值为： ');
disp(Tag_final)
disp('最优值个体分别为： ');
disp('x1=');
disp(x1max)
disp('x2=');
disp(x2max)