First_Implementation_on_Swarm_Algorithms

Author: i2a-k

F1.m

@@ -0,0 +1,6 @@
+%Rastrigin
+function [Out] = F1(X)
+T1 = X.^2;
+T2 = -10*cos(2*pi*X)+10;
+Out = sum(T1+T2,2);
+%D=[-5.12,5.12]

F2.m

@@ -0,0 +1,6 @@
+%Ackley
+function [Out] = F2(X)
+T1 = -20*exp(-0.2*(sqrt(sum(X.^2,2)*1./size(X,2)))); 
+T2 = exp(sum(cos(X*2*pi),2)*1./size(X,2));
+Out = T1-T2+20+exp(1);
+%D=[-32,32]

F3.m

@@ -0,0 +1,6 @@
+%Schwefel 2.26
+function [Out] = F3(X)
+T1 = 418.9829.*size(X,2);
+T2 = sum(X.*sin(sqrt(abs(X))),2);
+Out = T1 - T2;
+%D=[-500,500]

SI_H1_PSO.m

@@ -0,0 +1,184 @@
+clc;
+clear;
+close all;
+
+%Number of Initial Population & Dimensions
+pop_size = 100;
+dim = 2;
+
+%Iteration Condition
+max_iter = 200;
+
+%Mutation Rate
+%m_rate = 0.05;
+
+%Domain of Benchmarks
+from = -5.12;
+to = -1*from;
+
+%Results for n Times Execution
+num_of_result = 5;
+%Columns of total Result : dim,(gbest_fitness),(time)
+total_result = zeros(num_of_result,dim+2);
+
+for n=1:num_of_result
+    tic;
+    
+    %Nfe Condition
+    max_nfe = 20000;
+    
+    %Initialize Best Fitness and Position by a Large Value
+    g_best = zeros(1, dim);
+    g_best(1,:) = to;
+    g_best_fitness = F1(g_best(1,:)); %nfe++
+    nfe = 1;
+    
+    %Initialize Population
+    X = unifrnd(from,to,[pop_size dim]);
+    %Initialize Personal Bests (Equal to First Positions)
+    p_best = X;
+    %Initialize Velocity (Equal to First Position)
+    V = X;
+    %V = zeros(pop_size,dim);
+    
+    F_result = zeros(1, pop_size);
+    
+    %c_max = 2.5;
+    %c_min = 0.5;
+    
+    %Calculate Fitness of X and Save the Best Fitness and its Position
+    for i = 1:pop_size
+        F_result(1,i) = F1(X(i,:));
+        nfe = nfe + 1;
+        if (F_result(1,i) <= g_best_fitness)
+            g_best_fitness = F_result(1,i);
+            g_best(1,:) = X(i,:);
+        end
+    end
+    
+    %Main Loop
+    for m=1:max_iter
+        F1_result = zeros(1, pop_size);
+        r1 = rand;
+        r2 = rand;
+        
+        %Cognitive Coefficient
+        %c1 = (c_min - c_max) * (j/max_iter) + c_max;
+        %Global Coefficient
+        %c2 = (c_max - c_min) * (j/max_iter) + c_max;
+        %Inertia Coefficient for Standard PSO
+        %w = (c1*r1) + (c2*r2);
+        
+        r_w = rand;
+        w0 = 0 + (0.4-0)*rand;
+        alpha0 = 0.5 + (1-0.5)*rand;
+        
+        %Interia Coefficient for AWPSO
+        w = w0 + r_w * (1 - w0);
+        %Acceleration Factor
+        alpha = alpha0 + m/max_iter;
+        
+        %Convex (for Breeding PSO)
+        %lambda1 = rand;
+        %lambda2 = 1 - lambda1;
+        %Average
+        %lambda1 = 0.5;
+        %lambda2 = lambda1;
+        %Affine
+        %lambda1 = 1.5;
+        %lambda2 = -0.5;
+        %Linear
+        %lambda1 = rand;
+        %lambda2 = rand;
+        
+        for j=1:pop_size
+            %Equation of Velocity (Update Velocity of each Particle)
+            %V(j,:) = (w * V(j,:)) + (c1*r1*(p_best(j,:) - X(j,:)))...
+            %    + (c2*r2*(g_best(1,:) - X(j,:) )); %Standard PSO
+            V(j,:) = (w * V(j,:)) + alpha*((r1*(p_best(j,:) - X(j,:)))...
+                + (r2*(g_best(1,:) - X(j,:) ))); %AWPSO
+            
+            %Update Velocity of each Particle for Breeding PSO
+            %for z=1:2:pop_size
+            %    V(z,:) = ((V(z,:) + V(z+1,:))/(norm(V(z,:) + V(z+1,:))))...
+            %        * norm(V(z,:));
+            %end
+            
+            %Control the Domain of the new Velocity
+            for p=i:dim
+                r_v = rand;
+                if (V(j,p) < from)
+                    V(j,p) = from + r_v;
+                elseif (V(j,p) > to)
+                    V(j,p) = to - r_v;
+                end
+            end
+            
+            %Equation of new Position (Update Position of each Particle)
+            X(j,:) = X(j,:) + V(j,:);
+            
+            %Update Position of each Particle for Breeding PSO
+            %for z=1:2:pop_size
+            %    x_temp_a = X(z,:);
+            %    x_temp_b = X(z+1,:);
+            %    X(z,:) = lambda1*(x_temp_a) + lambda2*(x_temp_b);
+            %    X(z+1,:) = lambda1*(x_temp_b) + lambda2*(x_temp_a);
+            %end
+            
+            %Mutation
+            %y = unifrnd(from,to,[floor(m_rate*pop_size) dim]);
+            %for i = 1:size(y,1)
+            %rand_Mutation = randi(pop_size);
+            %X(rand_Mutation,1:dim) = X(rand_Mutation,1:dim) + y(i,:);
+            %end
+            
+            %Control the Domain of the new Positions
+            for t=1:dim
+                r_x = rand;
+                if (X(j,t) < from)
+                    X(j,t) = from + r_x;
+                elseif (X(j,t) > to)
+                    X(j,t) = to - r_x;
+                end
+            end
+        end
+        
+        %Update the Personal Bests and Global Best
+        for k = 1:pop_size
+            
+            if (nfe >= max_nfe)
+                break;
+            end
+            
+            F1_result(1,k) = F1(X(k,:));
+            nfe = nfe + 1;
+            if (F1_result(1,k) <= F1(p_best(k,:)))
+                nfe = nfe +1;
+                p_best(k,:) = X(k,:);
+            end
+            
+            if (F1_result(1,k) <= g_best_fitness)
+                g_best_fitness = F1_result(1,k);
+                nfe = nfe +1;
+                g_best(1,:) = X(k,:);
+            end
+        end
+    end
+    
+    total_result(n,1) = toc;
+    total_result(n,2) = g_best_fitness;
+    total_result(n,3:end) = g_best;
+end
+
+min_fitness = min(total_result(:,2));
+max_fitness = max(total_result(:,2));
+mean_fitness = mean(total_result(:,2));
+std_fitness = std(total_result(:,2));
+mean_time = mean(total_result(:,1));
+
+disp(strcat('Popsize:', num2str(pop_size), ', Dimension:', num2str(dim)));
+disp(strcat('mean fitness: ', num2str(mean_fitness)));
+disp(strcat('max fitness: ', num2str(max_fitness)));
+disp(strcat('min fitness: ', num2str(min_fitness)));
+disp(strcat('std fitness: ', num2str(std_fitness)));
+disp(strcat('mean time: ', num2str(mean_time)));