【蚁狮算法】基于具有自适应边界与最优引导的莱维飞行蚁狮优化算法（ABLALO）求解单目标优化问题matlab代码...

1 简介

针对蚁狮算法存在探索与开发能力不平衡的缺点,提出了具有自适应边界与最优引导的莱维飞行改进算法.首先蚁狮调整边界范围,蚂蚁做莱维飞行,以此平衡探索与开发能力;其次较差蚁狮做高斯变异,并通过自适应最优引导方程,提高收敛速度和全局搜索能力.6个标准测试函数的仿真结果表明,相比其它算法,提出的改进算法提高了最优解的精度和收敛速度.

2 部分代码

登录后复制

          
          

           
           %___________________________________________________________________%
           
           
%  Ant Lion Optimizer (ALO) source codes demo version 1.0           %
           
           
% You can simply define your cost in a seperate file and load its handle to fobj 
           
           
% The initial parameters that you need are:
           
           
%__________________________________________
           
           
% fobj = @YourCostFunction
           
           
% dim = number of your variables
           
           
% Max_iteration = maximum number of generations
           
           
% SearchAgents_no = number of search agents
           
           
% lb=[lb1,lb2,...,lbn] where lbn is the lower bound of variable n
           
           
% ub=[ub1,ub2,...,ubn] where ubn is the upper bound of variable n
           
           
% If all the variables have equal lower bound you can just
           
           
% define lb and ub as two single number numbers
           
           
% To run ALO: [Best_score,Best_pos,cg_curve]=ALO(SearchAgents_no,Max_iteration,lb,ub,dim,fobj)
           
           
function [min_value,Elite_antlion_fitness,Elite_antlion_position,Convergence_curve]=ALO(N,Max_iter,lb,ub,dim,fobj)
           
           
% Initialize the positions of antlions and ants
           
           
antlion_position=initialization(N,dim,ub,lb);
           
           
ant_position=initialization(N,dim,ub,lb);
           
           
% Initialize variables to save the position of elite, sorted antlions, 
           
           
% convergence curve, antlions fitness, and ants fitness
           
           
Sorted_antlions=zeros(N,dim);
           
           
Elite_antlion_position=zeros(1,dim);
           
           
Elite_antlion_fitness=inf;
           
           
Convergence_curve=zeros(1,Max_iter);
           
           
antlions_fitness=zeros(1,N);
           
           
ants_fitness=zeros(1,N);
           
           
% Calculate the fitness of initial antlions and sort them
           
           
for i=1:size(antlion_position,1)
           
           
    antlions_fitness(1,i)=fobj(antlion_position(i,:)); 
           
           
end
           
           
[sorted_antlion_fitness,sorted_indexes]=sort(antlions_fitness);
           
           
for newindex=1:N
           
           
     Sorted_antlions(newindex,:)=antlion_position(sorted_indexes(newindex),:);
           
           
end
           
           
Elite_antlion_position=Sorted_antlions(1,:);
           
           
Elite_antlion_fitness=sorted_antlion_fitness(1);
           
           
% Main loop start from the second iteration since the first iteration 
           
           
% was dedicated to calculating the fitness of antlions
           
           
Current_iter=2; 
           
           
while Current_iter<Max_iter+1
           
           
    % This for loop simulate random walks
           
           
    for i=1:size(ant_position,1)
           
           
        % Select ant lions based on their fitness (the better anlion the higher chance of catching ant)
           
           
        Rolette_index=RouletteWheelSelection(1./sorted_antlion_fitness);
           
           
        if Rolette_index==-1  
           
           
            Rolette_index=1;
           
           
        end
           
           
        % RA is the random walk around the selected antlion by rolette wheel
           
           
        RA=Random_walk_around_antlion(dim,Max_iter,lb,ub, Sorted_antlions(Rolette_index,:),Current_iter);
           
           
        % RA is the random walk around the elite (best antlion so far)
           
           
        [RE]=Random_walk_around_antlion(dim,Max_iter,lb,ub, Elite_antlion_position(1,:),Current_iter);
           
           
        ant_position(i,:)= (RA(Current_iter,:)+RE(Current_iter,:))/2; % Equation (2.13) in the paper          
           
           
    end
           
           
    for i=1:size(ant_position,1)  
           
           
        % Boundar checking (bring back the antlions of ants inside search
           
           
        % space if they go beyoud the boundaries
           
           
        Flag4ub=ant_position(i,:)>ub;
           
           
        Flag4lb=ant_position(i,:)<lb;
           
           
        ant_position(i,:)=(ant_position(i,:).*(~(Flag4ub+Flag4lb)))+ub.*Flag4ub+lb.*Flag4lb;  
           
           
        ants_fitness(1,i)=fobj(ant_position(i,:));        
           
           
    end
           
           
    % Update antlion positions and fitnesses based of the ants (if an ant 
           
           
    % becomes fitter than an antlion we assume it was cought by the antlion  
           
           
    % and the antlion update goes to its position to build the trap)
           
           
    double_population=[Sorted_antlions;ant_position];
           
           
    double_fitness=[sorted_antlion_fitness ants_fitness];
           
           
    [double_fitness_sorted I]=sort(double_fitness);
           
           
    double_sorted_population=double_population(I,:);
           
           
    antlions_fitness=double_fitness_sorted(1:N);
           
           
    Sorted_antlions=double_sorted_population(1:N,:);
           
           
    % Update the position of elite if any antlinons becomes fitter than it
           
           
    if antlions_fitness(1)<Elite_antlion_fitness 
           
           
        Elite_antlion_position=Sorted_antlions(1,:);
           
           
        Elite_antlion_fitness=antlions_fitness(1);
           
           
    end
           
           
    % Keep the elite in the population
           
           
    Sorted_antlions(1,:)=Elite_antlion_position;
           
           
    antlions_fitness(1)=Elite_antlion_fitness;
           
           
    % Update the convergence curve
           
           
    Convergence_curve(Current_iter)=Elite_antlion_fitness;
           
           
    % Display the iteration and best optimum obtained so far
           
           
    if mod(Current_iter,1)==0
           
           
        display(['At iteration ', num2str(Current_iter), ' the elite fitness is ', num2str(Elite_antlion_fitness)]);
           
           
    end
           
           
min_value(Current_iter)=Elite_antlion_fitness;
           
           
    Current_iter=Current_iter+1; 
           
           
end
          
          

• 1.
• 2.
• 3.
• 4.
• 5.
• 6.
• 7.
• 8.
• 9.
• 10.
• 11.
• 12.
• 13.
• 14.
• 15.
• 16.
• 17.
• 18.
• 19.
• 20.
• 21.
• 22.
• 23.
• 24.
• 25.
• 26.
• 27.
• 28.
• 29.
• 30.
• 31.
• 32.
• 33.
• 34.
• 35.
• 36.
• 37.
• 38.
• 39.
• 40.
• 41.
• 42.
• 43.
• 44.
• 45.
• 46.
• 47.
• 48.
• 49.
• 50.
• 51.
• 52.
• 53.
• 54.
• 55.
• 56.
• 57.
• 58.
• 59.
• 60.
• 61.
• 62.
• 63.
• 64.
• 65.
• 66.
• 67.
• 68.
• 69.
• 70.
• 71.
• 72.
• 73.
• 74.
• 75.
• 76.
• 77.
• 78.
• 79.
• 80.
• 81.
• 82.
• 83.
• 84.
• 85.
• 86.
• 87.

3 仿真结果

4 参考文献

[1]王若安, 周越文, 韩博,等. 具有自适应边界与最优引导的莱维飞行蚁狮优化算法[J]. 微电子学与计算机, 2018, 35(9):7.

博主简介：擅长智能优化算法、神经网络预测、信号处理、元胞自动机、图像处理、路径规划、无人机等多种领域的Matlab仿真，相关matlab代码问题可私信交流。

部分理论引用网络文献，若有侵权联系博主删除。