general basic coding

8/13/2019 General Basic Coding

1/37

////// steepest descent method with backtracking line search applied to therastrigin function////

function y=rastrigin(x) // the function tooptimizen=max(size(x));y=n+sum(x.^2-cos(2*%pi*x));endfunction//-----------------------------------------------------function y=rastrigingrad(x) // the gradient of thefunction to optimizey=2*x+2*%pi*sin(2*%pi*x);endfunction//--------------------------------------------------------function z=dotprod(x,y); // computes the dot productof x and y

z=sum(x.*y);endfunction//-----------------------------------------------------function d=descentdirection(f,x,fx,gx); // descent direction:gradientd=-gx;

endfunction//----------------------------------------------------function [xnew,fnew,itback]=backtracking(f,x,fx,gx,d);// line search bybacktracking until Armijo conditiontau=0.3;bet=0.0001;

alphainit=1;alpha=alphainit;xnew=x+alpha*d;fnew=f(xnew);itback=1;while(fnew>fx+bet*alpha*dotprod(gx,d))alpha=tau*alpha;xnew=x+alpha*d;fnew=f(xnew);itback=itback+1;

endendfunction//-------------------------------------------------// main program//disp('steepest descent method for the rastrigin function:');//timer();n=evstr(x_dialog('number of variables of the rastrigin function tominimize','2'));epsilon=1E-5;//xmin=-5*ones(1,n);xmax=5*ones(1,n);u=rand(1,n);x0=xmin+(xmax-xmin).*u;x=x0;fx=rastrigin(x);gx=rastrigingrad(x);itgrad=1;

itfct=1;Xbest=x;Fbest=fx;


2/37

//while (norm(gx)>epsilon)d=descentdirection(rastrigin,x,fx,gx);[x,fx,itback]=backtracking(rastrigin,x,fx,gx,d);Xbest=[Xbest;x];Fbest=[Fbest;fx];

gx=rastrigingrad(x);itgrad=itgrad+1;itfct=itfct+itback;

end//------------------------------------------------------// results display//disp('function evaluation number:');disp(itfct);disp('gradient evaluation number:');disp(itgrad);//disp('minimum obtained:');disp(x);disp('corresponding value by f:');disp(fx);//disp('corresponding value by g:');disp(gx);

//disp('computational time:');disp(timer());//// case of the rastrigin function with 2 parameters (trajectory display)------//if (n==2)xmin=-5.12;xmax=5.12;N=300;xplot=xmin:((xmax-xmin)/(N-1)):xmax;yplot=xplot;zplot=zeros(N,N);for i=1:Nfor j=1:Nzplot(i,j)=rastrigin([xplot(i),yplot(j)]);endendxset('window',0)clf()plot2d(Xbest(:,1),Xbest(:,2),rect=[-5.12,-5.12,5.12,5.12]);contour2d(xplot,yplot,zplot,[0:0.01:0.1,0.2:1,1:10]);xtitle('trajectory display');xset('window',1)clf()plot2d(Xbest(:,1),Xbest(:,2),rect=[x(1)-0.1,x(2)-0.1,x(1)+0.1,x(2)+0.1]);contour2d(xplot,yplot,zplot,[fx:0.1:(fx+1)]);xtitle('trajectory display');end


3/37

////------------------------------------------------------// BFGS for Rastrigindisp('BFGS for Rastrigin');////-----------------------------------------------------

//function y=rastrigin(x) // the function to optimizen=max(size(x));y=n+sum(x.^2-cos(2*%pi*x));endfunction//-----------------------------------------------------function y=rastrigingrad(x) // the gradient of the function to optimizey=2*x+2*%pi*sin(2*%pi*x);endfunction//--------------------------------------------------------function z=dotprod(x,y); // computes the dot product of x and yz=sum(x.*y);endfunction

//-----------------------------------------------------function [d,gx]=descentdirection(Bk,gx); // descent direction: gradientd=linsolve(Bk,gx);endfunction//----------------------------------------------------function [xnew,fnew,itback]=backtracking(f,x,fx,gx,d);// line search bybacktracking until Armijo conditiontau=0.3;bet=0.0001;alphainit=1;alpha=alphainit;xnew=x+alpha*d;fnew=f(xnew);itback=1;while(fnew>fx+bet*alpha*dotprod(gx,d))alpha=tau*alpha;xnew=x+alpha*d;fnew=f(xnew);itback=itback+1;

endendfunction//-------------------------------------------------// main program//timer();n=2;epsilon=1E-5;//xmin=-5*ones(1,n);xmax=5*ones(1,n);u=rand(1,n);x0=xmin+(xmax-xmin).*u;x=x0;fx=rastrigin(x);gx=rastrigingrad(x);itgrad=1;itfct=1;Xbest=x;Fbest=fx;Bk=eye(n,n);//while (norm(gx)>epsilon)x0=x;gx0=gx;d=descentdirection(Bk,gx');

[x,fx,itback]=backtracking(rastrigin,x,fx,gx,d');// disp('backtracking number');disp(itback);


4/37

Xbest=[Xbest;x];Fbest=[Fbest;fx];gx=rastrigingrad(x);itgrad=itgrad+1;itfct=itfct+itback;yk=gx'-gx0';sk=x'-x0';

Bk=Bk+(yk*yk')/dotprod(sk,yk)-(Bk*sk*sk'*Bk)/dotprod(sk,Bk*sk);// disp(mini(spec(Bk)));end//------------------------------------------------------// results display//disp('function evaluation number:');disp(itfct);disp('gradient evaluation number:');disp(itgrad);//disp('minimum obtained:');disp(x);disp('corresponding value by f:');disp(fx);//disp('computational time:');disp(timer());//

// case of the rastrigin function with 2 parameters (n=2)------if (n==2)xmin=-5.12;xmax=5.12;N=300;xplot=xmin:((xmax-xmin)/(N-1)):xmax;yplot=xplot;zplot=zeros(N,N);for i=1:Nfor j=1:Nzplot(i,j)=rastrigin([xplot(i),yplot(j)]);endendxset('window',0)clf()plot2d(Xbest(:,1),Xbest(:,2),rect=[-5.12,-5.12,5.12,5.12]);contour2d(xplot,yplot,zplot,[0:0.01:0.1,0.2:1,1:10]);xset('window',1)clf()plot2d(Xbest(:,1),Xbest(:,2),rect=[x(1)-0.1,x(2)-0.1,x(1)+0.1,x(2)+0.1]);contour2d(xplot,yplot,zplot,[fx:0.1:(fx+1)]);end


5/37

//// Methode d'optimisation sans gradient//// Methode Nelder Mead//----------------------------------------// definition de la fonction minimiser

////deff('y=f(x)','y=sum(x.*x)'); // fonction quadratiquedeff('y=f(x)','y=sum(x.*x-cos(2*%pi*x))+n'); // fonction de Rastrigin////// un cas qui ne marche pas pour Nelder Mead (Mac Kinnon)//deff('y=f(x)','if x(1)


6/37

fr=f(xr);fnew=fr;Neval=Neval+1;// cas 1if (X(1,n+1)


7/37

// Methode d'optimisation sans gradient//// Mthode MDS//----------------------------------------// definition de la fonction minimiser//

//deff('y=f(x)','y=sum(x.*x)'); // fonction quadratiquedeff('y=f(x)','y=sum(x.*x-cos(2*%pi*x))+n'); // fonction de Rastrigin//n=evstr(x_dialog('nombre de parametres (contours si n=2)','2'));Nit=evstr(x_dialog('nombre d''iterations','100'));//xmin=-5;xmax=5;//function Y=evalsimplexe(X)[n1,n2]=size(X);Y=X;for i=2:n1Y(i,n2)=f(X(i,1:n2-1));

end[a,b]=gsort(-Y(:,n2));Y=Y(b,:);

endfunction//// trac des lignes de niveau//if (n==2)N=300;xplot=xmin:((xmax-xmin)/(N-1)):xmax;yplot=xplot;zplot=zeros(N,N);for i=1:Nfor j=1:Nzplot(i,j)=f([xplot(i),yplot(j)]);endendxset('window',0)clf()contour2d(xplot,yplot,zplot,20);end//// creation du premier simplexe//X=xmin+(xmax-xmin)*rand(n+1,n+1);//// evaluation du premier simplexefor i=1:n+1

X(i,n+1)=f(X(i,1:n))end

Neval=n+1;//// debut boucle principalefor k=1:Nit// ordonnement du simplexe[a,b]=gsort(-X(:,n+1));X=X(b,:);//Xr=X;Xr(2:n+1,1:n)=2*ones(n,1)*X(1,1:n)-X(2:n+1,1:n);

//Xr=evalsimplexe(Xr);


8/37

//if (Xr(1,n+1)


9/37

// Methode d'optimisation sans gradient//// Methode de recuit simule//----------------------------------------// definition de la fonction minimiser//

function y=f(x) // the function to optimizen=prod(size(x));y=n+sum(x.^2-cos(2*%pi*x));endfunction///////////////////////////////////////////////////////////////////n=evstr(x_dialog('nombre de parametres de Rastrigin','2'));Nmax=evstr(x_dialog('nombre maximal d''valuations','2000'));//disp('Niter Temperature sigma');u=rand(1,n);xmin=-5*ones(1,n);

xmax=5*ones(1,n);x0=xmin+(xmax-xmin).*u; // random initialisationNeval=[];Fbest=[];y0 = f(x0);x = x0; y = y0; alpha = 0.92; T = 1; s = 0.2;icount=1;Neval=[];Fbest=[];for k = 1 : 20

T = alpha * T;accept = 0;for l = 1 : Nmax/20

x1 = x0 + s*(0.5*ones(x0) - rand (x0)); // uniform// x1= x0+s*rand(x0,'normal'); // gaussian

y1 = f(x1);icount=icount+1;dy = y1 - y0;if rand() < exp (- dy / T) then

x0 = x1; y0 = y1; accept = accept + 1;if y0 < y then x = x0; y = y0; end

endNeval=[Neval;icount];Fbest=[Fbest;f(x0)];endif accept < 25/100*Nmax/20 then s = s / 2; endif accept > 75/100*Nmax/20 then s = 2 * s; enddisp([icount,T,s]);x0 = x; y0 = y;

end////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////disp('minimum obtained after SA:');disp(x);disp('corresponding value by f:');disp(y);disp('function evaluation number by SA:');disp(Neval($));xset('window',0)clf();plot2d(Neval,Fbest)///////////////////////////////////////////////////////////////


10/37

////------------------------------------------------------// real valued genetic algorithm// for the minimization of the rastrigin function// (with dynamic display for the case of 2 parameters)//

//-----------------------------------------------------// selection: proportionate with ranking method// crossover: blend// mutation: non uniform// 1-elitism//function y=rastrigin(x,n) // the function to optimizey=n+sum(x.^2-cos(2*%pi*x));endfunction//function evalpop=evaluation(X); // evaluation of the whole population[Npop,n]=size(X);n=n-1;evalpop=zeros(Npop,1);

for i=1:Npop;evalpop(i)=rastrigin(X(i,1:n),n);endendfunction//function [Xpar,bestpar]=evalplus1elitism(Xpar,Xoldpar,Npop,gen) //evaluation plus 1-elitismval=evaluation(Xpar);Xpar(:,n+1)=val;[minval,index]=min(Xoldpar(:,n+1));bestpar=Xoldpar(index(1),:);[minval,index]=min(val);bestnewpop=Xpar(index(1),:);if (bestnewpop($)>bestpar($))&(gen>1) then

nrand=int(Npop*rand())+1;Xpar(nrand,:)=bestpar;

elsebestpar=bestnewpop;

endendfunction//function Xsel=rankselect(X) // ranking selectionXsel=X;[Npop,n]=size(X);n=n-1;[Fsort,ind]=gsort(X(:,n+1));X=X(ind,:);p=1:Npop;roulette=cumsum(p)/sum(p);for i=1:Npop;u=rand();index=find(roulette


11/37

endfunction//function xoff=mutate(xpar,ngen,Ngen,xmin,xmax) // non uniform mutation[np,n]=size(xpar);n=n-1;b=5;xoff=xpar;

for i=1:nu1=rand();u2=rand();if (u1


12/37

xpar=[Xpar(u1,:);Xpar(u2,:)];Xoff(i:(i+1),:)=xpar;if (u3


13/37

////------------------------------------------------------//disp('ES with CSA adaptation for Rastrigin');////-----------------------------------------------------

function y=rastrigin(x) // the function to optimizen=prod(size(x));y=n+sum(x.^2-cos(2*%pi*x));endfunction////-----------------------------------------------------function Xpar=evaluation(X); // evaluation of the whole populationXpar=X;[Npo,n]=size(X);n=n-1;evalpop=zeros(Npo,1);for i=1:Npo;evalpop(i)=rastrigin(X(i,1:n));

end

Xpar(:,n+1)=evalpop;endfunction////-----------------------------------------------------function [Xparnew,Wnew]=selection(Xpar,Xoff,W);[mu,n]=size(Xpar);[lambda,n]=size(Xoff);n=n-1;Xtot=Xoff; // selection comma[Fsort,ind]=gsort(-Xtot(:,n+1));indbest=ind(1:mu);Xparnew=Xtot(indbest,:);Wnew=W(indbest,:);endfunction////-----------------------------------------------------//-----------------------------------------------------//---------main program -------------------------------//disp('real valued ES for minimizing black box function');//n=evstr(x_dialog('parameter number of the rastrigin function','15'));mu=evstr(x_dialog('parent number','20'));lambda=evstr(x_dialog('offspring number','200'));Ngen=evstr(x_dialog('generation number','100'));//siginit=1; // initial mutation strength//// ------- parameters for CSA adaptation-------------c=1/sqrt(n);chiN=sqrt(n)*(1-1/(4*n)+1/(21*n^2));D=sqrt(n);//// ----------------------------------------------------//xmin=-5.*ones(1,n);xmax=5.*ones(1,n);Xmin=ones(mu,1)*xmin;Xmax=ones(mu,1)*xmax;u=rand(mu,n);

pop=Xmin+(Xmax-Xmin).*u; // random initialisation of the populationXpar=[pop,rand(mu,1)]; Xoldpar=Xpar;


14/37

Xoff=Xpar;min=[];Ntot=[];mineval=0;newval=zeros(mu,1);itfct=0;fmin=[];////-----------------------------------------------------//-----------------------------------------------------//

sigma=siginit;V=zeros(1,n);Xpar=evaluation(Xpar);Y=1/mu*sum(Xpar(:,1:n),1);Nevalf=mu;//// ---- MAIN LOOP : BEGINNING---------------------------//------------------------------------------------------//for gen=1:(Ngen-1)//Woff=[];for i=1:lambda

w=sigma*rand(1,n,'normal'); // mutationWoff=[Woff;w];xoff=Y+w;Xoff(i,1:n)=xoff;

end//Xoff=evaluation(Xoff); // evaluationNevalf=Nevalf+lambda;//[Xpar,Wpar]=selection(Xpar,Xoff,Woff); // selection//fmin=[fmin,Xpar(1,$)];bestpar=Xpar(1,1:n);Ntot=[Ntot,Nevalf];//// --- adaptativity of sigma-----------------//Z=1/mu*sum(Wpar,1);Y=Y+Z;V=(1-c)*V+sqrt(c*(2-c))*sqrt(mu)/sigma*Z;sigma=sigma*exp((norm(V)-chiN)/(D*chiN));//// MAIN LOOP : ENDING//end//-----------------------------------------------------//-----------------------------------------------------////xset('window',0);clf();plot2d(Ntot,fmin);disp('minimum obtained:');disp(bestpar(1:n));disp('corresponding value by f:');disp(fmin($));disp('evaluation number:');disp(Nevalf);//


15/37

////------------------------------------------------------//// Evolution Strategy// for the minimization of the rastrigin function//

//-----------------------------------------------------//function y=rastrigin(x) // the function to optimizen=prod(size(x));y=n+sum(x.^2-cos(2*%pi*x));endfunction////-----------------------------------------------------function Xpar=evaluation(X); // evaluation of the whole populationXpar=X;[Npo,n]=size(X);n=n-1;evalpop=zeros(Npo,1);for i=1:Npo;

evalpop(i)=rastrigin(X(i,1:n));endXpar(:,n+1)=evalpop;endfunction////-----------------------------------------------------function Xparnew=selection(Xpar,Xoff); // selection plus or comma[mu,n]=size(Xpar);[lambda,n]=size(Xoff);n=n-1;Xtot=[Xpar;Xoff]; // plus selection//Xtot=[Xoff]; // comma selection[Fsort,ind]=gsort(-Xtot(:,n+1));Xtot=Xtot(ind,:);Xparnew=Xtot(1:mu,:);endfunction////-----------------------------------------------------//function xoff=mutate(xpar,sigma) // normal mutation[np,n]=size(xpar);n=n-1;xoff=xpar;u=rand(1,n,'n');xoff(1,1:n)=xpar(1,1:n)+sigma*u;endfunction////-----------------------------------------------------//-----------------------------------------------------//---------main program -------------------------------//disp('real valued ES for minimizing black box function');//// ----------------------------------------------------//n=evstr(x_dialog('parameter number of the rastrigin function','2'));mu=evstr(x_dialog('parent number','5'));lambda=evstr(x_dialog('offspring number','50'));Ngen=evstr(x_dialog('generation number','20'));//siginit=1; // initial mutation strengthalpha=1.25; // 1/5 rule coefficient

//// ----------------------------------------------------


16/37

//xmin=-5.*ones(1,n);xmax=5.*ones(1,n);Xmin=ones(mu,1)*xmin;Xmax=ones(mu,1)*xmax;u=rand(mu,n);

pop=Xmin+(Xmax-Xmin).*u; // random initialisation of the populationXpar=[pop,rand(mu,1)]; Xoldpar=Xpar;Xoff=Xpar;min=[];Ntot=[];mineval=0;newval=zeros(mu,1);itfct=0;fmin=[];////-----------------------------------------------------//-----------------------------------------------------//sigma=siginit;Xpar=evaluation(Xpar);Nevalf=mu;//// MAIN LOOP : BEGINNING

////for gen=1:(Ngen-1)//xcros=1/lambda*sum(Xpar,'r'); // parent crossover//for i=1:lambdau=int(mu*rand())+1;xpar=Xpar(u,:);xoff=mutate(xcros,sigma); // parent crossover+mutation

// xoff=mutate(xpar,sigma); // parent mutation, no crossoverXoff(i,:)=xoff;

end//oldval=Xoff(:,$);Xoff=evaluation(Xoff); // offspring evaluationNevalf=Nevalf+lambda;//newval=Xoff(:,$);ind=find(oldval>newval);taux=length(ind)/lambda;//// --- adaptativity of sigma-----------------//if (taux


17/37

plot2d(Ntot,fmin)xtitle('convergence history','Neval','fmin');//disp('minimum obtained:');disp(bestpar(1:n));disp('corresponding value by f:');disp(fmin($));disp('evaluation number:');disp(Nevalf);

//


18/37


19/37

// new value of xPSO(:,1:n)=PSO(:,1:n)+PSO(:,(n+1:2*n));

////----- dyanmic display if n=2 ----------------------------

if (n==2) thenxset('window',2);

drawlaterclf()Traj=[Traj;pg(1),pg(2)];contour2d(x,y,z,[0:0.01:0.1,0.2:1,1:10],rect=[-5.12,-5.12,5.12,5.12]);plot2d(PSO(:,1),PSO(:,2),-1,rect=[-5.12,-5.12,5.12,5.12]);plot2d(Traj(:,1),Traj(:,2),5,rect=[-5.12,-5.12,5.12,5.12]);xtitle('trajectory display');drawnowxset('window',3);drawlaterclf()contour2d(x,y,z,[0:0.01:0.1,0.2:1,1:10],rect=[-0.5,-0.5,0.5,0.5]);plot2d(PSO(:,1),PSO(:,2),-1,rect=[-0.5,-0.5,0.5,0.5]);

plot2d(Traj(:,1),Traj(:,2),5,rect=[-0.5,-0.5,0.5,0.5]);xtitle('trajectory display');drawnowend

//endxset('window',1)clf()disp('best elemet found:');disp(pg(1:n))plot2d(Npop*(1:Ngen),pgval)


20/37

//// multi objective optimization// NSGA method without sharing// comparaison of the exact and computed Pareto front on a simple example.//function Xp=paretoplot(Pop,MOpop)

// divide the population with values MOpop by J1 and J2 into differentfront[Npop,b]=size(Pop);Xp=[];JXp=[];ind=(1:Npop);count=1;while(length(ind)>0)Nfront=[];for i=ind;l=find(MOpop(ind,1)


21/37

MOpop=[];for i=1:Npop[J1,J2]=MO(A(i,1:L));MOpop=[MOpop;[J1,J2]];endA=paretoplot(A(:,1:L),MOpop+1E-10*rand(Npop,2));

////// selection// 1st step: gsort elements[s,p]=gsort(A(:,L+1));A=A(p,:);val=[val,A(Npop,L+1)];bestelem=A(Npop,:);oldbestval=A(Npop,L+1);//// 2st step: choose Npop elements with probability pi//Asel=[];

p=(1:Npop)/sum(1:Npop);ps=cumsum(p);for i=1:Npopu=rand();isel=1;while (u>ps(isel))

isel=isel+1;end

Asel=[Asel;A(isel,:)];end// barycentric crossoverAcrois=[];

for k=1:Npop/2u1=int(Npop*rand()+1);u2=int(Npop*rand()+1);if (rand()


22/37

//// Genetic Algorithm with an approximated evaluation principle// Only a decreasing percent of the population is evaluated exactly// The approximation is build with a local RBF interpolation//

function y=exactfunction(x) // the function to optimizen=length(x);y=n+sum(x.^2-cos(2*%pi*x)); // Rastriginendfunction////----------------------------------------------------------------//function y=approxfunction(x,Xexact,A,b) // the approximated function byRBF interpolation[N1,N2]=size(Xexact);n=N2-1;u=linsolve(A,-b);y=0;for i=1:N1

y=y+u(i)*phi(x-Xexact(i,1:n))endendfunction////----------------------------------------------------------------//function y=phi(x) // RBF functiony=norm(x)endfunction////----------------------------------------------------------------//function [A,b]=construct(Xexact) // construction of the matrix forinterpolation//[N1,N2]=size(Xexact);n=N2-1;A=zeros(N1,N1);b=zeros(N1,1);for i=1:N1for j=1:N1A(i,j)=phi(Xexact(i,1:n)-Xexact(j,1:n));

endb(i)=Xexact(i,n+1);

endendfunction////---------------------------------------------------------------------function Xexactsel=selection(x,Xexact,Nsize) // selection of the centersfor interpolation//[N1,N2]=size(Xexact);n=N2-1;normx=[];for i=1:N1normx(i)=norm(x-Xexact(i,1:n))

end[x1,x2]=gsort(-normx);Xexactsel=Xexact(x2(1:Nsize),:)endfunction//----------------------------------------------------------------function evalpop=evaluation(X); // exact evaluation of thewhole population[Npop,N2]=size(X);n=N2-1;

evalpop=zeros(Npop,1);for i=1:Npop;


23/37

evalpop(i)=exactfunction(X(i,1:n));endendfunction////----------------------------------------------------------------//

function evalpop=evaluationapprox(X,Xexact,Nsize); // approximatedevaluation of the whole population[Npop,N2]=size(X);n=N2-1;evalpop=zeros(Npop,1);for i=1:Npop;Xexactsel=selection(X(i,1:n),Xexact,Nsize);[A,b]=construct(Xexactsel);evalpop(i)=approxfunction(X(i,1:n),Xexactsel,A,b);

endendfunction////------------------------------------------------------------------//

function [Xpar,bestpar]=elitism(Xnew,Xpar,Xtot,Npop,gen) // Elitism[minval,index]=min(Xtot(:,n+1));bestpar=Xtot(index(1),:);[minval,index]=min(Xnew(:,n+1));bestnewpop=Xnew(index(1),:);if (bestnewpop($)>bestpar($))&(gen>1) then


elsebestpar=bestnewpop;

endendfunction////--------------------------------------------------------------//function Xsel=rankselect(X) // ranking selectionXsel=X;[Npop,n]=size(X);n=n-1;[Fgsort,ind]=gsort(X(:,n+1));X=X(ind,:);p=1:Npop;roulette=cumsum(p)/sum(p);for i=1:Npop;u=rand();index=find(roulette


24/37

function xoff=mutate(xpar,ngen,Ngen,xmin,xmax) // non uniformmutation[np,n]=size(xpar);n=n-1;b=5;xoff=xpar;for i=1:n

u1=rand();u2=rand();if (u1


25/37

//----------------------------------------------------------------------------------------------if (gen


26/37

Nexact=[Nexact,Nexact($)+length(u)];end[Xpar,bestpar]=elitism(Xnew,Xpar,Xtot,Npop,gen);//fmin=[fmin,bestpar($)];save('session.sav');

//----------- results displays --------------

xset('window',0);plot2d(Nexact,fmin,3);xtitle('convergence history','Neval','fmin');xset('window',1);plot2d1('onl',Nexact,fmin,3);xtitle('convergence history (log scale)','Neval','fmin');//disp('minimum obtained:');disp(bestpar(1:n));disp('corresponding value by f:');disp(bestpar($));disp('evaluation number:');disp(Nexact($));

/////////////////////////////// VERSION AVEC INTERFACE UNIX//////-----------------------------------------------------//function writedata(str0)// unix('rm -f data_heart');// fddata=file('open','data_heart','unknown')// write(fddata,str0);// write(fddata,'[ensight]');// write(fddata,'start = 0');// write(fddata,'verbose = 4');// write(fddata,'#multimesh = 1');// file('close',fddata);//endfunction///////////////////////////////////////////////////////////////////////////////////////////////////////////////////function y=exactfunctionbis(X)//z1=X(1);//theta1=X(2);//r1=aiL*sqrt(1-(z1/ciL)**2);//x1=r1*cos(theta1);//y1=r1*sin(theta1);// tx=[t1 t2 t3 f1 f1 f2 x1 x2 x3];// ty=[t1 t2 t3 f1 f1 f2 y1 y2 y3];// tz=[t1 t2 t3 f1 f1 f2 z1 z2 z3];// ts=[ti1 ti2 ti3 tf1 tf2 tf3 s1 s2 s3];//str0=ts + a + string(tx) + e + string(ty) + e + string(tz) + a;//writedata(str0);//////str2='/afs/inria.fr/rocq/home/reo/ldumas/lifevREO-opt/testsuite/test_bidomain_Schaf/test_bidomain_Schaf -f data_heart >output';//////unix('rm -f time_dep');//unix('rm -f time_temp');//unix('rm -f output');//unix(str2);

//////y=read('time_temp',1,1);


27/37

//////////endfunction////

////------------------------------------------------------

// hybrid method (GA + steepest descent) for Rastrigindisp('hybrid method (GA + SD) for Rastrigin');//////-----------------------------------------------------//clear();//

function y=rastrigin(x) // the function to optimizen=prod(size(x));//y=n+sum(x.^2-cos(2*%pi*x));y=sum(x.^2-10*cos(2*%pi*x)+10);//y=n+exp(1)-n*exp(-0.2*sqrt(1/n*sum(x.^2)))-exp(1/n*sum(cos(2*%pi*x)));endfunction////-----------------------------------------------------function y=rastrigingrad(x) // the gradient of thefunction to optimize//y=2*x+2*%pi*sin(2*%pi*x);y=2*x+10*2*%pi*sin(2*%pi*x);//n=prod(size(x));//y1=-n*exp(-0.2*sqrt(1/n*sum(x.^2)))*((-0.2)*1/n*2*x)/(2*(sqrt(1/n*sum(x.^2))));//y2=-exp(1/n*sum(cos(2*%pi*x)))*1/n*(-2*%pi*sin(2*%pi*x));//y=y1+y2;endfunction////-----------------------------------------------------////-----------------------------------------------------function evalpop=evaluation(X); // evaluation of the whole population[Npop,n]=size(X);n=n-1;evalpop=zeros(Npop,1);for i=1:Npop;evalpop(i)=rastrigin(X(i,1:n));

endendfunction////-----------------------------------------------------function [bestpar,bestval]=thebest(Xtot);

[mu,n]=size(Xtot);n=n-1;[Fsort,indice]=sort(-Xtot(:,n+1));


28/37

bestpar=Xtot(indice(1),1:n);bestval=Xtot(indice(1),n+1);endfunction////-----------------------------------------------------//

//function [Xpar,bestpar]=evalplus1elitism(Xpar,Xoldpar,Npop,gen) //evaluation plus 1-elitismval=evaluation(Xpar);Xpar(:,n+1)=val;[minval,index]=min(Xoldpar(:,n+1));bestpar=Xoldpar(index(1),:);[minval,index]=min(val);bestnewpop=Xpar(index(1),:);if (bestnewpop($)>bestpar($))&(gen>1) then


else

bestpar=bestnewpop;endendfunction////-----------------------------------------------------//function Xsel=rankselect(X) // ranking selectionXsel=X;[Npop,n]=size(X);n=n-1;[Fsort,ind]=sort(X(:,n+1));X=X(ind,:);p=1:Npop;roulette=cumsum(p)/sum(p);for i=1:Npop;u=rand();index=find(roulette


29/37

xoff(1,i)=xpar(1,i)-(xpar(i)-xmin(i))*u2*(1-(ngen-1)/Ngen)^b;end;

end;endfunction////-----------------------------------------------------

function z=dotprod(x,y); // computes the dot productof x and yz=sum(x.*y);endfunction//-----------------------------------------------------function d=descentdirection(f,x,fx,gx); // descent direction:gradientd=-gx;endfunction//----------------------------------------------------function [xnew,fnew,itback]=backtracking(f,x,fx,gx,d,tau,bet,alphainit);//line search by backtracking until Armijo conditionalpha=alphainit;xnew=x+alpha*d;

fnew=f(xnew);itback=1;while(fnew>fx+bet*alpha*dotprod(gx,d))alpha=tau*alpha;xnew=x+alpha*d;fnew=f(xnew);itback=itback+1;

endendfunction//-------------------------------------------------// // steepest descent methodwith Armijo conditionfunction[xbest,fbest,itfct,itgrad]=steepest(x,fx,epsilongrad,itermax,deltagain,tau,bet,alphainit)itgrad=0;itfct=0;gx=rastrigingrad(x);itgrad=itgrad+1;//delta=1;while (norm(gx)>epsilongrad)&(delta>0)&(itgrad


30/37

while inon==1;inon=0;for i=1:Nclustindex=find(Xparclust(:,$)==i);if (length(index)>0) thenbari(i,:)=1/length(index)*sum(Xparclust(index,1:n),'r');

endendfor i=1:Npopdist0= norm(Xparclust(i,1:n)-bari(Xparclust(i,$),:));for j=1:Nclust

dist(j)=norm(Xparclust(i,1:n)-bari(j,:));if dist(j)0) thenXclust(i,:)=Xpar(index(indic(1)),:);

endNumb(i)=length(index);end

for i=1:Nclustfor j=1:Nclust

Matr(i,j)=norm(bari(i,:)-bari(j,:));end

endendfunction//////-------------------------------------------dynamic results displays

//function result(Ntot,fmin,co)nl=length(Ntot);if (nl>1) thenxset('window',0);plot2d([Ntot($-1),Ntot($)],[fmin($-1),fmin($)],co);xtitle('convergence history','Neval','fmin');endendfunction////-----------------------------------------------------//-----------------------------------------------------//---------main program -------------------------------//xset('window',0);// ----------------------------------------------------//n=6; // number of variables of the optimizationproblemNpop=40; //parent number//Ngen=80;

pc=0.9;pm=0.6;


31/37

Nevalfmax=4000;Nclustmax=4; // maximal cluster numberitgradmax=10; // maximal steepest descent iterationvalmin=3; // minimal number of consecutive GAiterationsCVRlim=1; // coefficient of variation of the

population threshold////epsilongrad=1E-10; // stopping criterion for gradient valuetau=0.3; // backtraking coefficientbet=1E-4; // Armijo coefficientalphainit=0.1; // first step length of steepest descent//// ----------------------------------------------------//xmin=-5.*ones(1,n);xmax=5.*ones(1,n);Xmin=ones(Npop,1)*xmin;

Xmax=ones(Npop,1)*xmax;u=rand(Npop,n);pop=Xmin+(Xmax-Xmin).*u; // random initialisation of the populationXpar=[pop,rand(Npop,1)]; Xoldpar=Xpar;Xoff=Xpar;Ntot=[];mineval=0;newval=zeros(Npop,1);itfct=0;fmin=[];CVold=1;valgen=1;Nevalg=0;Nevalf=0;gen=0;//Nclust=Nclustmax;//----------------------------------------------------------// MAIN LOOP : BEGINNING////while(NevalfCVRlim)&(Nclust>0)&(gen-valgen>valmin) then

newmean=mean(Xpar(:,$));Nnew=Nevalf;deltagain=(oldmean-newmean)/(Nnew-Nold);oldmean=newmean;Nold=Nnew;

//

[Xclust,ind,Matr,Numb]=clustering(Xpar,Nclust);Xoffnew=[];


32/37

for i=1:Nclustif (Numb(i)>0) then

[xnew,fnew,itfct,itgrad]=steepest(Xclust(i,1:n),Xclust(i,$),epsilongrad,itgradmax,deltagain,tau,bet,alphainit);

Nevalf=Nevalf+itfct+itgrad*n;

Nevalg=Nevalg+itgrad;Xpar(ind(i),:)=[xnew,fnew];Xoffnew=[Xoffnew;xnew,fnew];

endend[bestpar,bestval]=thebest(Xoffnew); // selection

lambda+mufmin=[fmin,bestval];Ntot=[Ntot,Nevalf];result(Ntot,fmin,2); // dynamic result displayvalgen=gen;

end//

//--------------------------------------------------------------------------//Xoldpar=Xpar;Xpar=rankselect(Xpar); // rank selectionfor i=1:2:(Npop-1)u1=int(Npop*rand())+1;u2=int(Npop*rand())+1;u3=rand();xpar=[Xpar(u1,:);Xpar(u2,:)];Xoff(i:(i+1),:)=xpar;if (u3


33/37

////------------------------------------------------------// hybrid method (ES + steepest descent) for Rastrigindisp('hybrid method (ES + SD) for Rastrigin');////

//-----------------------------------------------------clear();//function y=rastrigin(x) // the function to optimizen=prod(size(x));y=n+sum(x.^2-cos(2*%pi*x));endfunction////-----------------------------------------------------function y=rastrigingrad(x) // the gradient of thefunction to optimizey=2*x+2*%pi*sin(2*%pi*x);endfunction

////-----------------------------------------------------////-----------------------------------------------------function Xpar=evaluation(X); // evaluation of the whole populationXpar=X;[Npo,n]=size(X);n=n-1;evalpop=zeros(Npo,1);for i=1:Npo;evalpop(i)=rastrigin(X(i,1:n));

endXpar(:,n+1)=evalpop;endfunction////-----------------------------------------------------function Xparnew=selection(Xpar,Xoff);[mu,n]=size(Xpar);[lambda,n]=size(Xoff);n=n-1;Xtot=[Xpar;Xoff];[Fsort,ind]=sort(-Xtot(:,n+1));Xtot=Xtot(ind,:);Xparnew=Xtot(1:mu,:);endfunction////-----------------------------------------------------//function xoff=mutate(xpar,sigma) // normal mutation[np,n]=size(xpar);n=n-1;xoff=xpar;u=rand(1,n,'n');xoff(1,1:n)=xpar(1,1:n)+sigma*u;endfunction////-----------------------------------------------------function z=dotprod(x,y); // computes the dot productof x and yz=sum(x.*y);endfunction//-----------------------------------------------------function d=descentdirection(f,x,fx,gx); // descent direction:

gradientd=-gx;


34/37

endfunction//----------------------------------------------------function [xnew,fnew,itback]=backtracking(f,x,fx,gx,d,tau,bet,alphainit);//line search by backtracking until Armijo conditionalpha=alphainit;xnew=x+alpha*d;fnew=f(xnew);

itback=1;while(fnew>fx+bet*alpha*dotprod(gx,d))alpha=tau*alpha;xnew=x+alpha*d;fnew=f(xnew);itback=itback+1;

endendfunction//-------------------------------------------------// // steepest descent methodwith Armijo conditionfunction[xbest,fbest,itfct,itgrad]=steepest(x,fx,epsilongrad,itermax,deltagain,tau,

bet,alphainit)itgrad=0;itfct=0;gx=rastrigingrad(x);itgrad=itgrad+1;//delta=1;while (norm(gx)>epsilongrad)&(delta>0)&(itgrad0) thenbari(i,:)=1/length(index)*sum(Xparclust(index,1:n),'r');endendfor i=1:Npopdist0= norm(Xparclust(i,1:n)-bari(Xparclust(i,$),:));for j=1:Nclust

dist(j)=norm(Xparclust(i,1:n)-bari(j,:));

if dist(j)


35/37

Xparclust(i,$)=j;dist0=dist(j);end

endend

endfor i=1:Nclust

index=find(Xparclust(:,$)==i);[minval,indic]=mini(Xparclust(index,n+1));ind(i)=index(indic(1));if (length(index)>0) thenXclust(i,:)=Xpar(index(indic(1)),:);

endNumb(i)=length(index);end

for i=1:Nclustfor j=1:Nclust

Matr(i,j)=norm(bari(i,:)-bari(j,:));end

end

endfunction//////-------------------------------------------dynamic results displays

//function result(Ntot,fmin,co)nl=length(Ntot);if (nl>1) thenxset('window',0);plot2d([Ntot($-1),Ntot($)],[fmin($-1),fmin($)],co);xtitle('convergence history','Neval','fmin');endendfunction////-----------------------------------------------------//-----------------------------------------------------//---------main program -------------------------------//xset('window',0);xbasc();// ----------------------------------------------------//n=6; // number of variables of the optimizationproblemmu=5; //parent numberlambda=35; // offspring numbersiginit=0.5; // initial mutation strengthalpha=1.03; // 1/5 rule coefficientNgen=60;//Nclustmax=0; // maximal cluster numberitgradmax=10; // maximal steepest descent iterationvalmin=3; // minimal number of consecutive GAiterationsCVRlim=1; // coefficient of variation of thepopulation threshold////epsilongrad=1E-10; // stopping criterion for gradient valuetau=0.3; // backtraking coefficient

bet=1E-4; // Armijo coefficientalphainit=0.1; // first step length of steepest descent


36/37

//// ----------------------------------------------------//xmin=-5.*ones(1,n);xmax=5.*ones(1,n);Xmin=ones(mu,1)*xmin;

Xmax=ones(mu,1)*xmax;u=rand(mu,n);pop=Xmin+(Xmax-Xmin).*u; // random initialisation of the populationXpar=[pop,rand(mu,1)]; Xoldpar=Xpar;Xoff=Xpar;Ntot=[];mineval=0;newval=zeros(mu,1);itfct=0;fmin=[];CVold=1;valgen=1;Nevalg=0;////-----------------------------------------------------//-----------------------------------------------------//sigma=siginit;Xpar=evaluation(Xpar);

Nevalf=mu;Nclust=Nclustmax;gen=0;//// MAIN LOOP : BEGINNING////for gen=1:Ngenfor i=1:lambdau=int(mu*rand())+1;xpar=Xpar(u,:);xoff=mutate(xpar,sigma); // ES mutationXoff(i,:)=xoff;

end//oldval=Xoff(:,$);Xoff=evaluation(Xoff); // evaluation of the offspringsNevalf=Nevalf+lambda;//if (gen==1) then Nold=Nevalf;oldmean=mean(Xoff(:,$));end//Xpar=selection(Xpar,Xoff); // selection lambda+mubestpar=Xpar(1,1:n);fmin=[fmin,Xpar(1,$)];Ntot=[Ntot,Nevalf];result(Ntot,fmin,1); // dynamic result display//newval=Xoff(:,$);ind=find(oldval>newval);taux=length(ind)/lambda;if (tauxCVRlim)&(Nclust>0)&(gen-valgen>valmin) then // shift to

steepest descent methodnewmean=mean(Xoff(:,$));Nnew=Nevalf;


37/37

deltagain=(oldmean-newmean)/(Nnew-Nold);oldmean=newmean;Nold=Nnew;

//[Xclust,ind,Matr,Numb]=clustering(Xoff,Nclust);Xoffnew=[];for i=1:Nclust

if (Numb(i)>0) then

[xnew,fnew,itfct,itgrad]=steepest(Xclust(i,1:n),Xclust(i,$),epsilongrad,itgradmax,deltagain,tau,bet,alphainit);

Nevalf=Nevalf+itfct+itgrad*n;Nevalg=Nevalg+itgrad;Xoffnew=[Xoffnew;xnew,fnew];

endendXpar=selection(Xpar,Xoffnew); // selection lambda+mubestpar=Xpar(1,1:n);fmin=[fmin,Xpar(1,$)];Ntot=[Ntot,Nevalf];

result(Ntot,fmin,2); // dynamic result displayvalgen=gen;end//------------------------------------------------------------------------------//// MAIN LOOP : ENDING//end//-----------------------------------------------------//////disp('minimum obtained:');disp(bestpar(1:n));disp('corresponding value by f:');disp(fmin($));disp('evaluation number:');disp(Nevalf);//

general basic coding

Documents