├── BBBC
    ├── BBBC.m
    ├── fitnessFunc.m
    └── limiter.m
├── BBKH
    ├── BBKH.m
    ├── fitnessFunc.m
    ├── limiter.m
    └── sortPop.m
├── DE
    ├── DE.m
    ├── fitnessFunc.m
    └── limiter.m
├── FA
    ├── FA.m
    ├── alpha_new.m
    ├── fitnessFunc.m
    ├── limiter.m
    └── move.m
├── GA
    ├── GA.m
    ├── crossover.m
    ├── fitnessFunc.m
    ├── limiter.m
    └── mutate.m
├── GWO
    ├── GWO.m
    ├── fitnessFunc.m
    └── limiter.m
├── IWD
    ├── IWD.m
    ├── fitnessFunc.m
    └── limiter.m
├── LICENSE
├── MBO
    ├── MBO.m
    ├── fitnessFunc.m
    └── limiter.m
├── PSO
    ├── PSO.m
    ├── fitnessFunc.m
    └── limiter.m
├── README.md
├── SBO
    ├── Roulette.m
    ├── SBO.m
    ├── fitnessFunc.m
    └── limiter.m
├── SOS
    ├── SOS.m
    ├── fitnessFunc.m
    └── limiter.m
└── WEO
    ├── WEO.m
    ├── calcJ.m
    ├── fitnessFunc.m
    └── limiter.m


/BBBC/BBBC.m:
--------------------------------------------------------------------------------
 1 | %Big Bang Big Crunch Algorithm
 2 | %-----------------------------
 3 | clc
 4 | clear
 5 | close all
 6 | 
 7 | % Problem Statement
 8 | Npar = 3;
 9 | VarLow=[-5.12 -5.12 -5.12];
10 | VarHigh = [5.12 5.12 5.12];
11 | 
12 | %BBBC parameters
13 | N=100;       %number of candidates
14 | MaxIter=100;  %number of iterations
15 | 
16 | % initialize a random value as best value
17 | XBest = rand(1,Npar).* (VarHigh - VarLow) + VarLow;
18 | FBest=fitnessFunc(XBest);
19 | GB=FBest;
20 | t = cputime;
21 | 
22 | %intialize solutions and memory
23 | X = zeros(N, Npar);
24 | F = zeros(N, 1);
25 | 
26 | for ii = 1:N
27 |     X(ii,:) = rand(1,Npar).* (VarHigh - VarLow) + VarLow;
28 |     
29 |     % calculate the fitness of solutions
30 |     F(ii) = fitnessFunc(X(ii,:));
31 | end
32 | 
33 | %Main Loop
34 | for it=1:MaxIter
35 | 
36 |     %Find the centre of mass 
37 |     %-----------------------
38 | 
39 |     %numerator term
40 |     num=zeros(1,Npar);
41 |     for ii=1:N
42 |         for jj=1:Npar
43 |             num(jj)=num(jj)+(X(ii,jj)/F(ii));
44 |         end
45 |     end
46 | 
47 |     %denominator term
48 |     den=sum(1./F);
49 | 
50 |     %centre of mass
51 |     Xc=num/den; 
52 | 
53 |     %generate new solutions
54 |     %----------------------
55 |     for ii=1:N
56 | 
57 |         %new solution from centre of mass
58 |         for jj=1:Npar      
59 |             New=X(ii,:);
60 |             New(jj)=Xc(jj)+((VarHigh(jj)*rand)/it^2);
61 |         end
62 | 
63 |         %boundary constraints
64 |         New=limiter(New,VarHigh,VarLow);
65 |         %new fitness
66 |         newFit=fitnessFunc(New);
67 | 
68 |         %check whether the solution is better than previous solution
69 |         if newFit<F(ii)
70 |             X(ii,:)=New;
71 |             F(ii)=newFit;
72 |             if F(ii)<FBest
73 |                 XBest=X(ii,:);
74 |                 FBest=F(ii);   
75 |             end
76 |         end
77 | 
78 |     end
79 | 
80 |     % store the best value in each iteration
81 |     GB=[GB FBest];
82 | end
83 | 
84 | t1=cputime;
85 | 
86 | fprintf('The time taken is %3.2f seconds \n',t1-t);
87 | fprintf('The best value is :');
88 | XBest
89 | FBest
90 | 
91 | % Convergence Plot
92 | figure(1)
93 | plot(0:MaxIter,GB, 'linewidth',1.2);
94 | title('Convergence');
95 | xlabel('Iterations');
96 | ylabel('Objective Function (Cost)');
97 | grid('on')


--------------------------------------------------------------------------------
/BBBC/fitnessFunc.m:
--------------------------------------------------------------------------------
  1 | function fitness = fitnessFunc(x)
  2 | 
  3 | %Sphere
  4 | % fitness=sum(x(1)^2+x(2)^2+x(3)^2);
  5 | 
  6 | %Booth
  7 | %    fitness=(x(1)+2*x(2)-7)^2 + (2*x(1) + x(2) - 5)^2;
  8 | 
  9 | %Beale's Function
 10 | % fitness=(1.5 -x(1)+x(1)*x(2))^2+(2.25-x(1)+x(1)*x(2)^2)^2+(2.625-x(1)+x(1)*x(2)^3)^2;
 11 | 
 12 | %six hump camel back
 13 | %   fitness=4*x(1)^2 - 2.1*x(1)^4 +(1/3)*x(1)^6 +x(1)*x(2)-4*x(2)^2+4*x(2)^4;
 14 | 
 15 | %Rastrigin
 16 | fitness = x(1)^2 - 10*cos(2*pi*x(1)) + 10;
 17 | fitness= fitness+ x(2)^2 - 10*cos(2*pi*x(2)) + 10;
 18 | fitness= fitness+ x(3)^2 - 10*cos(2*pi*x(3)) + 10;
 19 | 
 20 | %step
 21 | %     fitness=(x(1)+0.5)^2+(x(2)+0.5)^2;
 22 | 
 23 | %Rosenbrock
 24 | %    fitness=100*(x(2)-(x(1)^2))^2+ (x(1)-(x(1)^2))^2;
 25 | 
 26 | %trignometric
 27 | %    fitness=x(1)*sin(4*(x(1)))+1.1*x(2)*sin(2*(x(2)));
 28 | 
 29 | %trignometric 2
 30 | %  fitness=0.5+(sin(sqrtm(x(1)^2+x(2)^2))^2 - 0.5)/(1+0.1*(x(1)^2+x(2)^2));
 31 | 
 32 | %McCormick function
 33 | % fitness=sin(x(1)+x(2))+(x(1)-x(2))^2 -1.5*x(1)+2.5*x(2)+1;
 34 | 
 35 | %Greiwank function
 36 | %  fitness=(1/4000)*((x(1)-100)^2-(cos(x(1)-100)+(x(2)-100)^2-(cos(x(2)-100))));
 37 | 
 38 | %Matyas Function
 39 | % fitness=0.26*(x(1)^2 +x(2)^2)-0.48*x(1)*x(2);
 40 | 
 41 | %Schubert
 42 | %   fitness=((cos(2)+2*cos(3)+3*cos(4)+4*cos(5))*x(1)+1)*((cos(2)+2*cos(3)+3*cos(4)+4*cos(5))*x(2)+1);
 43 | 
 44 | 
 45 | %Quartic
 46 | % fitness=x(1)^4+2*x(2)^4+0.7886*(x(1));
 47 | 
 48 | %Drop wave function
 49 | %   fitness = (-1+cos(12*sqrtm(x(1)^2+x(2)^2)))/(0.5*(x(1)^2+x(2)^2));
 50 | 
 51 | %Cross intray
 52 | % fact1 = sin(x(1))*sin(x(2));
 53 | % fact2 = exp(abs(100 - sqrt(x(1)^2+x(2)^2)/pi));
 54 | % fitness= -0.0001 * (abs(fact1*fact2)+1)^0.1;
 55 | 
 56 | 
 57 | % MICHALEWICZ FUNCTION
 58 | % x(3)=[];
 59 | % d = length(x);
 60 | % sum = 0;
 61 | % for ii = 1:d
 62 | % 	xi = x(ii);
 63 | % 	new = sin(xi) * (sin(ii*xi^2/pi))^(2*10);
 64 | % 	sum  = sum + new;
 65 | % end
 66 | % fitness = -sum;
 67 | 
 68 | %EGGHOLDER FUNCTION
 69 | % x1 = x(1);
 70 | % x2 = x(2);
 71 | % term1 = -(x2+47) * sin(sqrt(abs(x2+x1/2+47)));
 72 | % term2 = -x1 * sin(sqrt(abs(x1-(x2+47))));
 73 | % 
 74 | % fitness = term1 + term2;
 75 | 
 76 | % ACKLEY FUNCTION
 77 | % d = length(x);
 78 | %  a = 20;
 79 | %  b = 0.2;
 80 | %  c = 2*pi;
 81 | % 
 82 | % sum1 = 0;
 83 | % sum2 = 0;
 84 | % for ii = 1:d
 85 | % 	xi = x(ii);
 86 | % 	sum1 = sum1 + xi^2;
 87 | % 	sum2 = sum2 + cos(c*xi);
 88 | % end
 89 | % 
 90 | % term1 = -a * exp(-b*sqrt(sum1/d));
 91 | % term2 = -exp(sum2/d);
 92 | % fitness = term1 + term2 + a + exp(1);
 93 | 
 94 | % SCHWEFEL FUNCTION
 95 | % x(3)=[];
 96 | % d = length(x);
 97 | % sum = 0;
 98 | % for ii = 1:d
 99 | % 	xi = x(ii);
100 | % 	sum = sum + xi*sin(sqrt(abs(xi)));
101 | % end
102 | % fitness = 418.9829*d - sum;
103 | 
104 | % SCHAFFER FUNCTION N. 2
105 | % x1 = x(1);
106 | % x2 = x(2);
107 | % fact1 = (sin(x1^2-x2^2))^2 - 0.5;
108 | % fact2 = (1 + 0.001*(x1^2+x2^2))^2;
109 | % 
110 | % fitness = 0.5 + fact1/fact2;
111 | 
112 | % SCHAFFER FUNCTION N. 4
113 | % x1 = x(1);
114 | % x2 = x(2);
115 | % fact1 = cos((sin(abs(x1^2-x2^2))))^2 - 0.5;
116 | % fact2 = (1 + 0.001*(x1^2+x2^2))^2;
117 | % 
118 | % fitness = 0.5 + fact1/fact2;
119 | 
120 | %EASOM FUNCTION
121 | % fitness=-cos(x(1))*cos(x(2))*exp(-((x(1)-pi)^2+(x(2)-pi)^2));
122 | 
123 | end


--------------------------------------------------------------------------------
/BBBC/limiter.m:
--------------------------------------------------------------------------------
 1 | function newP=limiter(P,VarHigh,VarLow)
 2 | % LIMITER Function to perfrom range limit operation on the solution
 3 | % to be within the search space bounds
 4 | 
 5 | newP=P;
 6 | 
 7 | for i=1:length(P)
 8 |     if newP(i)>VarHigh(i)
 9 |         newP(i)=VarHigh(i);
10 |     elseif newP(i)<VarLow(i)
11 |         newP(i)=VarLow(i);
12 |     end
13 | end
14 |  
15 | 
16 | end


--------------------------------------------------------------------------------
/BBKH/BBKH.m:
--------------------------------------------------------------------------------
  1 | %Bio-geography based Krill Herd Migration 
  2 | %----------------------------------------
  3 | clc
  4 | clear
  5 | close all
  6 | 
  7 | % Problem Statement
  8 | Npar = 3;
  9 | VarLow=[-5.12 -5.12 -5.12];
 10 | VarHigh = [5.12 5.12 5.12];
 11 | 
 12 | % parameters
 13 | NP=100;       %number of krills
 14 | MaxIter=100;  %number of iterations
 15 | Vf=0.2;       %foraging velocity
 16 | Dmax=0.005;   %max diffusion
 17 | Nmax=0.01;   
 18 | pmod=0.5;
 19 | wf = 0.3;     %inertia for foraging
 20 | wn= 0.3;      %inertia for movement
 21 | mu=0.3;
 22 | 
 23 | XBest = [0.5 0.5 0.5];
 24 | XBestFit = fitnessFunc(XBest);
 25 | GB=XBestFit;
 26 | t = cputime;
 27 | 
 28 | %Initialization only for memory allocation
 29 | Krill=repmat(struct('Position',zeros(1,Npar),'Velocity',zeros(1,Npar)),NP,1);
 30 | 
 31 | %Random Population
 32 | for ii = 1:NP
 33 |     Krill(ii).Position = rand(1,Npar).* (VarHigh - VarLow) + VarLow;
 34 |     Krill(ii).N=rand(1,Npar);
 35 |     Krill(ii).F=rand(1,Npar);
 36 |     Krill(ii).Fit = fitnessFunc(Krill(ii).Position);
 37 | end
 38 | 
 39 | %main loop
 40 | for kk = 1:MaxIter
 41 |     
 42 |    %Sorting the population according to their fitness
 43 |    [~,sortind]=sort([Krill.Fit]);
 44 |    Krill = Krill(sortind);
 45 | 
 46 |    %store the best krill
 47 |    if Krill(1).Fit<XBestFit
 48 |       XBest=Krill(1).Position;
 49 |       XBestFit=Krill(1).Fit;
 50 |    end
 51 |   
 52 |    for ii=1:NP
 53 |  
 54 |        %movement
 55 |        Krill(ii).N=Nmax+wn*(Krill(ii).N);
 56 | 
 57 |        %foraging
 58 |        beta=XBest-Krill(ii).Position;
 59 |        Krill(ii).F=Vf*beta+ wf*(Krill(ii).F);
 60 | 
 61 |        %diffusion
 62 |        D=Dmax*rand(1,Npar);
 63 | 
 64 |        %new position
 65 |        Krill(ii).Position=Krill(ii).Position+Krill(ii).N+D+Krill(ii).F;
 66 | 
 67 |        %Krill Migration operator
 68 |        if rand<pmod
 69 |            for jj=1:Npar
 70 |               j=randperm(NP,1);
 71 |               if rand<mu
 72 |                  Krill(ii).Position(jj)=Krill(j).Position(jj);
 73 |               end
 74 |            end
 75 |        end
 76 | 
 77 |        %limit within boundaries
 78 |        Krill(ii).Positon=limiter(Krill(ii).Position,VarLow,VarHigh);
 79 | 
 80 |        %find the fitness value
 81 |        Krill(ii).Fit =fitnessFunc(Krill(ii).Position);
 82 |    end
 83 |    
 84 |    % store the best value in each iteration
 85 |    GB=[GB XBestFit];
 86 | end
 87 | t1=cputime;
 88 | 
 89 | fprintf('The time taken is %3.2f seconds \n',t1-t);
 90 | fprintf('The best value is :');
 91 | XBest
 92 | XBestFit
 93 | 
 94 | % Convergence Plot
 95 | figure(1)
 96 | plot(0:MaxIter,GB, 'linewidth',1.2);
 97 | title('Convergence');
 98 | xlabel('Iterations');
 99 | ylabel('Objective Function (Cost)');
100 | grid('on')
101 | 
102 | 
103 | 


--------------------------------------------------------------------------------
/BBKH/fitnessFunc.m:
--------------------------------------------------------------------------------
  1 | function fitness = fitnessFunc(x)
  2 | 
  3 | %Sphere
  4 | % fitness=sum(x(1)^2+x(2)^2+x(3)^2);
  5 | 
  6 | %Booth
  7 | %    fitness=(x(1)+2*x(2)-7)^2 + (2*x(1) + x(2) - 5)^2;
  8 | 
  9 | %Beale's Function
 10 | % fitness=(1.5 -x(1)+x(1)*x(2))^2+(2.25-x(1)+x(1)*x(2)^2)^2+(2.625-x(1)+x(1)*x(2)^3)^2;
 11 | 
 12 | %six hump camel back
 13 | %   fitness=4*x(1)^2 - 2.1*x(1)^4 +(1/3)*x(1)^6 +x(1)*x(2)-4*x(2)^2+4*x(2)^4;
 14 | 
 15 | %Rastrigin
 16 | fitness = x(1)^2 - 10*cos(2*pi*x(1)) + 10;
 17 | fitness= fitness+ x(2)^2 - 10*cos(2*pi*x(2)) + 10;
 18 | fitness= fitness+ x(3)^2 - 10*cos(2*pi*x(3)) + 10;
 19 | 
 20 | %step
 21 | %     fitness=(x(1)+0.5)^2+(x(2)+0.5)^2;
 22 | 
 23 | %Rosenbrock
 24 | %    fitness=100*(x(2)-(x(1)^2))^2+ (x(1)-(x(1)^2))^2;
 25 | 
 26 | %trignometric
 27 | %    fitness=x(1)*sin(4*(x(1)))+1.1*x(2)*sin(2*(x(2)));
 28 | 
 29 | %trignometric 2
 30 | %  fitness=0.5+(sin(sqrtm(x(1)^2+x(2)^2))^2 - 0.5)/(1+0.1*(x(1)^2+x(2)^2));
 31 | 
 32 | %McCormick function
 33 | % fitness=sin(x(1)+x(2))+(x(1)-x(2))^2 -1.5*x(1)+2.5*x(2)+1;
 34 | 
 35 | %Greiwank function
 36 | %  fitness=(1/4000)*((x(1)-100)^2-(cos(x(1)-100)+(x(2)-100)^2-(cos(x(2)-100))));
 37 | 
 38 | %Matyas Function
 39 | % fitness=0.26*(x(1)^2 +x(2)^2)-0.48*x(1)*x(2);
 40 | 
 41 | %Schubert
 42 | %   fitness=((cos(2)+2*cos(3)+3*cos(4)+4*cos(5))*x(1)+1)*((cos(2)+2*cos(3)+3*cos(4)+4*cos(5))*x(2)+1);
 43 | 
 44 | 
 45 | %Quartic
 46 | % fitness=x(1)^4+2*x(2)^4+0.7886*(x(1));
 47 | 
 48 | %Drop wave function
 49 | %   fitness = (-1+cos(12*sqrtm(x(1)^2+x(2)^2)))/(0.5*(x(1)^2+x(2)^2));
 50 | 
 51 | %Cross intray
 52 | % fact1 = sin(x(1))*sin(x(2));
 53 | % fact2 = exp(abs(100 - sqrt(x(1)^2+x(2)^2)/pi));
 54 | % fitness= -0.0001 * (abs(fact1*fact2)+1)^0.1;
 55 | 
 56 | 
 57 | % MICHALEWICZ FUNCTION
 58 | % x(3)=[];
 59 | % d = length(x);
 60 | % sum = 0;
 61 | % for ii = 1:d
 62 | % 	xi = x(ii);
 63 | % 	new = sin(xi) * (sin(ii*xi^2/pi))^(2*10);
 64 | % 	sum  = sum + new;
 65 | % end
 66 | % fitness = -sum;
 67 | 
 68 | %EGGHOLDER FUNCTION
 69 | % x1 = x(1);
 70 | % x2 = x(2);
 71 | % term1 = -(x2+47) * sin(sqrt(abs(x2+x1/2+47)));
 72 | % term2 = -x1 * sin(sqrt(abs(x1-(x2+47))));
 73 | % 
 74 | % fitness = term1 + term2;
 75 | 
 76 | % ACKLEY FUNCTION
 77 | % d = length(x);
 78 | %  a = 20;
 79 | %  b = 0.2;
 80 | %  c = 2*pi;
 81 | % 
 82 | % sum1 = 0;
 83 | % sum2 = 0;
 84 | % for ii = 1:d
 85 | % 	xi = x(ii);
 86 | % 	sum1 = sum1 + xi^2;
 87 | % 	sum2 = sum2 + cos(c*xi);
 88 | % end
 89 | % 
 90 | % term1 = -a * exp(-b*sqrt(sum1/d));
 91 | % term2 = -exp(sum2/d);
 92 | % fitness = term1 + term2 + a + exp(1);
 93 | 
 94 | % SCHWEFEL FUNCTION
 95 | % x(3)=[];
 96 | % d = length(x);
 97 | % sum = 0;
 98 | % for ii = 1:d
 99 | % 	xi = x(ii);
100 | % 	sum = sum + xi*sin(sqrt(abs(xi)));
101 | % end
102 | % fitness = 418.9829*d - sum;
103 | 
104 | % SCHAFFER FUNCTION N. 2
105 | % x1 = x(1);
106 | % x2 = x(2);
107 | % fact1 = (sin(x1^2-x2^2))^2 - 0.5;
108 | % fact2 = (1 + 0.001*(x1^2+x2^2))^2;
109 | % 
110 | % fitness = 0.5 + fact1/fact2;
111 | 
112 | % SCHAFFER FUNCTION N. 4
113 | % x1 = x(1);
114 | % x2 = x(2);
115 | % fact1 = cos((sin(abs(x1^2-x2^2))))^2 - 0.5;
116 | % fact2 = (1 + 0.001*(x1^2+x2^2))^2;
117 | % 
118 | % fitness = 0.5 + fact1/fact2;
119 | 
120 | %EASOM FUNCTION
121 | % fitness=-cos(x(1))*cos(x(2))*exp(-((x(1)-pi)^2+(x(2)-pi)^2));
122 | 
123 | end


--------------------------------------------------------------------------------
/BBKH/limiter.m:
--------------------------------------------------------------------------------
 1 | function newP=limiter(P,VarHigh,VarLow)
 2 | % LIMITER Function to perfrom range limit operation on the solution
 3 | % to be within the search space bounds
 4 | 
 5 | newP=P;
 6 | 
 7 | for i=1:length(P)
 8 |     if newP(i)>VarHigh(i)
 9 |         newP(i)=VarHigh(i);
10 |     elseif newP(i)<VarLow(i)
11 |         newP(i)=VarLow(i);
12 |     end
13 | end
14 |  
15 | 
16 | end


--------------------------------------------------------------------------------
/BBKH/sortPop.m:
--------------------------------------------------------------------------------
1 | function X=sortPop(X)
2 | % SORTPOP Function to sort the population of Krills
3 | 
4 | [~,sortind]=sort([X.Fit]);
5 | 
6 | X = X(sortind);
7 | 
8 | end


--------------------------------------------------------------------------------
/DE/DE.m:
--------------------------------------------------------------------------------
  1 | %Differential Evolution
  2 | %----------------------
  3 | clc
  4 | clear
  5 | close all
  6 | 
  7 | % Problem Statement
  8 | Npar = 3;  % problem dimension
  9 | VarLow=[-5.12 -5.12 -5.12];
 10 | VarHigh = [5.12 5.12 5.12];
 11 | 
 12 | % parameters
 13 | N=100;                %Number of population members
 14 | MaxIter=100;         %Maximum number of iterations (generations)
 15 | F=0.85;              %DE-scaling factor
 16 | CR = 0.7;            %crossover probability
 17 | Pmu=0.5;             %mutation probability
 18 | 
 19 | %initialize a random value as default best value
 20 | Best=rand(1,Npar).* (VarHigh - VarLow) + VarLow; %default starting point
 21 | bestVal=fitnessFunc(Best);
 22 | GB=bestVal;
 23 | 
 24 | t=cputime;
 25 | 
 26 | %intialize a random population and memory
 27 | pop = zeros(N, Npar);
 28 | fitness = zeros(N, 1);
 29 | 
 30 | for ii=1:N
 31 |     % initialize with a random solution
 32 |     pop(ii, :) = rand(1,Npar) .* (VarHigh - VarLow) + VarLow;
 33 | 
 34 |     % calculate the fitness of the solution
 35 |     fitness(ii) = fitnessFunc(pop(ii,:));
 36 |     
 37 |     % Evaluate the best member
 38 |     if fitness(ii)<bestVal
 39 |         Best=pop(ii,:);
 40 |         bestVal=fitness(ii);
 41 |     end
 42 | end
 43 | 
 44 | rot  = (0:1:N-1);   % rotating index array (size N)
 45 | 
 46 | %Main loop
 47 | for ii=1:MaxIter
 48 |     popold=pop;    %Save the old population
 49 | 
 50 |     ind=randperm(4);          % index pointer array
 51 |     a1  = randperm(N);        % shuffle locations of vectors
 52 |     rt  = rem(rot+ind(1),N);  % rotate indices by ind(1) positions
 53 |     a2  = a1(rt+1);           % rotate vector locations
 54 |     rt  = rem(rot+ind(2),N);
 55 |     a3  = a2(rt+1);                
 56 |     rt  = rem(rot+ind(3),N);
 57 |     a4  = a3(rt+1);               
 58 |     rt  = rem(rot+ind(4),N);
 59 |     a5  = a4(rt+1);                
 60 | 
 61 |     pm1 = popold(a1,:);             % shuffled population 1
 62 |     pm2 = popold(a2,:);             % shuffled population 2
 63 |     pm3 = popold(a3,:);             % shuffled population 3
 64 |     pm4 = popold(a4,:);             % shuffled population 4
 65 |     pm5 = popold(a5,:);             % shuffled population 5
 66 | 
 67 |     for k=1:N                       % population filled with the best member
 68 |         bm(k,:) = Best;                 % of the last iteration
 69 |     end
 70 | 
 71 |     mui = rand(N,Npar) < CR;  % all random numbers < CR are 1, 0 otherwise
 72 |     mpo = mui < Pmu;          % inverse mask to FM_mui
 73 | 
 74 |     ui = popold + F*(bm-popold) + F*(pm1 - pm2); %differntial variation
 75 |     ui = popold.*mpo + ui.*mui;         %crossover
 76 | 
 77 |     %-----parent+child selection-----------------------------------------
 78 |     %-----Select which vectors are allowed to enter the new population-----
 79 | 
 80 |     for k=1:N
 81 |         % limit solutions within the search space
 82 |         ui(k,:)=limiter(ui(k,:),VarHigh,VarLow); 
 83 |         
 84 |         % check cost of competitor
 85 |         tempval=fitnessFunc(ui(k,:));
 86 | 
 87 |         if tempval<fitness(k)   
 88 |             pop(k,:) = ui(k,:);                     
 89 |             fitness(k) = tempval;                   
 90 | 
 91 |             if (tempval<bestVal)  
 92 |                 bestVal = tempval;     % new best value
 93 |                 Best = ui(k,:);        % new best solution
 94 |             end
 95 |         end
 96 |     end
 97 | 
 98 |     % store the best value in each iteration
 99 |     GB=[GB bestVal];
100 | 
101 | end
102 | 
103 | t1=cputime;
104 | 
105 | fprintf('The time taken is %3.2f seconds \n',t1-t);
106 | fprintf('The best value is :');
107 | Best
108 | bestVal
109 | 
110 | % Convergence Plot
111 | figure(1)
112 | plot(0:MaxIter,GB, 'linewidth',1.2);
113 | title('Convergence');
114 | xlabel('Iterations');
115 | ylabel('Objective Function (Cost)');
116 | grid('on')
117 | 


--------------------------------------------------------------------------------
/DE/fitnessFunc.m:
--------------------------------------------------------------------------------
  1 | function fitness = fitnessFunc(x)
  2 | 
  3 | %Sphere
  4 | % fitness=sum(x(1)^2+x(2)^2+x(3)^2);
  5 | 
  6 | %Booth
  7 | %    fitness=(x(1)+2*x(2)-7)^2 + (2*x(1) + x(2) - 5)^2;
  8 | 
  9 | %Beale's Function
 10 | % fitness=(1.5 -x(1)+x(1)*x(2))^2+(2.25-x(1)+x(1)*x(2)^2)^2+(2.625-x(1)+x(1)*x(2)^3)^2;
 11 | 
 12 | %six hump camel back
 13 | %   fitness=4*x(1)^2 - 2.1*x(1)^4 +(1/3)*x(1)^6 +x(1)*x(2)-4*x(2)^2+4*x(2)^4;
 14 | 
 15 | %Rastrigin
 16 | fitness = x(1)^2 - 10*cos(2*pi*x(1)) + 10;
 17 | fitness= fitness+ x(2)^2 - 10*cos(2*pi*x(2)) + 10;
 18 | fitness= fitness+ x(3)^2 - 10*cos(2*pi*x(3)) + 10;
 19 | 
 20 | %step
 21 | %     fitness=(x(1)+0.5)^2+(x(2)+0.5)^2;
 22 | 
 23 | %Rosenbrock
 24 | %    fitness=100*(x(2)-(x(1)^2))^2+ (x(1)-(x(1)^2))^2;
 25 | 
 26 | %trignometric
 27 | %    fitness=x(1)*sin(4*(x(1)))+1.1*x(2)*sin(2*(x(2)));
 28 | 
 29 | %trignometric 2
 30 | %  fitness=0.5+(sin(sqrtm(x(1)^2+x(2)^2))^2 - 0.5)/(1+0.1*(x(1)^2+x(2)^2));
 31 | 
 32 | %McCormick function
 33 | % fitness=sin(x(1)+x(2))+(x(1)-x(2))^2 -1.5*x(1)+2.5*x(2)+1;
 34 | 
 35 | %Greiwank function
 36 | %  fitness=(1/4000)*((x(1)-100)^2-(cos(x(1)-100)+(x(2)-100)^2-(cos(x(2)-100))));
 37 | 
 38 | %Matyas Function
 39 | % fitness=0.26*(x(1)^2 +x(2)^2)-0.48*x(1)*x(2);
 40 | 
 41 | %Schubert
 42 | %   fitness=((cos(2)+2*cos(3)+3*cos(4)+4*cos(5))*x(1)+1)*((cos(2)+2*cos(3)+3*cos(4)+4*cos(5))*x(2)+1);
 43 | 
 44 | 
 45 | %Quartic
 46 | % fitness=x(1)^4+2*x(2)^4+0.7886*(x(1));
 47 | 
 48 | %Drop wave function
 49 | %   fitness = (-1+cos(12*sqrtm(x(1)^2+x(2)^2)))/(0.5*(x(1)^2+x(2)^2));
 50 | 
 51 | %Cross intray
 52 | % fact1 = sin(x(1))*sin(x(2));
 53 | % fact2 = exp(abs(100 - sqrt(x(1)^2+x(2)^2)/pi));
 54 | % fitness= -0.0001 * (abs(fact1*fact2)+1)^0.1;
 55 | 
 56 | 
 57 | % MICHALEWICZ FUNCTION
 58 | % x(3)=[];
 59 | % d = length(x);
 60 | % sum = 0;
 61 | % for ii = 1:d
 62 | % 	xi = x(ii);
 63 | % 	new = sin(xi) * (sin(ii*xi^2/pi))^(2*10);
 64 | % 	sum  = sum + new;
 65 | % end
 66 | % fitness = -sum;
 67 | 
 68 | %EGGHOLDER FUNCTION
 69 | % x1 = x(1);
 70 | % x2 = x(2);
 71 | % term1 = -(x2+47) * sin(sqrt(abs(x2+x1/2+47)));
 72 | % term2 = -x1 * sin(sqrt(abs(x1-(x2+47))));
 73 | % 
 74 | % fitness = term1 + term2;
 75 | 
 76 | % ACKLEY FUNCTION
 77 | % d = length(x);
 78 | %  a = 20;
 79 | %  b = 0.2;
 80 | %  c = 2*pi;
 81 | % 
 82 | % sum1 = 0;
 83 | % sum2 = 0;
 84 | % for ii = 1:d
 85 | % 	xi = x(ii);
 86 | % 	sum1 = sum1 + xi^2;
 87 | % 	sum2 = sum2 + cos(c*xi);
 88 | % end
 89 | % 
 90 | % term1 = -a * exp(-b*sqrt(sum1/d));
 91 | % term2 = -exp(sum2/d);
 92 | % fitness = term1 + term2 + a + exp(1);
 93 | 
 94 | % SCHWEFEL FUNCTION
 95 | % x(3)=[];
 96 | % d = length(x);
 97 | % sum = 0;
 98 | % for ii = 1:d
 99 | % 	xi = x(ii);
100 | % 	sum = sum + xi*sin(sqrt(abs(xi)));
101 | % end
102 | % fitness = 418.9829*d - sum;
103 | 
104 | % SCHAFFER FUNCTION N. 2
105 | % x1 = x(1);
106 | % x2 = x(2);
107 | % fact1 = (sin(x1^2-x2^2))^2 - 0.5;
108 | % fact2 = (1 + 0.001*(x1^2+x2^2))^2;
109 | % 
110 | % fitness = 0.5 + fact1/fact2;
111 | 
112 | % SCHAFFER FUNCTION N. 4
113 | % x1 = x(1);
114 | % x2 = x(2);
115 | % fact1 = cos((sin(abs(x1^2-x2^2))))^2 - 0.5;
116 | % fact2 = (1 + 0.001*(x1^2+x2^2))^2;
117 | % 
118 | % fitness = 0.5 + fact1/fact2;
119 | 
120 | %EASOM FUNCTION
121 | % fitness=-cos(x(1))*cos(x(2))*exp(-((x(1)-pi)^2+(x(2)-pi)^2));
122 | 
123 | end


--------------------------------------------------------------------------------
/DE/limiter.m:
--------------------------------------------------------------------------------
 1 | function newP=limiter(P,VarHigh,VarLow)
 2 | % LIMITER Function to perfrom range limit operation on the solution
 3 | % to be within the search space bounds
 4 | 
 5 | newP=P;
 6 | 
 7 | for i=1:length(P)
 8 |     if newP(i)>VarHigh(i)
 9 |         newP(i)=VarHigh(i);
10 |     elseif newP(i)<VarLow(i)
11 |         newP(i)=VarLow(i);
12 |     end
13 | end
14 |  
15 | 
16 | end


--------------------------------------------------------------------------------
/FA/FA.m:
--------------------------------------------------------------------------------
 1 | %Firefly algorithm
 2 | %-----------------
 3 | clc
 4 | clear
 5 | close all
 6 | warning off
 7 | 
 8 | % Problem Statement
 9 | Npar = 3;            %problem dimension
10 | VarLow=[-5.12 -5.12 -5.12];
11 | VarHigh = [5.12 5.12 5.12];
12 | 
13 | % parameters
14 | n=100;         %number of fireflies
15 | Gen = 100;
16 | alpha=0.3;      % Randomness 0--1 (highly random)
17 | gamma=1.0;      % Absorption coefficient
18 | delta=0.97;      % Randomness reduction (similar to 
19 |                 % an annealing schedule)
20 | betamin=0.2;    %minimum value of beta
21 | 
22 | % initialize a random value as best value
23 | nbest=rand(1,Npar) .* (VarHigh - VarLow) + VarLow;
24 | Lightbest = fitnessFunc(nbest);
25 | GB = Lightbest;
26 | 
27 | t=cputime;
28 | 
29 | % Initialization of fireflies and memory
30 | ns=zeros(n,Npar);
31 | Lightn=zeros(n,1);
32 | for ii = 1:n
33 |     
34 |     ns(ii,:)= rand(1,Npar) .* (VarHigh - VarLow) + VarLow;
35 |     Lightn(ii)= fitnessFunc(ns(ii,:));  
36 |     
37 |     % save the best value
38 |     if (Lightn(ii)<Lightbest)
39 |        nbest=ns(ii,:);
40 |        Lightbest = Lightn(ii);
41 |     end
42 | 
43 | end
44 | 
45 | 
46 | for k=1:Gen
47 |     % Reducing Alpha
48 |     alpha=alpha_new(alpha,Gen);
49 | 
50 |     % Move all fireflies to the better locations
51 |     ns=move(n,ns,Lightn,alpha,betamin,gamma,VarLow,VarHigh);
52 | 
53 |     % limit the solutions within the search space
54 |     for ii=1:n
55 |        ns(ii,:)=limiter(ns(ii,:),VarHigh,VarLow); 
56 |     end
57 |     
58 |     % Evaluate new solutions (for all n fireflies)
59 |     for ii=1:n
60 |        Lightn(ii) = fitnessFunc(ns(ii,:));
61 |        if (Lightn(ii)<Lightbest)
62 |            nbest=ns(ii,:);
63 |            Lightbest=Lightn(ii);
64 |        end
65 |     end
66 |      
67 |     % store the best value in each iteration
68 |     GB = [GB Lightbest];
69 | end   
70 | 
71 | t1=cputime;
72 | 
73 | fprintf('The time taken is %3.2f seconds \n',t1-t);
74 | fprintf('The best value is :');
75 | nbest
76 | Lightbest
77 | 
78 | % Convergence Plot
79 | figure(1)
80 | plot(0:Gen,GB, 'linewidth',1.2);
81 | title('Convergence');
82 | xlabel('Iterations');
83 | ylabel('Objective Function (Cost)');
84 | grid('on')
85 | 
86 | 
87 | 
88 | 
89 | 
90 | 
91 | 
92 | 


--------------------------------------------------------------------------------
/FA/alpha_new.m:
--------------------------------------------------------------------------------
1 | function alpha=alpha_new(alpha,NGen)
2 | % ALPHA_NEW Function to generate new value of alpha
3 | % alpha_n=alpha_0(1-delta)^NGen=10^(-4);
4 | % alpha_0=0.9
5 | 
6 | delta=1-(10^(-4)/0.9)^(1/NGen);
7 | alpha=(1-delta)*alpha;
8 | 
9 | end


--------------------------------------------------------------------------------
/FA/fitnessFunc.m:
--------------------------------------------------------------------------------
  1 | function fitness = fitnessFunc(x)
  2 | 
  3 | %Sphere
  4 | % fitness=sum(x(1)^2+x(2)^2+x(3)^2);
  5 | 
  6 | %Booth
  7 | %    fitness=(x(1)+2*x(2)-7)^2 + (2*x(1) + x(2) - 5)^2;
  8 | 
  9 | %Beale's Function
 10 | % fitness=(1.5 -x(1)+x(1)*x(2))^2+(2.25-x(1)+x(1)*x(2)^2)^2+(2.625-x(1)+x(1)*x(2)^3)^2;
 11 | 
 12 | %six hump camel back
 13 | %   fitness=4*x(1)^2 - 2.1*x(1)^4 +(1/3)*x(1)^6 +x(1)*x(2)-4*x(2)^2+4*x(2)^4;
 14 | 
 15 | %Rastrigin
 16 | fitness = x(1)^2 - 10*cos(2*pi*x(1)) + 10;
 17 | fitness= fitness+ x(2)^2 - 10*cos(2*pi*x(2)) + 10;
 18 | fitness= fitness+ x(3)^2 - 10*cos(2*pi*x(3)) + 10;
 19 | 
 20 | %step
 21 | %     fitness=(x(1)+0.5)^2+(x(2)+0.5)^2;
 22 | 
 23 | %Rosenbrock
 24 | %    fitness=100*(x(2)-(x(1)^2))^2+ (x(1)-(x(1)^2))^2;
 25 | 
 26 | %trignometric
 27 | %    fitness=x(1)*sin(4*(x(1)))+1.1*x(2)*sin(2*(x(2)));
 28 | 
 29 | %trignometric 2
 30 | %  fitness=0.5+(sin(sqrtm(x(1)^2+x(2)^2))^2 - 0.5)/(1+0.1*(x(1)^2+x(2)^2));
 31 | 
 32 | %McCormick function
 33 | % fitness=sin(x(1)+x(2))+(x(1)-x(2))^2 -1.5*x(1)+2.5*x(2)+1;
 34 | 
 35 | %Greiwank function
 36 | %  fitness=(1/4000)*((x(1)-100)^2-(cos(x(1)-100)+(x(2)-100)^2-(cos(x(2)-100))));
 37 | 
 38 | %Matyas Function
 39 | % fitness=0.26*(x(1)^2 +x(2)^2)-0.48*x(1)*x(2);
 40 | 
 41 | %Schubert
 42 | %   fitness=((cos(2)+2*cos(3)+3*cos(4)+4*cos(5))*x(1)+1)*((cos(2)+2*cos(3)+3*cos(4)+4*cos(5))*x(2)+1);
 43 | 
 44 | 
 45 | %Quartic
 46 | % fitness=x(1)^4+2*x(2)^4+0.7886*(x(1));
 47 | 
 48 | %Drop wave function
 49 | %   fitness = (-1+cos(12*sqrtm(x(1)^2+x(2)^2)))/(0.5*(x(1)^2+x(2)^2));
 50 | 
 51 | %Cross intray
 52 | % fact1 = sin(x(1))*sin(x(2));
 53 | % fact2 = exp(abs(100 - sqrt(x(1)^2+x(2)^2)/pi));
 54 | % fitness= -0.0001 * (abs(fact1*fact2)+1)^0.1;
 55 | 
 56 | 
 57 | % MICHALEWICZ FUNCTION
 58 | % x(3)=[];
 59 | % d = length(x);
 60 | % sum = 0;
 61 | % for ii = 1:d
 62 | % 	xi = x(ii);
 63 | % 	new = sin(xi) * (sin(ii*xi^2/pi))^(2*10);
 64 | % 	sum  = sum + new;
 65 | % end
 66 | % fitness = -sum;
 67 | 
 68 | %EGGHOLDER FUNCTION
 69 | % x1 = x(1);
 70 | % x2 = x(2);
 71 | % term1 = -(x2+47) * sin(sqrt(abs(x2+x1/2+47)));
 72 | % term2 = -x1 * sin(sqrt(abs(x1-(x2+47))));
 73 | % 
 74 | % fitness = term1 + term2;
 75 | 
 76 | % ACKLEY FUNCTION
 77 | % d = length(x);
 78 | %  a = 20;
 79 | %  b = 0.2;
 80 | %  c = 2*pi;
 81 | % 
 82 | % sum1 = 0;
 83 | % sum2 = 0;
 84 | % for ii = 1:d
 85 | % 	xi = x(ii);
 86 | % 	sum1 = sum1 + xi^2;
 87 | % 	sum2 = sum2 + cos(c*xi);
 88 | % end
 89 | % 
 90 | % term1 = -a * exp(-b*sqrt(sum1/d));
 91 | % term2 = -exp(sum2/d);
 92 | % fitness = term1 + term2 + a + exp(1);
 93 | 
 94 | % SCHWEFEL FUNCTION
 95 | % x(3)=[];
 96 | % d = length(x);
 97 | % sum = 0;
 98 | % for ii = 1:d
 99 | % 	xi = x(ii);
100 | % 	sum = sum + xi*sin(sqrt(abs(xi)));
101 | % end
102 | % fitness = 418.9829*d - sum;
103 | 
104 | % SCHAFFER FUNCTION N. 2
105 | % x1 = x(1);
106 | % x2 = x(2);
107 | % fact1 = (sin(x1^2-x2^2))^2 - 0.5;
108 | % fact2 = (1 + 0.001*(x1^2+x2^2))^2;
109 | % 
110 | % fitness = 0.5 + fact1/fact2;
111 | 
112 | % SCHAFFER FUNCTION N. 4
113 | % x1 = x(1);
114 | % x2 = x(2);
115 | % fact1 = cos((sin(abs(x1^2-x2^2))))^2 - 0.5;
116 | % fact2 = (1 + 0.001*(x1^2+x2^2))^2;
117 | % 
118 | % fitness = 0.5 + fact1/fact2;
119 | 
120 | %EASOM FUNCTION
121 | % fitness=-cos(x(1))*cos(x(2))*exp(-((x(1)-pi)^2+(x(2)-pi)^2));
122 | 
123 | end


--------------------------------------------------------------------------------
/FA/limiter.m:
--------------------------------------------------------------------------------
 1 | function newP=limiter(P,VarHigh,VarLow)
 2 | % LIMITER Function to perfrom range limit operation on the solution
 3 | % to be within the search space bounds
 4 | 
 5 | newP=P;
 6 | 
 7 | for i=1:length(P)
 8 |     if newP(i)>VarHigh(i)
 9 |         newP(i)=VarHigh(i);
10 |     elseif newP(i)<VarLow(i)
11 |         newP(i)=VarLow(i);
12 |     end
13 | end
14 |  
15 | 
16 | end


--------------------------------------------------------------------------------
/FA/move.m:
--------------------------------------------------------------------------------
 1 | function ns=move(n,ns,Lightn,alpha,betamin,gamma,VarLow,VarHigh)
 2 |   
 3 | % Scaling of the system
 4 | scale=abs(VarHigh-VarLow);
 5 | d=length(VarLow);
 6 | 
 7 | % make a copy of original values
 8 | nso = ns;
 9 | Lighto=Lightn;
10 | 
11 | % Updating fireflies
12 | for i=1:n
13 |     % The attractiveness parameter beta=exp(-gamma*r)
14 |     for j=1:n
15 |         r=sqrt(sum((ns(i,:)-ns(j,:)).^2)); % distance between fireflies
16 |         
17 |         if Lightn(i)>Lighto(j) % Brighter and more attractive
18 |             % Update moves
19 |             beta0=1; 
20 |             beta=(beta0-betamin)*exp(-gamma*r.^2)+betamin;
21 |             tmpf=alpha.*(rand(1,d)-0.5).*scale;
22 |             ns(i,:)=ns(i,:).*(1-beta)+nso(j,:).*beta+tmpf;
23 |         end
24 |     end 
25 | 
26 | end 
27 | 
28 | end
29 | 


--------------------------------------------------------------------------------
/GA/GA.m:
--------------------------------------------------------------------------------
  1 | % Genetic Algorithm
  2 | %------------------
  3 | clc
  4 | clear
  5 | close all
  6 | 
  7 | % Problem Statement
  8 | Npar = 3;
  9 | VarLow=[-5.12 -5.12 -5.12];
 10 | VarHigh = [5.12 5.12 5.12];
 11 | 
 12 | % parameters
 13 | N = 100;          % population size
 14 | G = 100;          % Number of generations
 15 | cx = 0.5;         %Crossover length
 16 | Pmut = 0.12;      %probability of mutation
 17 | res = 3;          %resolution of the problem (10^-res)
 18 | 
 19 | % calculate bias if the lower range is less than 0
 20 | off = zeros(1,Npar);
 21 | for ii = 1:Npar
 22 |     if VarLow(ii) <0
 23 |         off(ii) = 0 - VarLow(ii);
 24 |     end
 25 | end
 26 | 
 27 | % calculate the ideal genome length
 28 | gg = zeros(1,Npar);
 29 | for ii = 1:Npar
 30 |    gg(ii) = length(dec2bin((VarHigh(ii)+off(ii))*(10^res))); 
 31 | end
 32 | genl = max(gg);
 33 | 
 34 | % initialize a random value as best value
 35 | best = rand(1,Npar).* (VarHigh - VarLow) + VarLow;
 36 | bestVal = fitnessFunc(best);
 37 | GB = bestVal;
 38 | t = cputime;
 39 | 
 40 | 
 41 | % Initialization of a random population and memory
 42 | pop = zeros(N, Npar);
 43 | fitness = zeros(N, 1);
 44 | for ii=1:N
 45 |     pop(ii,:) = rand(1,Npar).*(VarHigh - VarLow) + VarLow;
 46 |     
 47 |     % calulate the fitness of the population
 48 |     fitness(ii,:) = fitnessFunc(pop(ii,:));
 49 | end
 50 | 
 51 | %Sorting the population according to their fitness
 52 | [fitness,sortind] = sort(fitness);
 53 | pop = pop(sortind, :);
 54 | 
 55 | %Generations Loop
 56 | for k = 1:G
 57 | 
 58 |     % crossover
 59 |     for i = 1:N
 60 |         if rand>(i/N)  % higher fitness get better chance to mate
 61 |             j = randperm(N,1);  % choose a random member
 62 | 
 63 |             % perfrom crossover
 64 |             offspring = crossover(pop(i,:),pop(j,:),genl,cx,res,off);
 65 | 
 66 |             % limit the range within constraints
 67 |             offspring = limiter(offspring,VarHigh,VarLow);
 68 | 
 69 |             % calculate the fitness
 70 |             fitnessoff = fitnessFunc(offspring);
 71 | 
 72 |             % add the offspring to the population
 73 |             pop=cat(1,pop,offspring);
 74 |             fitness=cat(1,fitness,fitnessoff);
 75 |         end
 76 |     end
 77 | 
 78 |     % Mutation
 79 |     for i = 1:N
 80 |         if rand<Pmut         
 81 |             % perfrom mutation
 82 |             mutant = mutate(pop(i,:),genl,res,off);
 83 | 
 84 |             % limit the range within constraints
 85 |             mutant = limiter(mutant,VarHigh,VarLow);
 86 | 
 87 |             % calculate the fitness
 88 |             fitnessoff = fitnessFunc(mutant);
 89 | 
 90 |             % add the offspring to the population
 91 |             pop=cat(1,pop,mutant);
 92 |             fitness=cat(1,fitness,fitnessoff);
 93 |         end
 94 |     end 
 95 | 
 96 |     % Elimination
 97 |     %Sorting the population according to their fitness
 98 |     [fitness,sortind] = sort(fitness);
 99 |     pop = pop(sortind, :);
100 | 
101 |     % remove weaker populations
102 |     pop = pop(1:N, :);
103 |     fitness = fitness(1:N);
104 | 
105 |     % Storing best solution
106 |     bestVal = fitness(1);
107 |     best = pop(1,:);
108 | 
109 |     % store the best value in each iteration
110 |     GB = [GB bestVal];
111 |    
112 | end
113 | 
114 | t1=cputime;
115 | 
116 | fprintf('The time taken is %3.2f seconds \n',t1-t);
117 | fprintf('The best value is :');
118 | best
119 | bestVal
120 | 
121 | % Convergence Plot
122 | figure(1)
123 | plot(0:G,GB, 'linewidth',1.2);
124 | title('Convergence');
125 | xlabel('Iterations');
126 | ylabel('Objective Function (Cost)');
127 | grid('on')
128 | 


--------------------------------------------------------------------------------
/GA/crossover.m:
--------------------------------------------------------------------------------
 1 | function offspring=crossover(male,female,genl,cx,res,off)
 2 | % CROSSOVER function to perform crossover of parent genomes to 
 3 | % produce offspring
 4 | 
 5 | % get the crossover bit length
 6 | cx=cx*genl;
 7 | cx=round(cx);
 8 | 
 9 | % convert male to binary
10 | maleb=(male+off)*(10^res);
11 | malestr=dec2bin(maleb,genl);
12 | 
13 | % convert female to binary
14 | femaleb=(female+off)*100;
15 | femalestr=dec2bin(femaleb,genl);
16 | 
17 | % perfrom crossover
18 |  for k=1:1:(genl-cx)
19 |    offspringstr(:,k)=malestr(:,k); 
20 |  end
21 |  
22 |  for k=genl:-1:genl-(cx-1)
23 |     offspringstr(:,k)=femalestr(:,k);
24 |  end
25 |  
26 | % convert back to decimal and then to float
27 | offspring=bin2dec(offspringstr)';
28 | offspring=((offspring/10^res) - off);
29 | 
30 | end


--------------------------------------------------------------------------------
/GA/fitnessFunc.m:
--------------------------------------------------------------------------------
  1 | function fitness = fitnessFunc(x)
  2 | 
  3 | %Sphere
  4 | % fitness=sum(x(1)^2+x(2)^2+x(3)^2);
  5 | 
  6 | %Booth
  7 | %    fitness=(x(1)+2*x(2)-7)^2 + (2*x(1) + x(2) - 5)^2;
  8 | 
  9 | %Beale's Function
 10 | % fitness=(1.5 -x(1)+x(1)*x(2))^2+(2.25-x(1)+x(1)*x(2)^2)^2+(2.625-x(1)+x(1)*x(2)^3)^2;
 11 | 
 12 | %six hump camel back
 13 | %   fitness=4*x(1)^2 - 2.1*x(1)^4 +(1/3)*x(1)^6 +x(1)*x(2)-4*x(2)^2+4*x(2)^4;
 14 | 
 15 | %Rastrigin
 16 | fitness = x(1)^2 - 10*cos(2*pi*x(1)) + 10;
 17 | fitness= fitness+ x(2)^2 - 10*cos(2*pi*x(2)) + 10;
 18 | fitness= fitness+ x(3)^2 - 10*cos(2*pi*x(3)) + 10;
 19 | 
 20 | %step
 21 | %     fitness=(x(1)+0.5)^2+(x(2)+0.5)^2;
 22 | 
 23 | %Rosenbrock
 24 | %    fitness=100*(x(2)-(x(1)^2))^2+ (x(1)-(x(1)^2))^2;
 25 | 
 26 | %trignometric
 27 | %    fitness=x(1)*sin(4*(x(1)))+1.1*x(2)*sin(2*(x(2)));
 28 | 
 29 | %trignometric 2
 30 | %  fitness=0.5+(sin(sqrtm(x(1)^2+x(2)^2))^2 - 0.5)/(1+0.1*(x(1)^2+x(2)^2));
 31 | 
 32 | %McCormick function
 33 | % fitness=sin(x(1)+x(2))+(x(1)-x(2))^2 -1.5*x(1)+2.5*x(2)+1;
 34 | 
 35 | %Greiwank function
 36 | %  fitness=(1/4000)*((x(1)-100)^2-(cos(x(1)-100)+(x(2)-100)^2-(cos(x(2)-100))));
 37 | 
 38 | %Matyas Function
 39 | % fitness=0.26*(x(1)^2 +x(2)^2)-0.48*x(1)*x(2);
 40 | 
 41 | %Schubert
 42 | %   fitness=((cos(2)+2*cos(3)+3*cos(4)+4*cos(5))*x(1)+1)*((cos(2)+2*cos(3)+3*cos(4)+4*cos(5))*x(2)+1);
 43 | 
 44 | 
 45 | %Quartic
 46 | % fitness=x(1)^4+2*x(2)^4+0.7886*(x(1));
 47 | 
 48 | %Drop wave function
 49 | %   fitness = (-1+cos(12*sqrtm(x(1)^2+x(2)^2)))/(0.5*(x(1)^2+x(2)^2));
 50 | 
 51 | %Cross intray
 52 | % fact1 = sin(x(1))*sin(x(2));
 53 | % fact2 = exp(abs(100 - sqrt(x(1)^2+x(2)^2)/pi));
 54 | % fitness= -0.0001 * (abs(fact1*fact2)+1)^0.1;
 55 | 
 56 | 
 57 | % MICHALEWICZ FUNCTION
 58 | % x(3)=[];
 59 | % d = length(x);
 60 | % sum = 0;
 61 | % for ii = 1:d
 62 | % 	xi = x(ii);
 63 | % 	new = sin(xi) * (sin(ii*xi^2/pi))^(2*10);
 64 | % 	sum  = sum + new;
 65 | % end
 66 | % fitness = -sum;
 67 | 
 68 | %EGGHOLDER FUNCTION
 69 | % x1 = x(1);
 70 | % x2 = x(2);
 71 | % term1 = -(x2+47) * sin(sqrt(abs(x2+x1/2+47)));
 72 | % term2 = -x1 * sin(sqrt(abs(x1-(x2+47))));
 73 | % 
 74 | % fitness = term1 + term2;
 75 | 
 76 | % ACKLEY FUNCTION
 77 | % d = length(x);
 78 | %  a = 20;
 79 | %  b = 0.2;
 80 | %  c = 2*pi;
 81 | % 
 82 | % sum1 = 0;
 83 | % sum2 = 0;
 84 | % for ii = 1:d
 85 | % 	xi = x(ii);
 86 | % 	sum1 = sum1 + xi^2;
 87 | % 	sum2 = sum2 + cos(c*xi);
 88 | % end
 89 | % 
 90 | % term1 = -a * exp(-b*sqrt(sum1/d));
 91 | % term2 = -exp(sum2/d);
 92 | % fitness = term1 + term2 + a + exp(1);
 93 | 
 94 | % SCHWEFEL FUNCTION
 95 | % x(3)=[];
 96 | % d = length(x);
 97 | % sum = 0;
 98 | % for ii = 1:d
 99 | % 	xi = x(ii);
100 | % 	sum = sum + xi*sin(sqrt(abs(xi)));
101 | % end
102 | % fitness = 418.9829*d - sum;
103 | 
104 | % SCHAFFER FUNCTION N. 2
105 | % x1 = x(1);
106 | % x2 = x(2);
107 | % fact1 = (sin(x1^2-x2^2))^2 - 0.5;
108 | % fact2 = (1 + 0.001*(x1^2+x2^2))^2;
109 | % 
110 | % fitness = 0.5 + fact1/fact2;
111 | 
112 | % SCHAFFER FUNCTION N. 4
113 | % x1 = x(1);
114 | % x2 = x(2);
115 | % fact1 = cos((sin(abs(x1^2-x2^2))))^2 - 0.5;
116 | % fact2 = (1 + 0.001*(x1^2+x2^2))^2;
117 | % 
118 | % fitness = 0.5 + fact1/fact2;
119 | 
120 | %EASOM FUNCTION
121 | % fitness=-cos(x(1))*cos(x(2))*exp(-((x(1)-pi)^2+(x(2)-pi)^2));
122 | 
123 | end


--------------------------------------------------------------------------------
/GA/limiter.m:
--------------------------------------------------------------------------------
 1 | function newP=limiter(P,VarHigh,VarLow)
 2 | % LIMITER Function to perfrom range limit operation on the solution
 3 | % to be within the search space bounds
 4 | 
 5 | newP=P;
 6 | 
 7 | for i=1:length(P)
 8 |     if newP(i)>VarHigh(i)
 9 |         newP(i)=VarHigh(i);
10 |     elseif newP(i)<VarLow(i)
11 |         newP(i)=VarLow(i);
12 |     end
13 | end
14 |  
15 | 
16 | end


--------------------------------------------------------------------------------
/GA/mutate.m:
--------------------------------------------------------------------------------
 1 | function mutant=mutate(pop,genl,res,off)
 2 | % MUTATION function to performs the process of a 
 3 | % randomized mutation
 4 | 
 5 | % perfom bias and resolution change
 6 | pop=(pop+off)*(10^res);
 7 | 
 8 | % convert to binary
 9 | pop=dec2bin(pop,genl);
10 | 
11 | % get a random bit to mutate
12 | mutbit=randperm(genl, 1);
13 | 
14 | if pop(:,mutbit)=='1'
15 |    pop(:,mutbit)='0';
16 | else
17 |     pop(:,mutbit)='1';
18 | end
19 | 
20 | % convert back to decimal
21 | pop=bin2dec(pop)';
22 | 
23 | % convertion back to floating point
24 | mutant=((pop/10^res) - off);
25 | 
26 | end


--------------------------------------------------------------------------------
/GWO/GWO.m:
--------------------------------------------------------------------------------
  1 | %Grey Wolf Optimization
  2 | % ---------------------
  3 | clc
  4 | clear
  5 | close all
  6 | 
  7 | % Problem Statement
  8 | Npar = 3;
  9 | VarLow=[-5.12 -5.12 -5.12];
 10 | VarHigh = [5.12 5.12 5.12];
 11 | 
 12 | % parameters
 13 | WolfSize = 100;
 14 | MaxIter = 100;
 15 | 
 16 | % initialize a random value as best value
 17 | alpha.Position=rand(1,Npar).* (VarHigh - VarLow) + VarLow;
 18 | alpha.Fit = fitnessFunc(alpha.Position);
 19 | GB=alpha.Fit;
 20 | 
 21 | t=cputime;
 22 | 
 23 | % Initialization of memory
 24 | X = repmat(struct('Position',zeros(1,Npar),'Fit',zeros(1,Npar)),WolfSize,1);
 25 | X(1) = alpha; % first wolf is alpha
 26 | 
 27 | for ii = 2:WolfSize
 28 |     %initial position of wolves
 29 |     X(ii).Position= rand(1,Npar).* (VarHigh - VarLow) + VarLow;
 30 |     
 31 |     % fitness of the solutions
 32 |     X(ii).Fit=fitnessFunc(X(ii).Position);
 33 |     
 34 |     % evaluate alpha
 35 |     if (X(ii).Fit < alpha.Fit)
 36 |         alpha.Position = X(ii).Position;
 37 |         alpha.Fit = X(ii).Fit;
 38 |     end
 39 | end
 40 | % sort wolves according to fitness
 41 | [~, sortind] = sort([X.Fit]);
 42 | X = X(sortind);
 43 | 
 44 | %initialize alpha beta and delta
 45 | alpha = X(1);
 46 | Beta = X(2);
 47 | delta = X(3);
 48 | 
 49 | %initialize A and C vectors
 50 | a=2*ones(1,Npar);
 51 | A1=2*rand(1,Npar).*a -a;
 52 | A2=2*rand(1,Npar).*a -a;
 53 | A3=2*rand(1,Npar).*a -a;
 54 | C1=2*rand(1,Npar);
 55 | C2=2*rand(1,Npar);
 56 | C3=2*rand(1,Npar);
 57 | 
 58 | % Main Loop
 59 | for jj = 1:MaxIter
 60 |     for ii = 1:WolfSize
 61 |         
 62 |         %compute encircling vectors
 63 |         Da=abs(C1.*alpha.Position-X(ii).Position);
 64 |         Db=abs(C2.*Beta.Position-X(ii).Position);
 65 |         Dd=abs(C3.*delta.Position-X(ii).Position);
 66 |         
 67 |         %update wolf position
 68 |         X1=alpha.Position - A1.*Da;
 69 |         X2=Beta.Position - A2.*Db;
 70 |         X3=delta.Position - A3.*Dd;
 71 |         X(ii).Position = (X1 + X2 + X3)/3;
 72 |         
 73 |         %maintian constraints
 74 |         X(ii).Position=limiter(X(ii).Position,VarHigh,VarLow);
 75 |         
 76 |         %update fitness
 77 |         X(ii).Fit=fitnessFunc(X(ii).Position);
 78 |         
 79 |         % update alpha if better
 80 |         if X(ii).Fit < alpha.Fit
 81 |             alpha = X(ii);
 82 |         end
 83 |     end
 84 |        
 85 |     % sort wolves according to fitness
 86 |     [~, sortind] = sort([X.Fit]);
 87 |     X = X(sortind);
 88 |     
 89 |     %update beta and delta
 90 |     Beta = X(2);
 91 |     delta = X(3);
 92 |     
 93 |     %update A and C vectors
 94 |     a=2*(1-jj/MaxIter);
 95 |     A1=2*rand(1,Npar).*a -a;
 96 |     A2=2*rand(1,Npar).*a -a;
 97 |     A3=2*rand(1,Npar).*a -a;
 98 |     C1=2*rand(1,Npar);
 99 |     C2=2*rand(1,Npar);
100 |     C3=2*rand(1,Npar);
101 |     
102 |     % store the best value in each iteration
103 |     GB = [GB alpha.Fit];
104 | end
105 | 
106 | t1=cputime;
107 | 
108 | fprintf('The time taken is %3.2f seconds \n',t1-t);
109 | fprintf('The best value is :');
110 | alpha.Position
111 | alpha.Fit
112 | 
113 | % Convergence Plot
114 | figure(1)
115 | plot(0:MaxIter,GB, 'linewidth',1.2);
116 | title('Convergence');
117 | xlabel('Iterations');
118 | ylabel('Objective Function (Cost)');
119 | grid('on')
120 | 
121 | 
122 | 


--------------------------------------------------------------------------------
/GWO/fitnessFunc.m:
--------------------------------------------------------------------------------
  1 | function fitness = fitnessFunc(x)
  2 | 
  3 | %Sphere
  4 | % fitness=sum(x(1)^2+x(2)^2+x(3)^2);
  5 | 
  6 | %Booth
  7 | %    fitness=(x(1)+2*x(2)-7)^2 + (2*x(1) + x(2) - 5)^2;
  8 | 
  9 | %Beale's Function
 10 | % fitness=(1.5 -x(1)+x(1)*x(2))^2+(2.25-x(1)+x(1)*x(2)^2)^2+(2.625-x(1)+x(1)*x(2)^3)^2;
 11 | 
 12 | %six hump camel back
 13 | %   fitness=4*x(1)^2 - 2.1*x(1)^4 +(1/3)*x(1)^6 +x(1)*x(2)-4*x(2)^2+4*x(2)^4;
 14 | 
 15 | %Rastrigin
 16 | fitness = x(1)^2 - 10*cos(2*pi*x(1)) + 10;
 17 | fitness= fitness+ x(2)^2 - 10*cos(2*pi*x(2)) + 10;
 18 | fitness= fitness+ x(3)^2 - 10*cos(2*pi*x(3)) + 10;
 19 | 
 20 | %step
 21 | %     fitness=(x(1)+0.5)^2+(x(2)+0.5)^2;
 22 | 
 23 | %Rosenbrock
 24 | %    fitness=100*(x(2)-(x(1)^2))^2+ (x(1)-(x(1)^2))^2;
 25 | 
 26 | %trignometric
 27 | %    fitness=x(1)*sin(4*(x(1)))+1.1*x(2)*sin(2*(x(2)));
 28 | 
 29 | %trignometric 2
 30 | %  fitness=0.5+(sin(sqrtm(x(1)^2+x(2)^2))^2 - 0.5)/(1+0.1*(x(1)^2+x(2)^2));
 31 | 
 32 | %McCormick function
 33 | % fitness=sin(x(1)+x(2))+(x(1)-x(2))^2 -1.5*x(1)+2.5*x(2)+1;
 34 | 
 35 | %Greiwank function
 36 | %  fitness=(1/4000)*((x(1)-100)^2-(cos(x(1)-100)+(x(2)-100)^2-(cos(x(2)-100))));
 37 | 
 38 | %Matyas Function
 39 | % fitness=0.26*(x(1)^2 +x(2)^2)-0.48*x(1)*x(2);
 40 | 
 41 | %Schubert
 42 | %   fitness=((cos(2)+2*cos(3)+3*cos(4)+4*cos(5))*x(1)+1)*((cos(2)+2*cos(3)+3*cos(4)+4*cos(5))*x(2)+1);
 43 | 
 44 | 
 45 | %Quartic
 46 | % fitness=x(1)^4+2*x(2)^4+0.7886*(x(1));
 47 | 
 48 | %Drop wave function
 49 | %   fitness = (-1+cos(12*sqrtm(x(1)^2+x(2)^2)))/(0.5*(x(1)^2+x(2)^2));
 50 | 
 51 | %Cross intray
 52 | % fact1 = sin(x(1))*sin(x(2));
 53 | % fact2 = exp(abs(100 - sqrt(x(1)^2+x(2)^2)/pi));
 54 | % fitness= -0.0001 * (abs(fact1*fact2)+1)^0.1;
 55 | 
 56 | 
 57 | % MICHALEWICZ FUNCTION
 58 | % x(3)=[];
 59 | % d = length(x);
 60 | % sum = 0;
 61 | % for ii = 1:d
 62 | % 	xi = x(ii);
 63 | % 	new = sin(xi) * (sin(ii*xi^2/pi))^(2*10);
 64 | % 	sum  = sum + new;
 65 | % end
 66 | % fitness = -sum;
 67 | 
 68 | %EGGHOLDER FUNCTION
 69 | % x1 = x(1);
 70 | % x2 = x(2);
 71 | % term1 = -(x2+47) * sin(sqrt(abs(x2+x1/2+47)));
 72 | % term2 = -x1 * sin(sqrt(abs(x1-(x2+47))));
 73 | % 
 74 | % fitness = term1 + term2;
 75 | 
 76 | % ACKLEY FUNCTION
 77 | % d = length(x);
 78 | %  a = 20;
 79 | %  b = 0.2;
 80 | %  c = 2*pi;
 81 | % 
 82 | % sum1 = 0;
 83 | % sum2 = 0;
 84 | % for ii = 1:d
 85 | % 	xi = x(ii);
 86 | % 	sum1 = sum1 + xi^2;
 87 | % 	sum2 = sum2 + cos(c*xi);
 88 | % end
 89 | % 
 90 | % term1 = -a * exp(-b*sqrt(sum1/d));
 91 | % term2 = -exp(sum2/d);
 92 | % fitness = term1 + term2 + a + exp(1);
 93 | 
 94 | % SCHWEFEL FUNCTION
 95 | % x(3)=[];
 96 | % d = length(x);
 97 | % sum = 0;
 98 | % for ii = 1:d
 99 | % 	xi = x(ii);
100 | % 	sum = sum + xi*sin(sqrt(abs(xi)));
101 | % end
102 | % fitness = 418.9829*d - sum;
103 | 
104 | % SCHAFFER FUNCTION N. 2
105 | % x1 = x(1);
106 | % x2 = x(2);
107 | % fact1 = (sin(x1^2-x2^2))^2 - 0.5;
108 | % fact2 = (1 + 0.001*(x1^2+x2^2))^2;
109 | % 
110 | % fitness = 0.5 + fact1/fact2;
111 | 
112 | % SCHAFFER FUNCTION N. 4
113 | % x1 = x(1);
114 | % x2 = x(2);
115 | % fact1 = cos((sin(abs(x1^2-x2^2))))^2 - 0.5;
116 | % fact2 = (1 + 0.001*(x1^2+x2^2))^2;
117 | % 
118 | % fitness = 0.5 + fact1/fact2;
119 | 
120 | %EASOM FUNCTION
121 | % fitness=-cos(x(1))*cos(x(2))*exp(-((x(1)-pi)^2+(x(2)-pi)^2));
122 | 
123 | end


--------------------------------------------------------------------------------
/GWO/limiter.m:
--------------------------------------------------------------------------------
 1 | function newP=limiter(P,VarHigh,VarLow)
 2 | % LIMITER Function to perfrom range limit operation on the solution
 3 | % to be within the search space bounds
 4 | 
 5 | newP=P;
 6 | 
 7 | for i=1:length(P)
 8 |     if newP(i)>VarHigh(i)
 9 |         newP(i)=VarHigh(i);
10 |     elseif newP(i)<VarLow(i)
11 |         newP(i)=VarLow(i);
12 |     end
13 | end
14 |  
15 | 
16 | end


--------------------------------------------------------------------------------
/IWD/IWD.m:
--------------------------------------------------------------------------------
  1 | % Intelligent Water Drops
  2 | %------------------------
  3 | clc
  4 | clear
  5 | close all
  6 | 
  7 | % Problem Statement
  8 | Npar = 3;
  9 | VarLow=[-5.12 -5.12 -5.12];
 10 | VarHigh = [5.12 5.12 5.12];
 11 | 
 12 | % parameters
 13 | N=100;        %number of candidates
 14 | MaxIter=100;  %number of iterations
 15 | av=1;
 16 | bv=0.01;
 17 | cv=1;
 18 | as=1;
 19 | bs=0.02;
 20 | cs=1;
 21 | 
 22 | % initialize a random value as best value
 23 | SBest = rand(1,Npar).* (VarHigh - VarLow) + VarLow;
 24 | TB=fitnessFunc(SBest);
 25 | GB=TB;
 26 | t = cputime;
 27 | 
 28 | %random initialization of water drops and memory
 29 | soil = zeros(N, Npar);
 30 | gsoil = zeros(N, Npar);
 31 | fsoil = zeros(N, Npar);
 32 | 
 33 | F = zeros(N, 1);
 34 | for ii = 1:N
 35 |     soil(ii,:) = rand(1,Npar).* (VarHigh - VarLow) + VarLow;
 36 |     
 37 |     % calculate the fitness
 38 |     F(ii) = fitnessFunc(soil(ii,:));
 39 | end
 40 | 
 41 | %Main loop
 42 | for it=1:MaxIter
 43 |     for ii=1:N
 44 |         
 45 |       %calculate gsoil
 46 |       for j=1:Npar
 47 |        if min(soil(:,j))>0
 48 |           gsoil(ii,j)=soil(ii,j)-min(soil(:,j));
 49 |        else
 50 |           gsoil(ii,j)=soil(ii,j);
 51 |        end
 52 |       end 
 53 |       
 54 |       %calculate fsoil
 55 |       es=0.001;
 56 |       for j=1:Npar
 57 |          fsoil(ii,j)=1/(es + gsoil(ii,j));
 58 |       end
 59 |       
 60 |       %calculate probability
 61 |       for j=1:Npar
 62 |          p(j)=fsoil(ii,j)/sum(fsoil(ii,:)); 
 63 |       end
 64 |       
 65 |       %calculate Velocity
 66 |       for j=1:Npar
 67 |         Viwd(j)=av/(bv +cv +(soil(ii,j))^2); 
 68 |       end
 69 |       
 70 |       HUD=abs(mean(soil)-soil(ii,:));
 71 |       
 72 |       time=HUD./Viwd;
 73 |       
 74 |       %calculate delsoil
 75 |       delsoil=as./(bs+(cs*time));
 76 |       
 77 |       %update the soil postion
 78 |       soil(ii,:)=soil(ii,:) + delsoil;
 79 |       
 80 |       %check constraints
 81 |       soil(ii,:)=limiter(soil(ii,:),VarHigh,VarLow);
 82 |       
 83 |       %find fitness
 84 |       F(ii)=fitnessFunc(soil(ii,:));
 85 |       
 86 |       %check for optimality
 87 |       if F(ii)<TB
 88 |          TB=F(ii);
 89 |          SBest=soil(ii,:);
 90 |       end
 91 |       
 92 |     end
 93 |     
 94 |     % store the best value in each iteration
 95 |     GB=[GB TB];
 96 | end
 97 | 
 98 | t1=cputime;
 99 | 
100 | fprintf('The time taken is %3.2f seconds \n',t1-t);
101 | fprintf('The best value is :');
102 | SBest
103 | TB
104 | 
105 | % Convergence Plot
106 | figure(1)
107 | plot(0:MaxIter,GB, 'linewidth',1.2);
108 | title('Convergence');
109 | xlabel('Iterations');
110 | ylabel('Objective Function (Cost)');
111 | grid('on')
112 | 
113 | 
114 | 


--------------------------------------------------------------------------------
/IWD/fitnessFunc.m:
--------------------------------------------------------------------------------
  1 | function fitness = fitnessFunc(x)
  2 | 
  3 | %Sphere
  4 | fitness=sum(x(1)^2+x(2)^2+x(3)^2);
  5 | 
  6 | %Booth
  7 | %    fitness=(x(1)+2*x(2)-7)^2 + (2*x(1) + x(2) - 5)^2;
  8 | 
  9 | %Beale's Function
 10 | % fitness=(1.5 -x(1)+x(1)*x(2))^2+(2.25-x(1)+x(1)*x(2)^2)^2+(2.625-x(1)+x(1)*x(2)^3)^2;
 11 | 
 12 | %six hump camel back
 13 | %   fitness=4*x(1)^2 - 2.1*x(1)^4 +(1/3)*x(1)^6 +x(1)*x(2)-4*x(2)^2+4*x(2)^4;
 14 | 
 15 | %Rastrigin
 16 | % fitness = x(1)^2 - 10*cos(2*pi*x(1)) + 10;
 17 | % fitness= fitness+ x(2)^2 - 10*cos(2*pi*x(2)) + 10;
 18 | % fitness= fitness+ x(3)^2 - 10*cos(2*pi*x(3)) + 10;
 19 | 
 20 | %step
 21 | %     fitness=(x(1)+0.5)^2+(x(2)+0.5)^2;
 22 | 
 23 | %Rosenbrock
 24 | %    fitness=100*(x(2)-(x(1)^2))^2+ (x(1)-(x(1)^2))^2;
 25 | 
 26 | %trignometric
 27 | %    fitness=x(1)*sin(4*(x(1)))+1.1*x(2)*sin(2*(x(2)));
 28 | 
 29 | %trignometric 2
 30 | %  fitness=0.5+(sin(sqrtm(x(1)^2+x(2)^2))^2 - 0.5)/(1+0.1*(x(1)^2+x(2)^2));
 31 | 
 32 | %McCormick function
 33 | % fitness=sin(x(1)+x(2))+(x(1)-x(2))^2 -1.5*x(1)+2.5*x(2)+1;
 34 | 
 35 | %Greiwank function
 36 | %  fitness=(1/4000)*((x(1)-100)^2-(cos(x(1)-100)+(x(2)-100)^2-(cos(x(2)-100))));
 37 | 
 38 | %Matyas Function
 39 | % fitness=0.26*(x(1)^2 +x(2)^2)-0.48*x(1)*x(2);
 40 | 
 41 | %Schubert
 42 | %   fitness=((cos(2)+2*cos(3)+3*cos(4)+4*cos(5))*x(1)+1)*((cos(2)+2*cos(3)+3*cos(4)+4*cos(5))*x(2)+1);
 43 | 
 44 | 
 45 | %Quartic
 46 | % fitness=x(1)^4+2*x(2)^4+0.7886*(x(1));
 47 | 
 48 | %Drop wave function
 49 | %   fitness = (-1+cos(12*sqrtm(x(1)^2+x(2)^2)))/(0.5*(x(1)^2+x(2)^2));
 50 | 
 51 | %Cross intray
 52 | % fact1 = sin(x(1))*sin(x(2));
 53 | % fact2 = exp(abs(100 - sqrt(x(1)^2+x(2)^2)/pi));
 54 | % fitness= -0.0001 * (abs(fact1*fact2)+1)^0.1;
 55 | 
 56 | 
 57 | % MICHALEWICZ FUNCTION
 58 | % x(3)=[];
 59 | % d = length(x);
 60 | % sum = 0;
 61 | % for ii = 1:d
 62 | % 	xi = x(ii);
 63 | % 	new = sin(xi) * (sin(ii*xi^2/pi))^(2*10);
 64 | % 	sum  = sum + new;
 65 | % end
 66 | % fitness = -sum;
 67 | 
 68 | %EGGHOLDER FUNCTION
 69 | % x1 = x(1);
 70 | % x2 = x(2);
 71 | % term1 = -(x2+47) * sin(sqrt(abs(x2+x1/2+47)));
 72 | % term2 = -x1 * sin(sqrt(abs(x1-(x2+47))));
 73 | % 
 74 | % fitness = term1 + term2;
 75 | 
 76 | % ACKLEY FUNCTION
 77 | % d = length(x);
 78 | %  a = 20;
 79 | %  b = 0.2;
 80 | %  c = 2*pi;
 81 | % 
 82 | % sum1 = 0;
 83 | % sum2 = 0;
 84 | % for ii = 1:d
 85 | % 	xi = x(ii);
 86 | % 	sum1 = sum1 + xi^2;
 87 | % 	sum2 = sum2 + cos(c*xi);
 88 | % end
 89 | % 
 90 | % term1 = -a * exp(-b*sqrt(sum1/d));
 91 | % term2 = -exp(sum2/d);
 92 | % fitness = term1 + term2 + a + exp(1);
 93 | 
 94 | % SCHWEFEL FUNCTION
 95 | % x(3)=[];
 96 | % d = length(x);
 97 | % sum = 0;
 98 | % for ii = 1:d
 99 | % 	xi = x(ii);
100 | % 	sum = sum + xi*sin(sqrt(abs(xi)));
101 | % end
102 | % fitness = 418.9829*d - sum;
103 | 
104 | % SCHAFFER FUNCTION N. 2
105 | % x1 = x(1);
106 | % x2 = x(2);
107 | % fact1 = (sin(x1^2-x2^2))^2 - 0.5;
108 | % fact2 = (1 + 0.001*(x1^2+x2^2))^2;
109 | % 
110 | % fitness = 0.5 + fact1/fact2;
111 | 
112 | % SCHAFFER FUNCTION N. 4
113 | % x1 = x(1);
114 | % x2 = x(2);
115 | % fact1 = cos((sin(abs(x1^2-x2^2))))^2 - 0.5;
116 | % fact2 = (1 + 0.001*(x1^2+x2^2))^2;
117 | % 
118 | % fitness = 0.5 + fact1/fact2;
119 | 
120 | %EASOM FUNCTION
121 | % fitness=-cos(x(1))*cos(x(2))*exp(-((x(1)-pi)^2+(x(2)-pi)^2));
122 | 
123 | end


--------------------------------------------------------------------------------
/IWD/limiter.m:
--------------------------------------------------------------------------------
 1 | function newP=limiter(P,VarHigh,VarLow)
 2 | % LIMITER Function to perfrom range limit operation on the solution
 3 | % to be within the search space bounds
 4 | 
 5 | newP=P;
 6 | 
 7 | for i=1:length(P)
 8 |     if newP(i)>VarHigh(i)
 9 |         newP(i)=VarHigh(i);
10 |     elseif newP(i)<VarLow(i)
11 |         newP(i)=VarLow(i);
12 |     end
13 | end
14 |  
15 | 
16 | end


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2018 
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/MBO/MBO.m:
--------------------------------------------------------------------------------
  1 | % Magnetotatic Bacteria Optimizer
  2 | %--------------------------------
  3 | clc
  4 | clear
  5 | close all
  6 | 
  7 | % Problem Statement
  8 | Npar = 3;
  9 | VarLow=[-5.12 -5.12 -5.12];
 10 | VarHigh = [5.12 5.12 5.12];
 11 | 
 12 | % parameters
 13 | MaxIter=100;         %Maximum iteration
 14 | N=50;          %Initial population
 15 | c1 = 20;
 16 | c2 =0.003;
 17 | mp =0.6;
 18 | B = 1;
 19 | 
 20 | % initialize a random value as best value
 21 | XBest = rand(1,Npar).* (VarHigh - VarLow) + VarLow;
 22 | XBestCost = fitnessFunc(XBest);
 23 | GB = XBestCost;
 24 | 
 25 | t=cputime;
 26 | 
 27 | % Initialize of magnetotatic bacteria and memory
 28 | X = zeros(N,Npar);
 29 | F = zeros(N, 1);
 30 | Fnorm = F;
 31 | 
 32 | for ii=1:N       
 33 |     % initialize with a random solution
 34 |     X(ii,:)=rand(1,Npar) .* (VarHigh - VarLow) + VarLow;
 35 | 
 36 |     % find the fitness of the solution
 37 |     F(ii)=fitnessFunc(X(ii,:));
 38 | end
 39 | 
 40 | % Main Loop
 41 | for it=1:MaxIter
 42 |    
 43 |    %normalized fitnesss
 44 |    for ii= 1:N
 45 |       Fnorm(ii) = (F(ii) - min(F))/(max(F) - min(F));  
 46 |    end
 47 |     
 48 |    %interaction distance
 49 |    for ii = 1:N
 50 |        for jj = 1:N
 51 |           for kk = 1:Npar
 52 |              D(ii,jj,kk) = (X(ii,kk) - X(jj,kk));  
 53 |           end
 54 |        end
 55 |    end
 56 |    
 57 |    %Moments
 58 |    for ii = 1:N
 59 |        for jj=1:N
 60 |          for kk = 1:Npar
 61 |            p = round(rand*N +0.5);
 62 |            q = round(rand*N +0.5);
 63 |            for dd = 1:Npar
 64 |              DD(dd) = D(ii,jj,dd); 
 65 |            end
 66 |            E(ii,jj,kk) = (D(ii,jj,kk)/(1+c1*norm(DD) + c2*D(p,q)))^3;
 67 |          end
 68 |        end
 69 |    end
 70 |    M = E/B;
 71 |    
 72 |    %moment regulation
 73 |    for ii=1:N
 74 |      if (rand<mp)
 75 |        X(ii,:) = X(ii,:) + (XBest - X(ii,:)).*rand(1,Npar);
 76 |      else
 77 |         for jj = 1:Npar
 78 |            r = round(rand*N +0.5);
 79 |            X(ii,jj) =  X(r,jj);
 80 |         end
 81 |      end
 82 |      
 83 |      % limit solution within search space
 84 |      X(ii,:) = limiter(X(ii,:),VarHigh,VarLow);
 85 |      
 86 |      % find new fitness
 87 |      F(ii) = fitnessFunc(X(ii,:));
 88 |    end
 89 |    
 90 |    %MTS Replacement
 91 |    [F, sortOrder] = sort(F);
 92 |    X = X(sortOrder,:);
 93 |    
 94 |    for ii= round(N/2):N
 95 |        if rand<0.5
 96 |          for jj = 1:Npar
 97 |            r = round(rand*N +0.5);
 98 |            X(ii,jj) = X(ii,jj) + rand*M(ii,r,jj);
 99 |          end
100 |        else
101 |           X(ii,:)=rand(1,Npar) .* (VarHigh - VarLow) + VarLow;
102 |        end
103 |        
104 |        % limit solution within search space
105 |        X(ii,:) = limiter(X(ii,:),VarHigh,VarLow);
106 |        
107 |        % find new fitness
108 |        F(ii) = fitnessFunc(X(ii,:));
109 |    end
110 |    
111 |    [F, sortOrder] = sort(F);
112 |    X = X(sortOrder,:);
113 |    
114 |    if (F(1) < XBestCost)
115 |       XBestCost = F(1);
116 |       XBest = X(1,:);
117 |    end
118 |    
119 |     % store the best value in each iteration
120 |     GB=[GB XBestCost];
121 | end
122 | 
123 | t1=cputime;
124 | 
125 | fprintf('The time taken is %3.2f seconds \n',t1-t);
126 | fprintf('The best value is :');
127 | XBest
128 | XBestCost
129 | 
130 | % Convergence Plot
131 | figure(1)
132 | plot(0:MaxIter,GB, 'linewidth',1.2);
133 | title('Convergence');
134 | xlabel('Iterations');
135 | ylabel('Objective Function (Cost)');
136 | grid('on')
137 | 
138 | 
139 | 


--------------------------------------------------------------------------------
/MBO/fitnessFunc.m:
--------------------------------------------------------------------------------
  1 | function fitness = fitnessFunc(x)
  2 | 
  3 | %Sphere
  4 | % fitness=sum(x(1)^2+x(2)^2+x(3)^2);
  5 | 
  6 | %Booth
  7 | %    fitness=(x(1)+2*x(2)-7)^2 + (2*x(1) + x(2) - 5)^2;
  8 | 
  9 | %Beale's Function
 10 | % fitness=(1.5 -x(1)+x(1)*x(2))^2+(2.25-x(1)+x(1)*x(2)^2)^2+(2.625-x(1)+x(1)*x(2)^3)^2;
 11 | 
 12 | %six hump camel back
 13 | %   fitness=4*x(1)^2 - 2.1*x(1)^4 +(1/3)*x(1)^6 +x(1)*x(2)-4*x(2)^2+4*x(2)^4;
 14 | 
 15 | %Rastrigin
 16 | fitness = x(1)^2 - 10*cos(2*pi*x(1)) + 10;
 17 | fitness= fitness+ x(2)^2 - 10*cos(2*pi*x(2)) + 10;
 18 | fitness= fitness+ x(3)^2 - 10*cos(2*pi*x(3)) + 10;
 19 | 
 20 | %step
 21 | %     fitness=(x(1)+0.5)^2+(x(2)+0.5)^2;
 22 | 
 23 | %Rosenbrock
 24 | %    fitness=100*(x(2)-(x(1)^2))^2+ (x(1)-(x(1)^2))^2;
 25 | 
 26 | %trignometric
 27 | %    fitness=x(1)*sin(4*(x(1)))+1.1*x(2)*sin(2*(x(2)));
 28 | 
 29 | %trignometric 2
 30 | %  fitness=0.5+(sin(sqrtm(x(1)^2+x(2)^2))^2 - 0.5)/(1+0.1*(x(1)^2+x(2)^2));
 31 | 
 32 | %McCormick function
 33 | % fitness=sin(x(1)+x(2))+(x(1)-x(2))^2 -1.5*x(1)+2.5*x(2)+1;
 34 | 
 35 | %Greiwank function
 36 | %  fitness=(1/4000)*((x(1)-100)^2-(cos(x(1)-100)+(x(2)-100)^2-(cos(x(2)-100))));
 37 | 
 38 | %Matyas Function
 39 | % fitness=0.26*(x(1)^2 +x(2)^2)-0.48*x(1)*x(2);
 40 | 
 41 | %Schubert
 42 | %   fitness=((cos(2)+2*cos(3)+3*cos(4)+4*cos(5))*x(1)+1)*((cos(2)+2*cos(3)+3*cos(4)+4*cos(5))*x(2)+1);
 43 | 
 44 | 
 45 | %Quartic
 46 | % fitness=x(1)^4+2*x(2)^4+0.7886*(x(1));
 47 | 
 48 | %Drop wave function
 49 | %   fitness = (-1+cos(12*sqrtm(x(1)^2+x(2)^2)))/(0.5*(x(1)^2+x(2)^2));
 50 | 
 51 | %Cross intray
 52 | % fact1 = sin(x(1))*sin(x(2));
 53 | % fact2 = exp(abs(100 - sqrt(x(1)^2+x(2)^2)/pi));
 54 | % fitness= -0.0001 * (abs(fact1*fact2)+1)^0.1;
 55 | 
 56 | 
 57 | % MICHALEWICZ FUNCTION
 58 | % x(3)=[];
 59 | % d = length(x);
 60 | % sum = 0;
 61 | % for ii = 1:d
 62 | % 	xi = x(ii);
 63 | % 	new = sin(xi) * (sin(ii*xi^2/pi))^(2*10);
 64 | % 	sum  = sum + new;
 65 | % end
 66 | % fitness = -sum;
 67 | 
 68 | %EGGHOLDER FUNCTION
 69 | % x1 = x(1);
 70 | % x2 = x(2);
 71 | % term1 = -(x2+47) * sin(sqrt(abs(x2+x1/2+47)));
 72 | % term2 = -x1 * sin(sqrt(abs(x1-(x2+47))));
 73 | % 
 74 | % fitness = term1 + term2;
 75 | 
 76 | % ACKLEY FUNCTION
 77 | % d = length(x);
 78 | %  a = 20;
 79 | %  b = 0.2;
 80 | %  c = 2*pi;
 81 | % 
 82 | % sum1 = 0;
 83 | % sum2 = 0;
 84 | % for ii = 1:d
 85 | % 	xi = x(ii);
 86 | % 	sum1 = sum1 + xi^2;
 87 | % 	sum2 = sum2 + cos(c*xi);
 88 | % end
 89 | % 
 90 | % term1 = -a * exp(-b*sqrt(sum1/d));
 91 | % term2 = -exp(sum2/d);
 92 | % fitness = term1 + term2 + a + exp(1);
 93 | 
 94 | % SCHWEFEL FUNCTION
 95 | % x(3)=[];
 96 | % d = length(x);
 97 | % sum = 0;
 98 | % for ii = 1:d
 99 | % 	xi = x(ii);
100 | % 	sum = sum + xi*sin(sqrt(abs(xi)));
101 | % end
102 | % fitness = 418.9829*d - sum;
103 | 
104 | % SCHAFFER FUNCTION N. 2
105 | % x1 = x(1);
106 | % x2 = x(2);
107 | % fact1 = (sin(x1^2-x2^2))^2 - 0.5;
108 | % fact2 = (1 + 0.001*(x1^2+x2^2))^2;
109 | % 
110 | % fitness = 0.5 + fact1/fact2;
111 | 
112 | % SCHAFFER FUNCTION N. 4
113 | % x1 = x(1);
114 | % x2 = x(2);
115 | % fact1 = cos((sin(abs(x1^2-x2^2))))^2 - 0.5;
116 | % fact2 = (1 + 0.001*(x1^2+x2^2))^2;
117 | % 
118 | % fitness = 0.5 + fact1/fact2;
119 | 
120 | %EASOM FUNCTION
121 | % fitness=-cos(x(1))*cos(x(2))*exp(-((x(1)-pi)^2+(x(2)-pi)^2));
122 | 
123 | end


--------------------------------------------------------------------------------
/MBO/limiter.m:
--------------------------------------------------------------------------------
 1 | function newP=limiter(P,VarHigh,VarLow)
 2 | % LIMITER Function to perfrom range limit operation on the solution
 3 | % to be within the search space bounds
 4 | 
 5 | newP=P;
 6 | 
 7 | for i=1:length(P)
 8 |     if newP(i)>VarHigh(i)
 9 |         newP(i)=VarHigh(i);
10 |     elseif newP(i)<VarLow(i)
11 |         newP(i)=VarLow(i);
12 |     end
13 | end
14 |  
15 | 
16 | end


--------------------------------------------------------------------------------
/PSO/PSO.m:
--------------------------------------------------------------------------------
 1 | % Particle Swarm Optimization
 2 | %-----------------------------
 3 | clc
 4 | clear
 5 | close all
 6 | 
 7 | % Problem Statement
 8 | Npar = 3;
 9 | VarLow=[-5.12 -5.12 -5.12];
10 | VarHigh = [5.12 5.12 5.12];
11 | 
12 | % Parameters
13 | C1 = 2;
14 | C2 = 4-C1;
15 | Inertia = .3;
16 | DampRatio = .95;
17 | ParticleSize = 100;
18 | MaxIter = 100;
19 | 
20 | % initialize a random value as best value
21 | GlobalBest = rand(1,Npar).* (VarHigh - VarLow) + VarLow;
22 | GlobalBestCost = fitnessFunc(GlobalBest);
23 | GB = GlobalBestCost;
24 | t = cputime;
25 | 
26 | % Initialization of particles and memory
27 | Particle=repmat(struct('Position',zeros(1,Npar),'Velocity',zeros(1,Npar)),ParticleSize,1);
28 | 
29 | for ii = 1:ParticleSize
30 |     
31 |     % initialize with a random position
32 |     Particle(ii).Position = rand(1,Npar).* (VarHigh - VarLow) + VarLow;
33 | 
34 |     % find the cost for that position
35 |     Particle(ii).Cost = fitnessFunc(Particle(ii).Position);
36 | 
37 |     % initialize velocity as random
38 |     Particle(ii).Velocity = rand(1,Npar);
39 |     
40 |     % store current position and cost as localbest
41 |     Particle(ii).LocalBest = Particle(ii).Position;
42 |     Particle(ii).LocalBestCost = Particle(ii).Cost;
43 |     
44 |     % update globalbest cost
45 |     if Particle(ii).Cost < GlobalBestCost
46 |         GlobalBest = Particle(ii).Position;
47 |         GlobalBestCost = Particle(ii).Cost;
48 |     end
49 | end
50 | 
51 | % Main Loop
52 | for jj = 1:MaxIter
53 |     for ii = 1:ParticleSize
54 |         Inertia = Inertia * DampRatio;
55 |         
56 |         % update velocity 
57 |         Particle(ii).Velocity = rand * Inertia * Particle(ii).Velocity + C1 * rand * (Particle(ii).LocalBest - Particle(ii).Position) +  C2 * rand * (GlobalBest - Particle(ii).Position);
58 |         
59 |         % update to new position
60 |         Particle(ii).Position = Particle(ii).Position + Particle(ii).Velocity;
61 | 
62 |         % limit position within search space
63 |         Particle(ii).Position = limiter(Particle(ii).Position,VarHigh,VarLow);
64 |         
65 |         % calculate the new cost
66 |         Particle(ii).Cost = fitnessFunc(Particle(ii).Position);
67 | 
68 |         % update local best and global best
69 |         if Particle(ii).Cost < Particle(ii).LocalBestCost
70 |             Particle(ii).LocalBest = Particle(ii).Position;
71 |             Particle(ii).LocalBestCost = Particle(ii).Cost;
72 | 
73 |             if Particle(ii).Cost < GlobalBestCost
74 |                 GlobalBest = Particle(ii).Position;
75 |                 GlobalBestCost = Particle(ii).Cost;
76 |             end
77 |         end
78 |     end
79 |     
80 |     % store the best value in each iteration
81 |     GB = [GB GlobalBestCost];
82 | end
83 | 
84 | t1=cputime;
85 | 
86 | fprintf('The time taken is %3.2f seconds \n',t1-t);
87 | fprintf('The best value is :');
88 | GlobalBest
89 | GlobalBestCost
90 | 
91 | % Convergence Plot
92 | figure(1)
93 | plot(0:MaxIter,GB, 'linewidth',1.2);
94 | title('Convergence');
95 | xlabel('Iterations');
96 | ylabel('Objective Function (Cost)');
97 | grid('on')
98 | 
99 | 


--------------------------------------------------------------------------------
/PSO/fitnessFunc.m:
--------------------------------------------------------------------------------
  1 | function fitness = fitnessFunc(x)
  2 | 
  3 | %Sphere
  4 | % fitness=sum(x(1)^2+x(2)^2+x(3)^2);
  5 | 
  6 | %Booth
  7 | %    fitness=(x(1)+2*x(2)-7)^2 + (2*x(1) + x(2) - 5)^2;
  8 | 
  9 | %Beale's Function
 10 | % fitness=(1.5 -x(1)+x(1)*x(2))^2+(2.25-x(1)+x(1)*x(2)^2)^2+(2.625-x(1)+x(1)*x(2)^3)^2;
 11 | 
 12 | %six hump camel back
 13 | %   fitness=4*x(1)^2 - 2.1*x(1)^4 +(1/3)*x(1)^6 +x(1)*x(2)-4*x(2)^2+4*x(2)^4;
 14 | 
 15 | %Rastrigin
 16 | fitness = x(1)^2 - 10*cos(2*pi*x(1)) + 10;
 17 | fitness= fitness+ x(2)^2 - 10*cos(2*pi*x(2)) + 10;
 18 | fitness= fitness+ x(3)^2 - 10*cos(2*pi*x(3)) + 10;
 19 | 
 20 | %step
 21 | %     fitness=(x(1)+0.5)^2+(x(2)+0.5)^2;
 22 | 
 23 | %Rosenbrock
 24 | %    fitness=100*(x(2)-(x(1)^2))^2+ (x(1)-(x(1)^2))^2;
 25 | 
 26 | %trignometric
 27 | %    fitness=x(1)*sin(4*(x(1)))+1.1*x(2)*sin(2*(x(2)));
 28 | 
 29 | %trignometric 2
 30 | %  fitness=0.5+(sin(sqrtm(x(1)^2+x(2)^2))^2 - 0.5)/(1+0.1*(x(1)^2+x(2)^2));
 31 | 
 32 | %McCormick function
 33 | % fitness=sin(x(1)+x(2))+(x(1)-x(2))^2 -1.5*x(1)+2.5*x(2)+1;
 34 | 
 35 | %Greiwank function
 36 | %  fitness=(1/4000)*((x(1)-100)^2-(cos(x(1)-100)+(x(2)-100)^2-(cos(x(2)-100))));
 37 | 
 38 | %Matyas Function
 39 | % fitness=0.26*(x(1)^2 +x(2)^2)-0.48*x(1)*x(2);
 40 | 
 41 | %Schubert
 42 | %   fitness=((cos(2)+2*cos(3)+3*cos(4)+4*cos(5))*x(1)+1)*((cos(2)+2*cos(3)+3*cos(4)+4*cos(5))*x(2)+1);
 43 | 
 44 | 
 45 | %Quartic
 46 | % fitness=x(1)^4+2*x(2)^4+0.7886*(x(1));
 47 | 
 48 | %Drop wave function
 49 | %   fitness = (-1+cos(12*sqrtm(x(1)^2+x(2)^2)))/(0.5*(x(1)^2+x(2)^2));
 50 | 
 51 | %Cross intray
 52 | % fact1 = sin(x(1))*sin(x(2));
 53 | % fact2 = exp(abs(100 - sqrt(x(1)^2+x(2)^2)/pi));
 54 | % fitness= -0.0001 * (abs(fact1*fact2)+1)^0.1;
 55 | 
 56 | 
 57 | % MICHALEWICZ FUNCTION
 58 | % x(3)=[];
 59 | % d = length(x);
 60 | % sum = 0;
 61 | % for ii = 1:d
 62 | % 	xi = x(ii);
 63 | % 	new = sin(xi) * (sin(ii*xi^2/pi))^(2*10);
 64 | % 	sum  = sum + new;
 65 | % end
 66 | % fitness = -sum;
 67 | 
 68 | %EGGHOLDER FUNCTION
 69 | % x1 = x(1);
 70 | % x2 = x(2);
 71 | % term1 = -(x2+47) * sin(sqrt(abs(x2+x1/2+47)));
 72 | % term2 = -x1 * sin(sqrt(abs(x1-(x2+47))));
 73 | % 
 74 | % fitness = term1 + term2;
 75 | 
 76 | % ACKLEY FUNCTION
 77 | % d = length(x);
 78 | %  a = 20;
 79 | %  b = 0.2;
 80 | %  c = 2*pi;
 81 | % 
 82 | % sum1 = 0;
 83 | % sum2 = 0;
 84 | % for ii = 1:d
 85 | % 	xi = x(ii);
 86 | % 	sum1 = sum1 + xi^2;
 87 | % 	sum2 = sum2 + cos(c*xi);
 88 | % end
 89 | % 
 90 | % term1 = -a * exp(-b*sqrt(sum1/d));
 91 | % term2 = -exp(sum2/d);
 92 | % fitness = term1 + term2 + a + exp(1);
 93 | 
 94 | % SCHWEFEL FUNCTION
 95 | % x(3)=[];
 96 | % d = length(x);
 97 | % sum = 0;
 98 | % for ii = 1:d
 99 | % 	xi = x(ii);
100 | % 	sum = sum + xi*sin(sqrt(abs(xi)));
101 | % end
102 | % fitness = 418.9829*d - sum;
103 | 
104 | % SCHAFFER FUNCTION N. 2
105 | % x1 = x(1);
106 | % x2 = x(2);
107 | % fact1 = (sin(x1^2-x2^2))^2 - 0.5;
108 | % fact2 = (1 + 0.001*(x1^2+x2^2))^2;
109 | % 
110 | % fitness = 0.5 + fact1/fact2;
111 | 
112 | % SCHAFFER FUNCTION N. 4
113 | % x1 = x(1);
114 | % x2 = x(2);
115 | % fact1 = cos((sin(abs(x1^2-x2^2))))^2 - 0.5;
116 | % fact2 = (1 + 0.001*(x1^2+x2^2))^2;
117 | % 
118 | % fitness = 0.5 + fact1/fact2;
119 | 
120 | %EASOM FUNCTION
121 | % fitness=-cos(x(1))*cos(x(2))*exp(-((x(1)-pi)^2+(x(2)-pi)^2));
122 | 
123 | end


--------------------------------------------------------------------------------
/PSO/limiter.m:
--------------------------------------------------------------------------------
 1 | function newP=limiter(P,VarHigh,VarLow)
 2 | % LIMITER Function to perfrom range limit operation on the solution
 3 | % to be within the search space bounds
 4 | 
 5 | newP=P;
 6 | 
 7 | for i=1:length(P)
 8 |     if newP(i)>VarHigh(i)
 9 |         newP(i)=VarHigh(i);
10 |     elseif newP(i)<VarLow(i)
11 |         newP(i)=VarLow(i);
12 |     end
13 | end
14 |  
15 | 
16 | end


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # Collection_of_Optimization_Algorithms
2 | A collection of evolutionary optimization algorithms in MATLAB
3 | 


--------------------------------------------------------------------------------
/SBO/Roulette.m:
--------------------------------------------------------------------------------
 1 | function f = Roulette(prob)
 2 | %ROULETTE Function to perfrom Roulette Wheel selection
 3 | % based on probability
 4 | 
 5 | C=cumsum(prob);
 6 | f=find(rand<=C,1,'first');
 7 |     
 8 | end
 9 | 
10 | 


--------------------------------------------------------------------------------
/SBO/SBO.m:
--------------------------------------------------------------------------------
  1 | %Satin Bower bird algorithm
  2 | %---------------------------
  3 | clc
  4 | clear
  5 | close all
  6 | 
  7 | % Problem Statement
  8 | Npar = 3;
  9 | VarLow=[-5.12 -5.12 -5.12];
 10 | VarHigh = [5.12 5.12 5.12];
 11 | 
 12 | %Parameters
 13 | nb=100;  %number of bowerbirds
 14 | maxIter=100;  %maximum number of iterations
 15 | alpha = 0.1; %greatest step size
 16 | pMut = 0.05;  %mutation probability
 17 | Z = 0.02;    % spread factor
 18 | 
 19 | % initialize a random value as best value
 20 | BestSol= rand(1,Npar).* (VarHigh - VarLow) + VarLow; %elite 
 21 | BestCost= fitnessFunc(BestSol);
 22 | GB = BestCost;
 23 | t = cputime;
 24 | 
 25 | %intialize of solutions and memory
 26 | pop = zeros(nb,Npar);
 27 | Fit = zeros(nb, 1);
 28 | F = zeros(nb, 1);
 29 | 
 30 | for ii = 1:nb
 31 |     % initialize bowers with random values
 32 |     pop(ii,:) = rand(1,Npar).* (VarHigh - VarLow) + VarLow;
 33 | 
 34 |     % find the fitness for of the bower
 35 |     Fit(ii) = fitnessFunc(pop(ii,:));
 36 |     
 37 |     % store the best value
 38 |     if Fit(ii)<BestCost
 39 |         BestSol = pop(ii,:);
 40 |         BestCost= Fit(ii);
 41 |     end
 42 | end
 43 | 
 44 | for jj=1:maxIter
 45 |     
 46 |     %Calculate F from Fitness
 47 |     for ii=1:nb
 48 |         if Fit(ii) > 0
 49 |             F(ii) = 1/(1+Fit(ii));  
 50 |         else
 51 |             F(ii) = 1 + abs(Fit(ii));
 52 |         end
 53 |     end
 54 |     Fsum=sum(F); % sum of F
 55 |    
 56 |     % calculate probability of each bower
 57 |     prob = F/sum(F);
 58 |     
 59 |     oldpop = pop;
 60 |     oldfit = Fit;
 61 | 
 62 |     %deterministic changes
 63 |     for ii=1:nb
 64 |         for k = 1:Npar
 65 |             %select a target bower
 66 |             target = Roulette(prob);
 67 |             
 68 |             % calculate step size
 69 |             lambda = alpha/(1+prob(ii));
 70 | 
 71 |             % update bower
 72 |             pop(ii,k) = pop(ii,k) + lambda*(((pop(target,k) + BestSol(k))/2) - pop(ii,k));
 73 | 
 74 |             %mutation
 75 |             if rand<pMut
 76 |                 pop(ii,k) = pop(ii,k) + Z*randn*(VarHigh(k) - VarLow(k));
 77 |             end
 78 |       
 79 |         end
 80 |         
 81 |         % limit solution within searchspace
 82 |         pop(ii,:)=limiter(pop(ii,:),VarHigh, VarLow);
 83 | 
 84 |         % caclulate the new fitness
 85 |         Fit(ii) = fitnessFunc(pop(ii,:));
 86 |     end
 87 |     
 88 |     %Elitism
 89 |     pop = [pop
 90 |           oldpop];
 91 |     Fit = [Fit
 92 |            oldfit];
 93 |     
 94 |     [Fit, index]=sort(Fit); % sort pop according to fitness
 95 |     Fit = Fit(1:nb);
 96 |     pop = pop(index, :);
 97 |     pop = pop(1:nb, :);
 98 |     
 99 |     % store the best value
100 |     BestSol = pop(1, :);
101 |     BestCost = Fit(1);
102 |     
103 |     % store the best value in each iteration
104 |     GB= [GB BestCost];
105 | end
106 | t1=cputime;
107 | 
108 | fprintf('The time taken is %3.2f seconds \n',t1-t);
109 | fprintf('The best value is :');
110 | BestSol
111 | BestCost
112 | 
113 | % Convergence Plot
114 | figure(1)
115 | plot(0:maxIter,GB, 'linewidth',1.2);
116 | title('Convergence');
117 | xlabel('Iterations');
118 | ylabel('Objective Function (Cost)');
119 | grid('on')
120 | 


--------------------------------------------------------------------------------
/SBO/fitnessFunc.m:
--------------------------------------------------------------------------------
  1 | function fitness = fitnessFunc(x)
  2 | 
  3 | %Sphere
  4 | % fitness=sum(x(1)^2+x(2)^2+x(3)^2);
  5 | 
  6 | %Booth
  7 | %    fitness=(x(1)+2*x(2)-7)^2 + (2*x(1) + x(2) - 5)^2;
  8 | 
  9 | %Beale's Function
 10 | % fitness=(1.5 -x(1)+x(1)*x(2))^2+(2.25-x(1)+x(1)*x(2)^2)^2+(2.625-x(1)+x(1)*x(2)^3)^2;
 11 | 
 12 | %six hump camel back
 13 | %   fitness=4*x(1)^2 - 2.1*x(1)^4 +(1/3)*x(1)^6 +x(1)*x(2)-4*x(2)^2+4*x(2)^4;
 14 | 
 15 | %Rastrigin
 16 | fitness = x(1)^2 - 10*cos(2*pi*x(1)) + 10;
 17 | fitness= fitness+ x(2)^2 - 10*cos(2*pi*x(2)) + 10;
 18 | fitness= fitness+ x(3)^2 - 10*cos(2*pi*x(3)) + 10;
 19 | 
 20 | %step
 21 | %     fitness=(x(1)+0.5)^2+(x(2)+0.5)^2;
 22 | 
 23 | %Rosenbrock
 24 | %    fitness=100*(x(2)-(x(1)^2))^2+ (x(1)-(x(1)^2))^2;
 25 | 
 26 | %trignometric
 27 | %    fitness=x(1)*sin(4*(x(1)))+1.1*x(2)*sin(2*(x(2)));
 28 | 
 29 | %trignometric 2
 30 | %  fitness=0.5+(sin(sqrtm(x(1)^2+x(2)^2))^2 - 0.5)/(1+0.1*(x(1)^2+x(2)^2));
 31 | 
 32 | %McCormick function
 33 | % fitness=sin(x(1)+x(2))+(x(1)-x(2))^2 -1.5*x(1)+2.5*x(2)+1;
 34 | 
 35 | %Greiwank function
 36 | %  fitness=(1/4000)*((x(1)-100)^2-(cos(x(1)-100)+(x(2)-100)^2-(cos(x(2)-100))));
 37 | 
 38 | %Matyas Function
 39 | % fitness=0.26*(x(1)^2 +x(2)^2)-0.48*x(1)*x(2);
 40 | 
 41 | %Schubert
 42 | %   fitness=((cos(2)+2*cos(3)+3*cos(4)+4*cos(5))*x(1)+1)*((cos(2)+2*cos(3)+3*cos(4)+4*cos(5))*x(2)+1);
 43 | 
 44 | 
 45 | %Quartic
 46 | % fitness=x(1)^4+2*x(2)^4+0.7886*(x(1));
 47 | 
 48 | %Drop wave function
 49 | %   fitness = (-1+cos(12*sqrtm(x(1)^2+x(2)^2)))/(0.5*(x(1)^2+x(2)^2));
 50 | 
 51 | %Cross intray
 52 | % fact1 = sin(x(1))*sin(x(2));
 53 | % fact2 = exp(abs(100 - sqrt(x(1)^2+x(2)^2)/pi));
 54 | % fitness= -0.0001 * (abs(fact1*fact2)+1)^0.1;
 55 | 
 56 | 
 57 | % MICHALEWICZ FUNCTION
 58 | % x(3)=[];
 59 | % d = length(x);
 60 | % sum = 0;
 61 | % for ii = 1:d
 62 | % 	xi = x(ii);
 63 | % 	new = sin(xi) * (sin(ii*xi^2/pi))^(2*10);
 64 | % 	sum  = sum + new;
 65 | % end
 66 | % fitness = -sum;
 67 | 
 68 | %EGGHOLDER FUNCTION
 69 | % x1 = x(1);
 70 | % x2 = x(2);
 71 | % term1 = -(x2+47) * sin(sqrt(abs(x2+x1/2+47)));
 72 | % term2 = -x1 * sin(sqrt(abs(x1-(x2+47))));
 73 | % 
 74 | % fitness = term1 + term2;
 75 | 
 76 | % ACKLEY FUNCTION
 77 | % d = length(x);
 78 | %  a = 20;
 79 | %  b = 0.2;
 80 | %  c = 2*pi;
 81 | % 
 82 | % sum1 = 0;
 83 | % sum2 = 0;
 84 | % for ii = 1:d
 85 | % 	xi = x(ii);
 86 | % 	sum1 = sum1 + xi^2;
 87 | % 	sum2 = sum2 + cos(c*xi);
 88 | % end
 89 | % 
 90 | % term1 = -a * exp(-b*sqrt(sum1/d));
 91 | % term2 = -exp(sum2/d);
 92 | % fitness = term1 + term2 + a + exp(1);
 93 | 
 94 | % SCHWEFEL FUNCTION
 95 | % x(3)=[];
 96 | % d = length(x);
 97 | % sum = 0;
 98 | % for ii = 1:d
 99 | % 	xi = x(ii);
100 | % 	sum = sum + xi*sin(sqrt(abs(xi)));
101 | % end
102 | % fitness = 418.9829*d - sum;
103 | 
104 | % SCHAFFER FUNCTION N. 2
105 | % x1 = x(1);
106 | % x2 = x(2);
107 | % fact1 = (sin(x1^2-x2^2))^2 - 0.5;
108 | % fact2 = (1 + 0.001*(x1^2+x2^2))^2;
109 | % 
110 | % fitness = 0.5 + fact1/fact2;
111 | 
112 | % SCHAFFER FUNCTION N. 4
113 | % x1 = x(1);
114 | % x2 = x(2);
115 | % fact1 = cos((sin(abs(x1^2-x2^2))))^2 - 0.5;
116 | % fact2 = (1 + 0.001*(x1^2+x2^2))^2;
117 | % 
118 | % fitness = 0.5 + fact1/fact2;
119 | 
120 | %EASOM FUNCTION
121 | % fitness=-cos(x(1))*cos(x(2))*exp(-((x(1)-pi)^2+(x(2)-pi)^2));
122 | 
123 | end


--------------------------------------------------------------------------------
/SBO/limiter.m:
--------------------------------------------------------------------------------
 1 | function newP=limiter(P,VarHigh,VarLow)
 2 | % LIMITER Function to perfrom range limit operation on the solution
 3 | % to be within the search space bounds
 4 | 
 5 | newP=P;
 6 | 
 7 | for i=1:length(P)
 8 |     if newP(i)>VarHigh(i)
 9 |         newP(i)=VarHigh(i);
10 |     elseif newP(i)<VarLow(i)
11 |         newP(i)=VarLow(i);
12 |     end
13 | end
14 |  
15 | 
16 | end


--------------------------------------------------------------------------------
/SOS/SOS.m:
--------------------------------------------------------------------------------
  1 | %Symbiotic organism Search 
  2 | %-------------------------
  3 | 
  4 | clc
  5 | clear
  6 | close all
  7 | warning off
  8 | 
  9 | %Problem Statement
 10 | Npar = 3;
 11 | VarLow=[-5.12 -5.12 -5.12];
 12 | VarHigh = [5.12 5.12 5.12];
 13 | 
 14 | % parameters
 15 | n=50;
 16 | MaxIter=50;
 17 | 
 18 | XBest = rand(1,Npar).* (VarHigh - VarLow) + VarLow;
 19 | XBestFit = fitnessFunc(XBest);
 20 | GB = XBestFit;
 21 | 
 22 | %Initialization of memory
 23 | X=repmat(struct('Position',zeros(1,Npar),'Velocity',zeros(1,Npar)),n,1);
 24 | 
 25 | t=cputime;
 26 | 
 27 | %Initialize Random ecosystem
 28 | for ii = 1:n
 29 |     X(ii).Position = rand(1,Npar).* (VarHigh - VarLow) + VarLow;
 30 |     X(ii).Position=limiter(X(ii).Position,VarHigh,VarLow);
 31 |     X(ii).Fit = fitnessFunc(X(ii).Position);
 32 | 
 33 |     if X(ii).Fit < XBestFit
 34 |         XBest = X(ii).Position;
 35 |         XBestFit = X(ii).Fit;
 36 |     end
 37 | end
 38 | 
 39 | 
 40 | %Main Loop
 41 | for jj=1:MaxIter
 42 |     for ii=1:n
 43 |         %MUTUALISM PHASE
 44 |         j=randperm(n,1);   %random organism to interact
 45 |         Mutual_Vector=(X(ii).Position+X(j).Position)/2; % mutual vector
 46 |         
 47 |         % new solutions
 48 |         Xinew = X(ii).Position+rand(1,Npar).*(XBest-Mutual_Vector);
 49 |         Xjnew = X(j).Position+rand(1,Npar).*(XBest-Mutual_Vector);
 50 |         
 51 |         % limit solutions within search space
 52 |         Xinew=limiter(Xinew,VarHigh,VarLow);
 53 |         Xjnew=limiter(Xjnew,VarHigh,VarLow);
 54 |         
 55 |         % find new fitness values
 56 |         Xinewfit=fitnessFunc(Xinew);
 57 |         Xjnewfit=fitnessFunc(Xjnew);
 58 | 
 59 |         % update organisms if better
 60 |         if Xinewfit<X(ii).Fit
 61 |             X(ii).Position=Xinew;
 62 |             X(ii).Fit=Xinewfit;
 63 |             if X(ii).Fit < XBestFit
 64 |               XBest = X(ii).Position;
 65 |               XBestFit = X(ii).Fit;
 66 |             end
 67 |         end
 68 |         if Xjnewfit<X(j).Fit
 69 |             X(j).Position=Xjnew;
 70 |             X(j).Fit=Xjnewfit;
 71 |             if X(j).Fit < XBestFit
 72 |               XBest = X(j).Position;
 73 |               XBestFit = X(j).Fit;
 74 |             end
 75 |         end
 76 | 
 77 |         %COMMENSALISM PHASE
 78 |         j=randperm(n,1);   %random organism to interact
 79 |         Xinew = X(ii).Position+(rand).*(XBest-X(ii).Position);
 80 |         Xinew=limiter(Xinew,VarHigh,VarLow); % limit within search space
 81 |         Xinewfit=fitnessFunc(Xinew);  % update fitness
 82 |         
 83 |         % update organism if better
 84 |         if Xinewfit<X(ii).Fit
 85 |             X(ii).Position=Xinew;
 86 |             X(ii).Fit=Xinewfit;
 87 |             if X(ii).Fit < XBestFit
 88 |               XBest = X(ii).Position;
 89 |               XBestFit = X(ii).Fit;
 90 |             end
 91 |         end
 92 | 
 93 |         %PARASITISM PHASE
 94 |         j=randperm(n,1);   %random organism to become parasite
 95 |         Xpar=X(j).Position;
 96 |         Xm=randperm(Npar,1); %random vector dimension
 97 |         Xpar(Xm) = rand* (VarHigh(Xm) - VarLow(Xm)) + VarLow(Xm);
 98 |         
 99 |         % limit within search space
100 |         Xpar=limiter(Xpar,VarHigh,VarLow);
101 |         Xparfit=fitnessFunc(Xpar);  % update fitness
102 | 
103 |         % update organism if better
104 |         if Xparfit<X(ii).Fit
105 |             X(ii).Position=Xpar;
106 |             X(ii).Fit=Xparfit;
107 |             if X(ii).Fit < XBestFit
108 |               XBest = X(ii).Position;
109 |               XBestFit = X(ii).Fit;
110 |             end
111 |         end
112 | 
113 |     end
114 |     
115 |     % store the best value in each iteration
116 |     GB = [GB XBestFit];
117 | end
118 | 
119 | t1=cputime;
120 | 
121 | fprintf('The time taken is %3.2f seconds \n',t1-t);
122 | fprintf('The best value is :');
123 | XBest
124 | XBestFit
125 | 
126 | % Convergence Plot
127 | figure(1)
128 | plot(0:MaxIter,GB, 'linewidth',1.2);
129 | title('Convergence');
130 | xlabel('Iterations');
131 | ylabel('Objective Function (Cost)');
132 | grid('on')
133 | 
134 | 


--------------------------------------------------------------------------------
/SOS/fitnessFunc.m:
--------------------------------------------------------------------------------
  1 | function fitness = fitnessFunc(x)
  2 | 
  3 | %Sphere
  4 | % fitness=sum(x(1)^2+x(2)^2+x(3)^2);
  5 | 
  6 | %Booth
  7 | %    fitness=(x(1)+2*x(2)-7)^2 + (2*x(1) + x(2) - 5)^2;
  8 | 
  9 | %Beale's Function
 10 | % fitness=(1.5 -x(1)+x(1)*x(2))^2+(2.25-x(1)+x(1)*x(2)^2)^2+(2.625-x(1)+x(1)*x(2)^3)^2;
 11 | 
 12 | %six hump camel back
 13 | %   fitness=4*x(1)^2 - 2.1*x(1)^4 +(1/3)*x(1)^6 +x(1)*x(2)-4*x(2)^2+4*x(2)^4;
 14 | 
 15 | %Rastrigin
 16 | fitness = x(1)^2 - 10*cos(2*pi*x(1)) + 10;
 17 | fitness= fitness+ x(2)^2 - 10*cos(2*pi*x(2)) + 10;
 18 | fitness= fitness+ x(3)^2 - 10*cos(2*pi*x(3)) + 10;
 19 | 
 20 | %step
 21 | %     fitness=(x(1)+0.5)^2+(x(2)+0.5)^2;
 22 | 
 23 | %Rosenbrock
 24 | %    fitness=100*(x(2)-(x(1)^2))^2+ (x(1)-(x(1)^2))^2;
 25 | 
 26 | %trignometric
 27 | %    fitness=x(1)*sin(4*(x(1)))+1.1*x(2)*sin(2*(x(2)));
 28 | 
 29 | %trignometric 2
 30 | %  fitness=0.5+(sin(sqrtm(x(1)^2+x(2)^2))^2 - 0.5)/(1+0.1*(x(1)^2+x(2)^2));
 31 | 
 32 | %McCormick function
 33 | % fitness=sin(x(1)+x(2))+(x(1)-x(2))^2 -1.5*x(1)+2.5*x(2)+1;
 34 | 
 35 | %Greiwank function
 36 | %  fitness=(1/4000)*((x(1)-100)^2-(cos(x(1)-100)+(x(2)-100)^2-(cos(x(2)-100))));
 37 | 
 38 | %Matyas Function
 39 | % fitness=0.26*(x(1)^2 +x(2)^2)-0.48*x(1)*x(2);
 40 | 
 41 | %Schubert
 42 | %   fitness=((cos(2)+2*cos(3)+3*cos(4)+4*cos(5))*x(1)+1)*((cos(2)+2*cos(3)+3*cos(4)+4*cos(5))*x(2)+1);
 43 | 
 44 | 
 45 | %Quartic
 46 | % fitness=x(1)^4+2*x(2)^4+0.7886*(x(1));
 47 | 
 48 | %Drop wave function
 49 | %   fitness = (-1+cos(12*sqrtm(x(1)^2+x(2)^2)))/(0.5*(x(1)^2+x(2)^2));
 50 | 
 51 | %Cross intray
 52 | % fact1 = sin(x(1))*sin(x(2));
 53 | % fact2 = exp(abs(100 - sqrt(x(1)^2+x(2)^2)/pi));
 54 | % fitness= -0.0001 * (abs(fact1*fact2)+1)^0.1;
 55 | 
 56 | 
 57 | % MICHALEWICZ FUNCTION
 58 | % x(3)=[];
 59 | % d = length(x);
 60 | % sum = 0;
 61 | % for ii = 1:d
 62 | % 	xi = x(ii);
 63 | % 	new = sin(xi) * (sin(ii*xi^2/pi))^(2*10);
 64 | % 	sum  = sum + new;
 65 | % end
 66 | % fitness = -sum;
 67 | 
 68 | %EGGHOLDER FUNCTION
 69 | % x1 = x(1);
 70 | % x2 = x(2);
 71 | % term1 = -(x2+47) * sin(sqrt(abs(x2+x1/2+47)));
 72 | % term2 = -x1 * sin(sqrt(abs(x1-(x2+47))));
 73 | % 
 74 | % fitness = term1 + term2;
 75 | 
 76 | % ACKLEY FUNCTION
 77 | % d = length(x);
 78 | %  a = 20;
 79 | %  b = 0.2;
 80 | %  c = 2*pi;
 81 | % 
 82 | % sum1 = 0;
 83 | % sum2 = 0;
 84 | % for ii = 1:d
 85 | % 	xi = x(ii);
 86 | % 	sum1 = sum1 + xi^2;
 87 | % 	sum2 = sum2 + cos(c*xi);
 88 | % end
 89 | % 
 90 | % term1 = -a * exp(-b*sqrt(sum1/d));
 91 | % term2 = -exp(sum2/d);
 92 | % fitness = term1 + term2 + a + exp(1);
 93 | 
 94 | % SCHWEFEL FUNCTION
 95 | % x(3)=[];
 96 | % d = length(x);
 97 | % sum = 0;
 98 | % for ii = 1:d
 99 | % 	xi = x(ii);
100 | % 	sum = sum + xi*sin(sqrt(abs(xi)));
101 | % end
102 | % fitness = 418.9829*d - sum;
103 | 
104 | % SCHAFFER FUNCTION N. 2
105 | % x1 = x(1);
106 | % x2 = x(2);
107 | % fact1 = (sin(x1^2-x2^2))^2 - 0.5;
108 | % fact2 = (1 + 0.001*(x1^2+x2^2))^2;
109 | % 
110 | % fitness = 0.5 + fact1/fact2;
111 | 
112 | % SCHAFFER FUNCTION N. 4
113 | % x1 = x(1);
114 | % x2 = x(2);
115 | % fact1 = cos((sin(abs(x1^2-x2^2))))^2 - 0.5;
116 | % fact2 = (1 + 0.001*(x1^2+x2^2))^2;
117 | % 
118 | % fitness = 0.5 + fact1/fact2;
119 | 
120 | %EASOM FUNCTION
121 | % fitness=-cos(x(1))*cos(x(2))*exp(-((x(1)-pi)^2+(x(2)-pi)^2));
122 | 
123 | end


--------------------------------------------------------------------------------
/SOS/limiter.m:
--------------------------------------------------------------------------------
 1 | function newP=limiter(P,VarHigh,VarLow)
 2 | % LIMITER Function to perfrom range limit operation on the solution
 3 | % to be within the search space bounds
 4 | 
 5 | newP=P;
 6 | 
 7 | for i=1:length(P)
 8 |     if newP(i)>VarHigh(i)
 9 |         newP(i)=VarHigh(i);
10 |     elseif newP(i)<VarLow(i)
11 |         newP(i)=VarLow(i);
12 |     end
13 | end
14 |  
15 | 
16 | end


--------------------------------------------------------------------------------
/WEO/WEO.m:
--------------------------------------------------------------------------------
  1 | %Water Evaporation optimization
  2 | %------------------------------
  3 | 
  4 | clc
  5 | clear
  6 | close all
  7 | 
  8 | % Problem Statement
  9 | Npar = 3;
 10 | VarLow=[-5.12 -5.12 -5.12];
 11 | VarHigh = [5.12 5.12 5.12];
 12 | 
 13 | %initial value
 14 | XBest =  rand(1,Npar).* (VarHigh - VarLow) + VarLow;
 15 | XBestCost = fitnessFunc(XBest);
 16 | GB = XBestCost;
 17 | 
 18 | %algorithm parameters
 19 | iter=100;   %maximum number of iterations
 20 | % step=0.9/iter;
 21 | nWM=100;       %number of water molecules
 22 | tmax=100;     %Maximum number of iterations
 23 | Emax=-0.5;
 24 | Emin=-3.5;
 25 | themin=-50;
 26 | themax=-20;
 27 | 
 28 | %initializations for memory allocation
 29 | molecule=zeros(nWM,Npar);
 30 | Fit=zeros(1,nWM);  
 31 | Esub=zeros(1,nWM);
 32 | MEP=zeros(1,nWM);
 33 | DEP=zeros(1,nWM);
 34 | theta=zeros(1,nWM);
 35 | 
 36 | %Intialization of water molecules
 37 | for ii = 1:nWM
 38 |     molecule(ii,:)= rand(1,Npar).* (VarHigh - VarLow) + VarLow;
 39 |     Fit(ii) = fitnessFunc(molecule(ii,:));
 40 |   
 41 |     if Fit(ii) < XBestCost
 42 |         XBest = molecule(ii,:);
 43 |         XBestCost = Fit(ii);
 44 |     end
 45 | end
 46 | 
 47 | % Main Loop
 48 | for t=1:tmax
 49 |     
 50 |     if t<=(tmax/2)
 51 |       for ii=1:nWM
 52 |        %Monolayer evaporation phase
 53 |        %===========================
 54 |        %calculate substrate energy vector
 55 |        Esub(ii)=((Emax-Emin)*(Fit(ii)-min(Fit(ii)))/(max(Fit)-min(Fit)))+Emin;
 56 |        Esub(ii)=min((max(Emin,Esub(ii))),Emax);
 57 |        
 58 |        %calculate evaporation probability
 59 |        MEP(ii)=(rand<exp(Esub(ii)));
 60 | 
 61 |       end
 62 |     else
 63 |         %Droplet evaporation phase
 64 |         %=========================
 65 |          for ii=1:nWM  
 66 |            %calculate substrate energy vector
 67 |             theta(ii)=((themax-themin)*(Fit(ii)-min(Fit(ii)))/(max(Fit)-min(Fit)))+themin;
 68 |             theta(ii)=min((max(themin,theta(ii))),themax);
 69 |        
 70 |            %calculate evaporation probability          
 71 |             DEP(ii)=(rand<calcJ(theta(ii)));
 72 |              
 73 |          end
 74 |     end
 75 |     
 76 |     %Evaporation of molecules
 77 |     count=0;
 78 |     for ii=1:nWM
 79 |        if t<=(tmax/2)
 80 |           if MEP(ii)==1
 81 |             molecule(ii-count,:)=[];
 82 |             Fit(ii-count)=[];
 83 |             count=count+1;        
 84 |           end
 85 |        else
 86 |            
 87 |            
 88 |        end
 89 |     end
 90 | 
 91 | 
 92 |     %Regeneration of lost water molecules
 93 |     %====================================
 94 |     curr=length(molecule(:,1));  %current water molecules
 95 |     nlost=nWM-curr;
 96 |     for ii=1:nlost
 97 |       for jj=1:Npar
 98 |        i=round(rand*curr +0.5);
 99 |        molecule((curr+ii),jj)=molecule(i,jj);
100 |       end
101 |       
102 |        %new fitness
103 |        Fit(curr+ii)=fitnessFunc(molecule((curr+ii),:));
104 |        
105 |        %Check new fitness better than previous best
106 |         if Fit(curr+ii) < XBestCost
107 |            XBest = molecule(ii,:);
108 |            XBestCost = Fit(curr+ii);
109 |         end
110 |     end
111 |     
112 |     GB=[GB XBestCost];
113 | end
114 | 
115 | t1=cputime;
116 | 
117 | fprintf('The time taken is %3.2f seconds \n',t1-t);
118 | fprintf('The best value is :');
119 | XBest
120 | XBestCost
121 | 
122 | % Convergence Plot
123 | figure(1)
124 | plot(0:tmax,GB, 'linewidth',1.2);
125 | title('Convergence');
126 | xlabel('Iterations');
127 | ylabel('Objective Function (Cost)');
128 | grid('on')


--------------------------------------------------------------------------------
/WEO/calcJ.m:
--------------------------------------------------------------------------------
1 | function J = calcJ(theta)
2 | %CALCJ
3 | theta=deg2rad(theta);  %conversion to radians
4 | 
5 |   J=(1/2.6)*(( (2/3) +((cos(theta))^3)/3  - cos(theta))^(-2/3))*(1-cos(theta));
6 | 
7 | end
8 | 
9 | 


--------------------------------------------------------------------------------
/WEO/fitnessFunc.m:
--------------------------------------------------------------------------------
  1 | function fitness = fitnessFunc(x)
  2 | 
  3 | %Sphere
  4 | % fitness=sum(x(1)^2+x(2)^2+x(3)^2);
  5 | 
  6 | %Booth
  7 | %    fitness=(x(1)+2*x(2)-7)^2 + (2*x(1) + x(2) - 5)^2;
  8 | 
  9 | %Beale's Function
 10 | % fitness=(1.5 -x(1)+x(1)*x(2))^2+(2.25-x(1)+x(1)*x(2)^2)^2+(2.625-x(1)+x(1)*x(2)^3)^2;
 11 | 
 12 | %six hump camel back
 13 | %   fitness=4*x(1)^2 - 2.1*x(1)^4 +(1/3)*x(1)^6 +x(1)*x(2)-4*x(2)^2+4*x(2)^4;
 14 | 
 15 | %Rastrigin
 16 | fitness = x(1)^2 - 10*cos(2*pi*x(1)) + 10;
 17 | fitness= fitness+ x(2)^2 - 10*cos(2*pi*x(2)) + 10;
 18 | fitness= fitness+ x(3)^2 - 10*cos(2*pi*x(3)) + 10;
 19 | 
 20 | %step
 21 | %     fitness=(x(1)+0.5)^2+(x(2)+0.5)^2;
 22 | 
 23 | %Rosenbrock
 24 | %    fitness=100*(x(2)-(x(1)^2))^2+ (x(1)-(x(1)^2))^2;
 25 | 
 26 | %trignometric
 27 | %    fitness=x(1)*sin(4*(x(1)))+1.1*x(2)*sin(2*(x(2)));
 28 | 
 29 | %trignometric 2
 30 | %  fitness=0.5+(sin(sqrtm(x(1)^2+x(2)^2))^2 - 0.5)/(1+0.1*(x(1)^2+x(2)^2));
 31 | 
 32 | %McCormick function
 33 | % fitness=sin(x(1)+x(2))+(x(1)-x(2))^2 -1.5*x(1)+2.5*x(2)+1;
 34 | 
 35 | %Greiwank function
 36 | %  fitness=(1/4000)*((x(1)-100)^2-(cos(x(1)-100)+(x(2)-100)^2-(cos(x(2)-100))));
 37 | 
 38 | %Matyas Function
 39 | % fitness=0.26*(x(1)^2 +x(2)^2)-0.48*x(1)*x(2);
 40 | 
 41 | %Schubert
 42 | %   fitness=((cos(2)+2*cos(3)+3*cos(4)+4*cos(5))*x(1)+1)*((cos(2)+2*cos(3)+3*cos(4)+4*cos(5))*x(2)+1);
 43 | 
 44 | 
 45 | %Quartic
 46 | % fitness=x(1)^4+2*x(2)^4+0.7886*(x(1));
 47 | 
 48 | %Drop wave function
 49 | %   fitness = (-1+cos(12*sqrtm(x(1)^2+x(2)^2)))/(0.5*(x(1)^2+x(2)^2));
 50 | 
 51 | %Cross intray
 52 | % fact1 = sin(x(1))*sin(x(2));
 53 | % fact2 = exp(abs(100 - sqrt(x(1)^2+x(2)^2)/pi));
 54 | % fitness= -0.0001 * (abs(fact1*fact2)+1)^0.1;
 55 | 
 56 | 
 57 | % MICHALEWICZ FUNCTION
 58 | % x(3)=[];
 59 | % d = length(x);
 60 | % sum = 0;
 61 | % for ii = 1:d
 62 | % 	xi = x(ii);
 63 | % 	new = sin(xi) * (sin(ii*xi^2/pi))^(2*10);
 64 | % 	sum  = sum + new;
 65 | % end
 66 | % fitness = -sum;
 67 | 
 68 | %EGGHOLDER FUNCTION
 69 | % x1 = x(1);
 70 | % x2 = x(2);
 71 | % term1 = -(x2+47) * sin(sqrt(abs(x2+x1/2+47)));
 72 | % term2 = -x1 * sin(sqrt(abs(x1-(x2+47))));
 73 | % 
 74 | % fitness = term1 + term2;
 75 | 
 76 | % ACKLEY FUNCTION
 77 | % d = length(x);
 78 | %  a = 20;
 79 | %  b = 0.2;
 80 | %  c = 2*pi;
 81 | % 
 82 | % sum1 = 0;
 83 | % sum2 = 0;
 84 | % for ii = 1:d
 85 | % 	xi = x(ii);
 86 | % 	sum1 = sum1 + xi^2;
 87 | % 	sum2 = sum2 + cos(c*xi);
 88 | % end
 89 | % 
 90 | % term1 = -a * exp(-b*sqrt(sum1/d));
 91 | % term2 = -exp(sum2/d);
 92 | % fitness = term1 + term2 + a + exp(1);
 93 | 
 94 | % SCHWEFEL FUNCTION
 95 | % x(3)=[];
 96 | % d = length(x);
 97 | % sum = 0;
 98 | % for ii = 1:d
 99 | % 	xi = x(ii);
100 | % 	sum = sum + xi*sin(sqrt(abs(xi)));
101 | % end
102 | % fitness = 418.9829*d - sum;
103 | 
104 | % SCHAFFER FUNCTION N. 2
105 | % x1 = x(1);
106 | % x2 = x(2);
107 | % fact1 = (sin(x1^2-x2^2))^2 - 0.5;
108 | % fact2 = (1 + 0.001*(x1^2+x2^2))^2;
109 | % 
110 | % fitness = 0.5 + fact1/fact2;
111 | 
112 | % SCHAFFER FUNCTION N. 4
113 | % x1 = x(1);
114 | % x2 = x(2);
115 | % fact1 = cos((sin(abs(x1^2-x2^2))))^2 - 0.5;
116 | % fact2 = (1 + 0.001*(x1^2+x2^2))^2;
117 | % 
118 | % fitness = 0.5 + fact1/fact2;
119 | 
120 | %EASOM FUNCTION
121 | % fitness=-cos(x(1))*cos(x(2))*exp(-((x(1)-pi)^2+(x(2)-pi)^2));
122 | 
123 | end


--------------------------------------------------------------------------------
/WEO/limiter.m:
--------------------------------------------------------------------------------
 1 | function newP=limiter(P,VarHigh,VarLow)
 2 | % LIMITER Function to perfrom range limit operation on the solution
 3 | % to be within the search space bounds
 4 | 
 5 | newP=P;
 6 | 
 7 | for i=1:length(P)
 8 |     if newP(i)>VarHigh(i)
 9 |         newP(i)=VarHigh(i);
10 |     elseif newP(i)<VarLow(i)
11 |         newP(i)=VarLow(i);
12 |     end
13 | end
14 |  
15 | 
16 | end


--------------------------------------------------------------------------------