bench_funcs.m

Matlab code for Fullyinformed PSO

function f=BENCH_FUNCS(x,func_num)
%Unconstrained problems with random shifting of global optima and random
%rotation of co ordinates. The total of 13 problems are presented
global initial_flag M O Rmin Rmax functchc result_type
persistent fhd 
[ps,D]=size(x);

if initial_flag==0
       %------------------BASIC FUNCTIONS---------------------
        if func_num==1 fhd=str2func('Ackley'); %[-32.768 32.768]
    elseif func_num==2 fhd=str2func('DixonPrice');%[-10 10]  
    elseif func_num==3 fhd=str2func('Griewank'); %[-100 100] or [-600 600]
    elseif func_num==4 fhd=str2func('Levy'); %[-10 10] 
    elseif func_num==5 fhd=str2func('Powell');%[-4 5]
    elseif func_num==6 fhd=str2func('Rastrigin');%[-5.12 5.12] 
    elseif func_num==7 fhd=str2func('Rosenbrock');%[-100 100]
    elseif func_num==8 fhd=str2func('Sphere');%[-5.12 5.12]
    elseif func_num==9 fhd=str2func('SumSquar');%[-10 10]               
    elseif func_num==10 fhd=str2func('Zakharov'); %[-5 10] 
    elseif func_num==11 fhd=str2func('Weierstrass'); %[-0.5 0.5]
    elseif func_num==12 fhd=str2func('Elliptic'); %[-100 100]
    elseif func_num==13 fhd=str2func('Schwefel');  %[-100 100] 
    %------------------ROTATED BASIC FUNCTIONS---------------------        
    elseif func_num==14 fhd=str2func('rAckley'); 
    elseif func_num==15 fhd=str2func('rDixonPrice');  
    elseif func_num==16 fhd=str2func('rGriewank'); 
    elseif func_num==17 fhd=str2func('rLevy');  
    elseif func_num==18 fhd=str2func('rPowell');
    elseif func_num==19 fhd=str2func('rRastrigin'); 
    elseif func_num==20 fhd=str2func('rRosenbrock');
    elseif func_num==21 fhd=str2func('rSumSquar');              
    elseif func_num==22 fhd=str2func('rZakharov'); 
    elseif func_num==23 fhd=str2func('rWeierstrass'); 
    elseif func_num==24 fhd=str2func('rElliptic');
    elseif func_num==25 fhd=str2func('rSchwefel');   
%------------------SHIFTED BASIC FUNCTIONS---------------------  
    elseif func_num==26 fhd=str2func('sAckley'); 
    elseif func_num==27 fhd=str2func('sDixonPrice');  
    elseif func_num==28 fhd=str2func('sGriewank'); 
    elseif func_num==29 fhd=str2func('sLevy');  
    elseif func_num==30 fhd=str2func('sPowell');
    elseif func_num==31 fhd=str2func('sRastrigin'); 
    elseif func_num==32 fhd=str2func('sRosenbrock');
    elseif func_num==33 fhd=str2func('sSphere');
    elseif func_num==34 fhd=str2func('sSumSquar');              
    elseif func_num==35 fhd=str2func('sZakharov'); 
    elseif func_num==36 fhd=str2func('sWeierstrass'); 
    elseif func_num==37 fhd=str2func('sElliptic');
    elseif func_num==38 fhd=str2func('sSchwefel'); 
 %------------------SHIFTED ROTATED BASIC FUNCTIONS---------------------  
    elseif func_num==39 fhd=str2func('srAckley'); 
    elseif func_num==40 fhd=str2func('srDixonPrice');  
    elseif func_num==41 fhd=str2func('srGriewank'); 
    elseif func_num==42 fhd=str2func('srLevy');  
    elseif func_num==43 fhd=str2func('srPowell');
    elseif func_num==44 fhd=str2func('srRastrigin'); 
    elseif func_num==45 fhd=str2func('srRosenbrock');
    elseif func_num==46 fhd=str2func('srSphere');
    elseif func_num==47 fhd=str2func('srSumSquar');              
    elseif func_num==48 fhd=str2func('srZakharov'); 
    elseif func_num==49 fhd=str2func('srWeierstrass'); 
    elseif func_num==50 fhd=str2func('srElliptic');
    elseif func_num==51 fhd=str2func('srSchwefel');        
        end
        Funnction=fhd
end       

       f=feval(fhd,x);
       
       
%------------------BASIC FUNCTIONS---------------------
            %-------Ackley--------
function f=Ackley(x)
global initial_flag M O Rmax Rmin
persistent fhd func_num 
[ps,D]=size(x);
if initial_flag==0 
[Rmax Rmin]=Search_range(func_num);
initial_flag=1;
end

n=D;
 e=exp(1);
 f = (20 + e ...
       -20*exp(-0.2*sqrt((1/n).*sum(x.^2,2))) ...
       -exp((1/n).*sum(cos(2*pi*x),2)));
            %---------------------
            
            %-------DixonPrice ----
function f = DixonPrice(x)
global initial_flag M O Rmax Rmin
persistent fhd func_num 
[ps,D]=size(x);
if initial_flag==0 
[Rmax Rmin]=Search_range(func_num);
initial_flag=1;
end
[ps,D]=size(x);
n = D;s1 = 0;
for j = 2:n;
    s1 = s1+j*(2*x(j)^2-x(j-1))^2;    
end
f = s1+(x(1)-1)^2;
            %---------------------

            %-------Griewank------
function f = Griewank(x)
global initial_flag M O Rmax Rmin
persistent fhd func_num 
[ps,D]=size(x);
if initial_flag==0 
[Rmax Rmin]=Search_range(func_num);
initial_flag=1;
end
    [ps,D]=size(x);
n = D; fr = 4000; s = 0; p = 1;
for j = 1:n; s = s+x(j)^2; end
for j = 1:n; p = p*cos(x(j)/sqrt(j)); end
f = s/fr-p+1;
            %---------------------
            %------- Levy --------
function f = Levy(x)
global initial_flag M O Rmax Rmin
persistent fhd func_num 
[ps,D]=size(x);
if initial_flag==0 
[Rmax Rmin]=Search_range(func_num);
initial_flag=1;
end
    [ps,D]=size(x);
n = D;
for i = 1:n; z(i) = 1+(x(i)-1)/4; end
s = sin(pi*z(1))^2;
for i = 1:n-1
    s = s+(z(i)-1)^2*(1+10*(sin(pi*z(i)+1))^2);
end 
f = s+(z(n)-1)^2*(1+(sin(2*pi*z(n)))^2);
            %----------------------    
            %------ Powell --------
function f = Powell(x)  
global initial_flag M O Rmax Rmin
persistent fhd func_num 
[ps,D]=size(x);
if initial_flag==0 
[Rmax Rmin]=Search_range(func_num);
initial_flag=1;
end
    [ps,D]=size(x);
n = D;
m = D;
for i = 1:m/4
    fvec(4*i-3) = x(4*i-3)+10*(x(4*i-2));
    fvec(4*i-2) = sqrt(5)*(x(4*i-1)-x(4*i));
    fvec(4*i-1) = (x(4*i-2)-2*(x(4*i-1)))^2;
    fvec(4*i)   = sqrt(10)*(x(4*i-3)-x(4*i))^2;
end;
fvec = fvec';
f = norm(fvec)^2;   
        
            %----------------------
            %--------Rastrigin------ 
function f = Rastrigin(x)
global initial_flag M O Rmax Rmin
persistent fhd func_num 
[ps,D]=size(x);
if initial_flag==0 
[Rmax Rmin]=Search_range(func_num);
initial_flag=1;
end
    [ps,D]=size(x);
n = D; s = 0;
for j = 1:n
    s = s+(x(j)^2-10*cos(2*pi*x(j))); 
end
f = 10*n+s;            
            %----------------------
            %--------Rosenbrock -------
function f = Rosenbrock(x)
global initial_flag M O Rmax Rmin
persistent fhd func_num 
[ps,D]=size(x);
if initial_flag==0 
[Rmax Rmin]=Search_range(func_num);
initial_flag=1;
end
    [ps,D]=size(x);
n = D; sum = 0;
for j = 1:n-1;
    sum = sum+100*(x(j)^2-x(j+1))^2+(x(j)-1)^2;
end
f = sum;            
         %--------------------------
            %-------Sphere -----------
function f = Sphere(x)
global initial_flag M O Rmax Rmin
persistent fhd func_num 
[ps,D]=size(x);
if initial_flag==0 
[Rmax Rmin]=Search_range(func_num);
initial_flag=1;
end
    [ps,D]=size(x);
n = D;s = 0;
for j = 1:n
    s = s+x(j)^2; 
end
f = s;            
            %--------------------------
            %----------SumSquar -------
function f = SumSquar(x)
global initial_flag M O Rmax Rmin
persistent fhd func_num 
[ps,D]=size(x);
if initial_flag==0 
[Rmax Rmin]=Search_range(func_num);
initial_flag=1;
end
    [ps,D]=size(x);
n = D;s = 0;
for j = 1:n  
    s=s+j*x(j)^2; 
end
f = s;
            %--------------------------
            %---------- Zakharov -------
function f =Zakharov(x)
global initial_flag M O Rmax Rmin
persistent fhd func_num 
[ps,D]=size(x);
if initial_flag==0 
[Rmax Rmin]=Search_range(func_num);
initial_flag=1;
end
    [ps,D]=size(x);
n = D;s1 = 0;s2 = 0;
for j = 1:n;
    s1 = s1+x(j)^2;
    s2 = s2+0.5*j*x(j);
end
f = s1+s2^2+s2^4;
            %--------------------------
            %------------Weierstrass-----
function [f]=Weierstrass(x)
global initial_flag M O Rmax Rmin
persistent fhd func_num 
[ps,D]=size(x);
if initial_flag==0 
[Rmax Rmin]=Search_range(func_num);
initial_flag=1;
end
    [ps,D]=size(x);
x=x+0.5; a = 0.5; b = 3; kmax = 20;
c1(1:kmax+1) = a.^(0:kmax);
c2(1:kmax+1) = 2*pi*b.^(0:kmax);
f=0;
c=-w(0.5,c1,c2);
for i=1:D
f=f+w(x(:,i)',c1,c2);
end
f=f+c*D;
            %--------------------------
            %---------Elliptic----------
function f=Elliptic(x)
global initial_flag M O Rmax Rmin
persistent fhd func_num 
[ps,D]=size(x);
if initial_flag==0 
[Rmax Rmin]=Search_range(func_num);
initial_flag=1;
end
    [ps,D]=size(x);
a=1e+6;
f=0;
for i=1:D
f=f+a.^((i-1)/(D-1)).*x(:,i).^2;
end            
            %--------------------------
            %--------- Schwefel--------
 function f = Schwefel(x)
global initial_flag M O Rmax Rmin
persistent fhd func_num 
[ps,D]=size(x);
if initial_flag==0 
[Rmax Rmin]=Search_range(func_num);
initial_flag=1;
end
     [ps,D]=size(x);
 n = D;
s = sum(-x.*sin(sqrt(abs(x))));
f = 418.9829*n+s;
            
            %--------------------------
%------------------------------------------------------------------

%-----------------ROTATED BASIC FUNCTIONS---------------------
            %-------Rotated Ackley--------
function f=rAckley(x)
global initial_flag M O Rmax Rmin
persistent fhd func_num 
[ps,D]=size(x);
if initial_flag==0 
[Rmax Rmin]=Search_range(func_num);
M=orthm_generator(D);
initial_flag=1;
end

  y=x;
  x1=M*y.';
  x=x1.';
  n=D;
 e=exp(1);
 f = (20 + e ...
       -20*exp(-0.2*sqrt((1/n).*sum(x.^2,2))) ...
       -exp((1/n).*sum(cos(2*pi*x),2)));
            %---------------------
            
            %-------Rotated DixonPrice ----
function f = rDixonPrice(x)
global initial_flag M O Rmax Rmin
persistent fhd func_num 
[ps,D]=size(x);
if initial_flag==0 
[Rmax Rmin]=Search_range(func_num);
M=orthm_generator(D);
initial_flag=1;
end

  y=x;
  x1=M*y.';
  x=x1.';
n = D;s1 = 0;
for j = 2:n;
    s1 = s1+j*(2*x(j)^2-x(j-1))^2;    
end
f = s1+(x(1)-1)^2;
            %---------------------
            %-------Rotated Griewank------
function f = rGriewank(x)
global initial_flag M O Rmax Rmin
persistent fhd func_num 
[ps,D]=size(x);
if initial_flag==0 
[Rmax Rmin]=Search_range(func_num);
M=orthm_generator(D);
initial_flag=1;
end
  y=x;
  x1=M*y.';
  x=x1.';
n = D; fr = 4000; s = 0; p = 1;
for j = 1:n; s = s+x(j)^2; end
for j = 1:n; p = p*cos(x(j)/sqrt(j)); end
f = s/fr-p+1;
            %---------------------
            %-------Rotated  Levy --------
function f = rLevy(x)
global initial_flag M O Rmax Rmin
persistent fhd func_num 
[ps,D]=size(x);
if initial_flag==0 
[Rmax Rmin]=Search_range(func_num);
M=orthm_generator(D);
initial_flag=1;
end
  y=x;
  x1=M*y.';
  x=x1.';
n = D;
for i = 1:n; z(i) = 1+(x(i)-1)/4; end
s = sin(pi*z(1))^2;
for i = 1:n-1
    s = s+(z(i)-1)^2*(1+10*(sin(pi*z(i)+1))^2);
end 
f = s+(z(n)-1)^2*(1+(sin(2*pi*z(n)))^2);
            %----------------------    
            %------ Rotated Powell --------
function f = rPowell(x)  
global initial_flag M O Rmax Rmin
persistent fhd func_num 
[ps,D]=size(x);
if initial_flag==0 
[Rmax Rmin]=Search_range(func_num);
M=orthm_generator(D);
initial_flag=1;
end

  y=x;
  x1=M*y.';
  x=x1.';
n = D; m = n;
for i = 1:m/4
    fvec(4*i-3) = x(4*i-3)+10*(x(4*i-2));
    fvec(4*i-2) = sqrt(5)*(x(4*i-1)-x(4*i));
    fvec(4*i-1) = (x(4*i-2)-2*(x(4*i-1)))^2;
    fvec(4*i)   = sqrt(10)*(x(4*i-3)-x(4*i))^2;
end;
fvec = fvec';
f = norm(fvec)^2;   

            %----------------------
            %--------Rotated Rastrigin------ 
function f = rRastrigin(x)
global initial_flag M O Rmax Rmin
persistent fhd func_num 
[ps,D]=size(x);
if initial_flag==0 
[Rmax Rmin]=Search_range(func_num);
M=orthm_generator(D);
initial_flag=1;
end
  y=x;
  x1=M*y.';
  x=x1.';
n = D; s = 0;
for j = 1:n
    s = s+(x(j)^2-10*cos(2*pi*x(j))); 
end
f = 10*n+s;            
            %----------------------
            %--------Rotated Rosenbrock -------
function f = rRosenbrock(x)
global initial_flag M O Rmax Rmin
persistent fhd func_num 
[ps,D]=size(x);
if initial_flag==0 
[Rmax Rmin]=Search_range(func_num);
M=orthm_generator(D);
initial_flag=1;
end

  y=x;
  x1=M*y.';
  x=x1.';
n = D; sum = 0;
for j = 1:n-1;
    sum = sum+100*(x(j)^2-x(j+1))^2+(x(j)-1)^2;
end
f = sum;            
         %--------------------------
         %----------Rotated SumSquar -------
function f = rSumSquar(x)
global initial_flag M O Rmax Rmin
persistent fhd func_num 
[ps,D]=size(x);
if initial_flag==0 
[Rmax Rmin]=Search_range(func_num);
M=orthm_generator(D);
initial_flag=1;
end
  y=x;
  x1=M*y.';
  x=x1.';
n = D;s = 0;
for j = 1:n  
    s=s+j*x(j)^2; 
end
f = s;
            %--------------------------
            %----------Rotated  Zakharov -------
function f =rZakharov(x)
global initial_flag M O Rmax Rmin
persistent fhd func_num 
[ps,D]=size(x);
if initial_flag==0 
[Rmax Rmin]=Search_range(func_num);
M=orthm_generator(D);
initial_flag=1;
end
  y=x;
  x1=M*y.';
  x=x1.';
n = D;s1 = 0;s2 = 0;
for j = 1:n;
    s1 = s1+x(j)^2;
    s2 = s2+0.5*j*x(j);
end
f = s1+s2^2+s2^4;
            %--------------------------
            %------------Rotated Weierstrass-----
function [f]=rWeierstrass(x)
global initial_flag M O Rmax Rmin
persistent fhd func_num 
[ps,D]=size(x);
if initial_flag==0 
[Rmax Rmin]=Search_range(func_num);
M=orthm_generator(D);
initial_flag=1;
end
  y=x;
  x1=M*y.';
  x=x1.';
x=x+0.5; a = 0.5; b = 3; kmax = 20;
c1(1:kmax+1) = a.^(0:kmax);
c2(1:kmax+1) = 2*pi*b.^(0:kmax);
f=0;
c=-w(0.5,c1,c2);
for i=1:D
f=f+w(x(:,i)',c1,c2);
end
f=f+c*D;


            %--------------------------
            %---------Rotated Elliptic----------
function f=rElliptic(x)
global initial_flag M O Rmax Rmin
persistent fhd func_num 
[ps,D]=size(x);
if initial_flag==0 
[Rmax Rmin]=Search_range(func_num);
M=orthm_generator(D);
initial_flag=1;
end
  y=x;
  x1=M*y.';
  x=x1.';
a=1e+6;
f=0;
for i=1:D
f=f+a.^((i-1)/(D-1)).*x(:,i).^2;
end            
            %--------------------------
            %--------- Rotated Schwefel--------
 function f = rSchwefel(x)
global initial_flag M O Rmax Rmin
persistent fhd func_num  
[ps,D]=size(x);
if initial_flag==0 
[Rmax Rmin]=Search_range(func_num);
M=orthm_generator(D);
initial_flag=1;
end
  y=x;
  x1=M*y.';
  x=x1.';
 n = D;
s = sum(-x.*sin(sqrt(abs(x))));
f = 418.9829*n+s;
            
            %--------------------------
%------------------------------------------------------------------

%------------------SHIFTED BASIC FUNCTIONS---------------------
            %-------Shifted Ackley--------
function f=sAckley(x)
global initial_flag M O Rmax Rmin
persistent fhd func_num 
[ps,D]=size(x);
if initial_flag==0 
[Rmax Rmin]=Search_range(func_num);
 O=Rmin + 2*Rmax*rand(1,D);
initial_flag=1;
end
x=x-O;
 n=D;
  e=exp(1);
  f = (20 + e ...
        -20*exp(-0.2*sqrt((1/n).*sum(x.^2,2))) ...
        -exp((1/n).*sum(cos(2*pi*x),2)));
             %---------------------
            
            %-------Shifted DixonPrice ----
function f = sDixonPrice(x)
global initial_flag M O Rmax Rmin
persistent fhd func_num