maea_total.m

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

            clear i;
            clear j;
            clear k;
            clear l;
            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的目标函数值
                    New1a=0;
                    New2a=0;
                    for l=1:code
                        New1a=New1a+New(l)*2^(code-l);
                    end
                    for l=(code+1):(2*code)
                        New2a=New2a+New(l)*2^(2*code-l);
                    end
                    New1=New1a*4.096/(2^code-1)-2.048;
                    New2=New2a*4.096/(2^code-1)-2.048;
                    % 目标值
                    NewTag=100*(New1^2-New2^2)^2+(1-New1)^2;
                    if NewTag>LRefTag
                        Learning=0;% 第一种自学习方法的自学习布尔标值位
                        break;
                    end
                end
                clear h;
                clear i;
                clear j;
                clear k;
                clear l;
                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的目标函数值
                            Newer1a=0;
                            Newer2a=0;
                            for l=1:code
                                Newer1a=Newer1a+Newer(l)*2^(code-l);
                            end
                            for l=(code+1):(2*code)
                                Newer2a=Newer2a+Newer(l)*2^(2*code-l);
                            end
                            Newer1=Newer1a*4.096/(2^code-1)-2.048;
                            Newer2=Newer2a*4.096/(2^code-1)-2.048;
                            % 目标值
                            NewerTag=100*(Newer1^2-Newer2^2)^2+(1-Newer1)^2;
                            if NewerTag>LRefTag
                                Learning1=0;% 第二种自学习方法的自学习布尔标值位
                                break;
                            end
                        end
                        clear h;
                        clear i;
                        clear j;
                        clear k;
                        clear l;
                        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 k;
    m=0;
    for h=1:Lsize
        for k=1:Lsize
            m=m+1;
            LT1a=0;
            LT2a=0;
            for l=1:code
                LT1a=LT1a+L(h,k,l)*2^(code-l);
            end
            for l=(code+1):(2*code)
                LT2a=LT2a+L(h,k,l)*2^(2*code-l);
            end
            LT1=LT1a*4.096/(2^code-1)-2.048;
            LT2=LT2a*4.096/(2^code-1)-2.048;
            % 目标值
            LTTag(m)=100*(LT1^2-LT2^2)^2+(1-LT1)^2;
        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;
end
plot(LTag_max);
title('最优值随进化代数的变化趋势');
xlabel('进化代数');
ylabel('最优值');
clear i;
clear j;
clear k;
clear h;
clear l;
clear m;
clear n;
L11a=0;
L12a=0;
for i=1:code
    L11a=L11a+L(1,1,i)*2^(code-i);
end
for j=(code+1):(2*code)
    L12a=L12a+L(1,1,j)*2^(2*code-j);
end
L11=L11a*4.096/(2^code-1)-2.048;
L12=L12a*4.096/(2^code-1)-2.048;
Tag_final=100*(L11^2-L12^2)^2+(1-L11)^2;
x1max=L11;
x2max=L12;
for h=1:Lsize
    for k=1:Lsize
        L1a=0;
        L2a=0;
        for l=1:code
            L1a=L1a+L(h,k,l)*2^(code-l);
        end
        for l=(code+1):(2*code)
            L2a=L2a+L(h,k,l)*2^(2*code-l);
        end
        L1=L1a*4.096/(2^code-1)-2.048;
        L2=L2a*4.096/(2^code-1)-2.048;
        % 目标值
        Tag=100*(L1^2-L2^2)^2+(1-L1)^2;
        if Tag>Tag_final
            Tag_final=Tag;
            x1max=L1;
            x2max=L2;
        end
    end
end
disp('函数全局最优值为： ');
disp(Tag_final)
disp('取得最优值时的变量值分别为： ');
disp('x1=');
disp(x1max)
disp('x2=');
disp(x2max)