## I. flower pollination algorithm

Flower Pollination Algorithm (FPA) was proposed by Yang, a scholar at Cambridge University in 2012. Its basic idea comes from the simulation of natural flower self pollination and cross pollination. It is a new meta heuristic swarm intelligent random optimization technology. In order to simplify the calculation, it is assumed that each plant has only one flower and each flower has only one gamete. We can think that each gamete is a candidate solution in the solution space.

Through his research on flower pollination, Yang abstracted the following four rules:

1) Biological cross pollination is considered as the global detection behavior of the algorithm, and the pollinator realizes global pollination through Levy flight mechanism;

2) Abiotic self pollination is regarded as the local mining behavior of the algorithm, or local pollination;

3) The constancy of flowers can be regarded as the probability of reproduction, which is directly proportional to the similarity of two pollinated flowers;

4) The global and local pollination of flowers are regulated by the conversion probability p ∈ [0,1]. Due to the influence of physical proximity and wind, the conversion probability p is a very important parameter in the whole pollination activity. The experimental study on this parameter in reference [1] shows that P = 0.05 8 is more conducive to algorithm optimization.

Direct up steps (taking multivariate function optimization as an example):

Objective function: Min g = f (x1, X2, X3, X4......... XD)

Setting parameters: N (number of candidate solutions), iter (maximum number of iterations), p (conversion probability), lamda (Levy flight parameter)

Initialize the flower and randomly set an NXd matrix;

Calculate fitness, i.e. function value;

Obtain the optimal solution and the location of the optimal solution;

A cycle 1:1: iter

Cycle B

if rand < p

Global pollination;

else

Local pollination;

end if

Update the flowers and fitness of the new generation (function variables and function values);

B cycle end

Obtain the optimal solution and optimal solution location of the new generation;

A cycle end

Global update formula: xi(t+1) = xi(t) + L(xi(t) - xbest(t)) l follows Levy distribution. For details, you can search cuckoo algorithm.

Local renewal formula: xi(t+1) = xi(t) + m(xj(t) - xk(t)) m is a random number uniformly distributed on [0,1]. xj and xk are two different individuals

## 2, Flower pollination algorithm based on t-distribution perturbation strategy and mutation strategy

### (1) Chaotic map initializing individual position

### (2) global search based on t-distributed perturbation strategy

### (3) Local search based on mutation strategy

### (4) algorithm implementation

# 2, Demo code

%__________________________________________ % 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) % The Whale Optimization Algorithm function [Leader_score,Leader_pos,Convergence_curve]=WOA(SearchAgents_no,Max_iter,lb,ub,dim,fobj,handles,value) % initialize position vector and score for the leader Leader_pos=zeros(1,dim); Leader_score=inf; %change this to -inf for maximization problems %Initialize the positions of search agents Positions=initialization(SearchAgents_no,dim,ub,lb); Convergence_curve=zeros(1,Max_iter); t=0;% Loop counter % Main loop while t<Max_iter for i=1:size(Positions,1) % Return back the search agents that go beyond the boundaries of the search space Flag4ub=Positions(i,:)>ub; Flag4lb=Positions(i,:)<lb; Positions(i,:)=(Positions(i,:).*(~(Flag4ub+Flag4lb)))+ub.*Flag4ub+lb.*Flag4lb; % Calculate objective function for each search agent fitness=fobj(Positions(i,:)); All_fitness(1,i)=fitness; % Update the leader if fitness<Leader_score % Change this to > for maximization problem Leader_score=fitness; % Update alpha Leader_pos=Positions(i,:); end end a=2-t*((2)/Max_iter); % a decreases linearly fron 2 to 0 in Eq. (2.3) % a2 linearly dicreases from -1 to -2 to calculate t in Eq. (3.12) a2=-1+t*((-1)/Max_iter); % Update the Position of search agents for i=1:size(Positions,1) r1=rand(); % r1 is a random number in [0,1] r2=rand(); % r2 is a random number in [0,1] A=2*a*r1-a; % Eq. (2.3) in the paper C=2*r2; % Eq. (2.4) in the paper b=1; % parameters in Eq. (2.5) l=(a2-1)*rand+1; % parameters in Eq. (2.5) p = rand(); % p in Eq. (2.6) for j=1:size(Positions,2) if p<0.5 if abs(A)>=1 rand_leader_index = floor(SearchAgents_no*rand()+1); X_rand = Positions(rand_leader_index, :); D_X_rand=abs(C*X_rand(j)-Positions(i,j)); % Eq. (2.7) Positions(i,j)=X_rand(j)-A*D_X_rand; % Eq. (2.8) elseif abs(A)<1 D_Leader=abs(C*Leader_pos(j)-Positions(i,j)); % Eq. (2.1) Positions(i,j)=Leader_pos(j)-A*D_Leader; % Eq. (2.2) end elseif p>=0.5 distance2Leader=abs(Leader_pos(j)-Positions(i,j)); % Eq. (2.5) Positions(i,j)=distance2Leader*exp(b.*l).*cos(l.*2*pi)+Leader_pos(j); end end end t=t+1; Convergence_curve(t)=Leader_score; if t>2 line([t-1 t], [Convergence_curve(t-1) Convergence_curve(t)],'Color','b') xlabel('Iteration'); ylabel('Best score obtained so far'); drawnow end set(handles.itertext,'String', ['The current iteration is ', num2str(t)]) set(handles.optimumtext,'String', ['The current optimal value is ', num2str(Leader_score)]) if value==1 hold on scatter(t*ones(1,SearchAgents_no),All_fitness,'.','k') end end

## 4, Simulation results

# 5, References

[1] Ning Jieqiong, he Qing Flower pollination algorithm based on t-distribution perturbation strategy and mutation strategy [J]. Small microcomputer system, 2021, 42 (1): 64-70