184

APPENDIX A: CODING IN MATLAB

******************************************************************************* %population.m % Code to generate random population for TSP function [y1,y2]= population(N,ngpool)

a=zeros(N,N); for i=1:N for j=1:N if(i~=j) a(i,j)=rand()*10; a(j,i)=a(i,j); end if(i==j) a(i,j)=0; end end end costmin=N; distmin=zeros(1,N); cost=zeros(1,N); for i=1:ngpool gpool(i,:)=randperm(N); end y1=a; y2=gpool;

end ******************************************************************************* %costfun.m %Code to calculate distance of tour in TSP – fitness function function y=costfn(N,ngpool,gpool,a)

t=size(gpool); cost=zeros(1,ngpool); totalfitness=0; global_min = Inf; for i=1:ngpool

sum=0; for j=1:N-1 x=gpool(i,j); y=gpool(i,j+1); sum=sum+a(x,y); end cost(i)=sum; end y=cost;

end *******************************************************************************

185

% e51function.m % Code to generate population of Eil51 Benchmark TSP instance and use distances of Eil51 function y=e51function(N)

edata=load('e51.txt'); locations=edata; distances = zeros(N); for count1=1:N,

for count2=1:N, x1 = locations(count1,2); y1 = locations(count1,3); x2 = locations(count2,2); y2 = locations(count2,3); distances(count1,count2)=sqrt((x1-x2)^2+(y1-y2)^2); distances(count2,count1)=distances(count1,count2); end;

end; y=distances;

end ******************************************************************************* % ga main program for TSP for 50 cities and 100 generations clear all clc close all N=50; ngen=100; ngpool = 50; gpool=zeros(ngpool,N); opt_rte=zeros(ngpool,N); newgpool=zeros(ngpool,N); newpop=zeros(ngpool,N); global_min = Inf; load 'afile50' a load 'agpool50' agpool costmin=N; distmin=zeros(1,N); cost=zeros(1,ngpool); a agpool [rl1 rl2]=rouletteseleloop(N,ngpool,agpool,a,ngen); [rnk1 rnk2]=rankseleloop(N,ngpool,agpool,a,ngen); [pr1 pr2]= proposedseleloop(N,ngpool,agpool,a,ngen); figure x=[1:1:ngen]; y1 = rl1; y2=rnk1; y3=pr1; plot(x,y1,'-.*k',x,y2,'-.xk',x,y3,'-.ok') ylabel('Average Distance') xlabel('Generation') legend('Roulette wheel selection','Rank selection','Proposed selection') title('Comparison of average distance in three approaches of Selection') figure x=[1:1:ngen]; y1= rl2; y2=rnk2; y3=pr2; plot(x,y1,'-*k',x,y2,'-.xk',x,y3,'-.ok') ylabel('Minimum Distance') xlabel('Generation') legend('Roulette wheel selection','Rank selection','Proposed selection') title('Comparison of minimum distance in three approaches of Selection') ********************************************************************************

186

%roulette.m %Code for roulette wheel selection function y=roulette(gpool,N,ngpool,cost) totalfitness=0; totalpfitness=0; tottfitness=0; sp=zeros(1,2); asexual=false; l=1; for i = 1:ngpool totalfitness =totalfitness + cost(i); end for i = 1:ngpool

pcentcontrib(i)=(cost(i) / totalfitness)*100; end %Since problem is TSP, so minimum fitness is to be found for i = 1:ngpool tspcontrib(i)=(1/pcentcontrib(i))*100; end for i = 1:ngpool tottfitness =tottfitness + tspcontrib(i); end tcontrib=sort(pcentcontrib,'descend'); while l<=ngpool/2 C=0; r=tottfitness.*rand(1,1); for i=1:ngpool C=C+tspcontrib(i); if r <= C sect=i;

break end end

for m=1:l-1 if sp(m)==sect

asexual=true; end end if (asexual~=true) sp(l)=sect; l=l+1; end asexual=false;

end y=sp; end ******************************************************************************* %blendsel.m %code to implement proposed annealed selection function y=blendsel(gpool,N,ngpool,cost,nogen,ngen,ra,rb) totalfitness=0; xtottfitness=0; asexual=false; l=1; totalfitness=0; xtottfitness=0; for i = 1:ngpool

totalfitness =totalfitness + cost(i); end for i = 1:ngpool pcentcontrib(i)=(cost(i) /totalfitness);

187

end [csort,ridx]=sort(cost,'descend'); for rk=1:ngpool rnkarray(rk)=rk; end ranksum=0; for r=1:ngpool rankarray(r,1)=rnkarray(r); rankarray(r,2)=ridx(r); rankarray(r,3)=csort(r); ranksum=ranksum+rankarray(r,1); end ng=ngpool for r=1:ngpool prank(r)=(rankarray(r,1)/ranksum);

ng=ng-1; end for i = 1:ngpool tspcontrib(i)=(1/pcentcontrib(i))*100; end for i=1:ngpool

xcontrib(i)=(tspcontrib(i)*rb+prank(i)*ra); end for i = 1:ngpool xtottfitness =xtottfitness + xcontrib(i); end tcontrib=sort(xcontrib,'descend'); while l <= ngpool/2

C=0; r=xtottfitness.*rand(1,1); for i=1:ngpool C=C+xcontrib(i); if r <= C slect=i;

break end

end for m=1:l-1 if sp(m)==slect

asexual=true; end

end if (asexual~=true) sp(l)=slect;

l=l+1; end asexual=false; end y=sp; end ****************************************************************************

188

%rank.m %code for rank selection function y=rank(gpool,N,ngpool,cost,csort,rankarray,prank,ranksum) sum=0; asexual=false; done=false; l=1; while l<=ngpool/2 sum=0; done=false; for i=1:ngpool sum=sum+prank(i); r=ranksum.*rand(1,1); if r <= sum sect=i; done=true; break end end if done==true for m=1:l-1 if sp(m)==sect asexual=true; end end if (asexual~=true) sp(l)=sect; l=l+1; end asexual=false; end end y=sp; end ****************************************************************************** %fnpmxco.m % Code for PMX crossover function [y1, y2] =funcpmxco(N,ngpool,p1,p2)

num_gene=N; tour1=p1; tour2=p2; DAD=99; MOM=999; failed =0; from=0; check_list=0; %* initialize failed[], from[], check_list[]

for k = 1:num_gene failed(k) = -1; from(k) = -1; check_list(k) = 0; end

% locate crossover points left = randint(1,1,[15, num_gene - 15]); right =randint(1,1,[15,num_gene - 15]);

if (left > right) temp = left; left = right; right = temp; end

% copy tour2 into offspring for k = 1:num_gene

offspring(k) = tour2(k); from(k) = DAD; check_list(tour2(k))=check_list(tour2(k))+1;

end % copy tour1 into offspring for k = left:right

189

check_list(offspring(k))=check_list(offspring(k))-1; offspring(k) = tour1(k); from(k) = MOM; check_list(tour1(k))=check_list(tour1(k))+1;

end % pmx main part

mx_fail = 1; % STEP 1 for k = left:right

% for all elements in the tour1-2 if (tour1(k) == tour2(k))

found = 1; % find match in tour2

else found = 0; % substitute elements

j = 1; while (~(found) && (j < num_gene))

if ((offspring(j) == tour1(k)) && (from(j) == DAD)) check_list(offspring(j))=check_list(offspring(j))-1; offspring(j) = tour2(k); found = 1; check_list(tour2(k))=check_list(tour2(k))+1;

end j=j+1;

end end if (~(found))

% failed to replace gene failed(mx_fail) = tour1(k); indx(mx_fail) = k;

mx_fail=mx_fail+1; end

end %end of for

% STEP 2 % see if any genes could not be replaced

if (mx_fail > 0) mx_hold = mx_fail; for k = 1:mx_hold

found = 0; j = 1;

while (~(found) && (j < num_gene)) if ((failed(k) == offspring(j)) && (from(j) == DAD))

check_list(offspring(j))=check_list(offspring(j))-1; offspring(j) = tour2(indx(k)); check_list(tour2(indx(k)))= check_list(tour2(indx(k)))+1;

found = 1; failed(k) = -1; mx_fail=mx_fail-1; end j=j+1;

end end

%end of for end %end of if % STEP 3

190

for k = 1:num_gene if (check_list(k) > 1) i = 1; while (i < num_gene) if ((offspring(i) == k) && (from(i) == DAD)) j = 1; while (j <= num_gene) if (check_list(j) == 0) offspring(i) = j; check_list(k)=check_list(k)-1; check_list(j)=check_list(j)+1; i = num_gene + 1; j = i; end j=j+1; end end % end of if i=i+1; end % end of while end end % end of for c1=offspring; % copy tour2 into offspring for k = 1:num_gene offspring(k) = tour1(k); from(k) = DAD; check_list(tour1(k))=check_list(tour1(k))+1; end % copy tour1 into offspring for k = left:right check_list(offspring(k))=check_list(offspring(k))-1; offspring(k) = tour2(k); from(k) = MOM; check_list(tour2(k))=check_list(tour2(k))+1; end % pmx main part mx_fail = 1; % STEP 1 for k = left:right % for all elements in the tour1-2 if (tour2(k) == tour1(k)) found = 1; %find match in tour2 else found = 0; % substitute elements j = 1; while (~(found) && (j < num_gene)) if ((offspring(j) == tour2(k)) && (from(j) == DAD)) check_list(offspring(j))=check_list(offspring(j))-1; offspring(j) = tour1(k); found = 1; check_list(tour1(k))=check_list(tour1(k))+1; end j=j+1; end end if (~(found))

191

% failed to replace gene failed(mx_fail) = tour2(k); indx(mx_fail) = k; mx_fail=mx_fail+1; end end % end of for % STEP 2 % see if any genes could not be replaced if (mx_fail > 0) mx_hold = mx_fail; for k = 1:mx_hold found = 0; j = 1; while (~(found) && (j < num_gene)) if ((failed(k) == offspring(j)) && (from(j) == DAD)) check_list(offspring(j))=check_list(offspring(j))-1; offspring(j) = tour1(indx(k)); check_list(tour1(indx(k)))= check_list(tour1(indx(k)))+1; found = 1; failed(k) = -1; mx_fail=mx_fail-1; end j=j+1; end end % end of for end % end of if % STEP 3 for k = 1:num_gene if (check_list(k) > 1) i = 1; while (i < num_gene) if ((offspring(i) == k) && (from(i) == DAD)) j = 1; while (j <= num_gene) if (check_list(j) == 0) offspring(i) = j; check_list(k)=check_list(k)-1; check_list(j)=check_list(j)+1; i = num_gene + 1; j = i; end j=j+1; end end % end of if i=i+1; end %end of while end end % end of for c2=offspring; y1=c1; y2=c2; end *******************************************************************************

192

%roulette sele loop.m %code to implement GA with roulette wheel selection function [y1 y2]=rouletteseleloop(N,ngpool,agpool,a,ngen) gpool=agpool; cost=costfn(N,ngpool,gpool,a); global_min = Inf; om=1; for j=1:ngen om=1; [costmin,idx]=min(cost); distmin=gpool(idx,:); [csort,ridx]=sort(cost); dist_history(j) = costmin; avg_history(j)=mean(cost); min_history(j)=min(cost); if costmin < global_min global_min = costmin; opt_rte(j,:) = gpool(idx,:); end sparent=roulette(gpool,N,ngpool,cost); for ik=1:(N/2)-1 for jk=ik+1:N/2 p1=gpool(sparent(ik),:); p2=gpool(sparent(jk),:); [c1 c2]=funcpmxco(N,ngpool,p1,p2); if om<N newgpool(om,:)=c1; om=om+1; newgpool(om,:)=c2; om=om+1; end end end gpool=newgpool; cost=costfn(N,ngpool,gpool,a); end % Find the Minimum Distance Route [min_dist, index] = min(dist_history); dist_history; op_rte = opt_rte(index,:); disp(['minimum cost in roulette selection = ' num2str(min_dist)]) disp('optimum points = ') disp(num2str(op_rte)) tblvarcost=avg_history; avgroulette=mean(tblvarcost); disp(['average fitness in roulette selection = ' num2str(avgroulette)]) y=[1:1:ngen]; x1 = tblvarcost; plot(x1,y) xlabel('Average Distance') ylabel('Generation') title('Roulette wheel Selection') tblvarmincost=dist_history; y=[1:1:ngen]; x2=tblvarmincost; figure plot(x2,y) xlabel('Minimum Distance') ylabel('Generation') title('Roulette wheel selection') y1=tblvarcost; y2=tblvarmincost; end *******************************************************************************

193

%inversion.m %code to perform inversion function inversion(nmuts,gpool,ngpool,N) for ic=1:nmuts ix=ceil(ngpool*rand); iy=ceil(N*rand); y2=ceil(N*rand); t=gpool(ix,iy); gpool(ix,iy)=gpool(ix,iy2); gpool(ix,iy2)=t; end end ******************************************************************************* %rank sele loop %code to implement GA with rank selection function [y1 ,y2]=rankseleloop(N,ngpool,agpool,a,ngen) gpool=agpool; cost=costfn(N,ngpool,gpool,a); global_min = Inf; for j=1:ngen om=1; [costmin,idx]=min(cost); distmin=gpool(idx,:); [csort,ridx]=sort(cost,'descend'); for rk=1:ngpool rnkarray(rk)=rk; end ranksum=0; for r=1:ngpool rankarray(r,1)=rnkarray(r); rankarray(r,2)=ridx(r);

rankarray(r,3)=csort(r); ranksum=ranksum+rankarray(r,1); end for r=1:ngpool

prank(r)=(rankarray(r,1)/ranksum)*100; end dist_history(j) = costmin; avg_history(j)=mean(cost); min_history(j)=min(cost); if costmin < global_min global_min = costmin; opt_rte(j,:) = gpool(idx,:); end ik=0; jk=0; sparent=rank(gpool,N,ngpool,cost,csort,rankarray,prank,ranksum); for ik=1:(ngpool/2)-1 for jk=ik+1:(ngpool/2) p1=gpool(sparent(ik),:); p2=gpool(sparent(jk),:);

[c1 c2]=funcpmxco(N,ngpool,p1,p2); newgpool(om,:)=c1; om=om+1;

end end gpool=newgpool; cost=costfn(N,ngpool,gpool,a); end % Find the Minimum Distance Route [min_dist, index] = min(dist_history); op_rte = opt_rte(index,:); disp(['minimum cost in rank selection = ' num2str(min_dist)]) disp('optimum points = ') disp(num2str(op_rte)) figure tblvarcost=avg_history; y=[1:1:ngen]; x1 = tblvarcost; avgrank=mean(tblvarcost);

194

disp(['average fitness in roulette selection = ' num2str(avgrank)]) plot(x1,y) xlabel('Average Distance') ylabel('Generation') title('Rank Selection') tblvarmincost=dist_history; y=[1:1:ngen]; x2=tblvarmincost; figure plot(x2,y) xlabel('Minimum Distance') ylabel('Generation') title('Rank Selection') y1=tblvarcost; y2=tblvarmincost; end ******************************************************************************* %proposedseleloop.m %code to implement ga with annealed selection function [y1,y2]=proposedseleloop(N,ngpool,agpool,a,ngen)

gpool=agpool; cost=costfn(N,ngpool,gpool,a); global_min = Inf; ra=1; rb=0; for j=1:ngen nogen=j; om=1; [costmin,idx]=min(cost); distmin=gpool(idx,:); csort,ridx]=sort(cost);

dist_history(j) = costmin; avg_history(j)=mean(cost); min_history(j)=min(cost); if costmin < global_min global_min = costmin; opt_rte(j,:) = gpool(idx,:); end sparent=blendsel(gpool,N,ngpool,cost,nogen,ngen,ra,rb) ;

ra=ra-1/ngen; rb=rb+1/ngen; for ik=1:(ngpool/2)-1 for jk=ik+1:ngpool/2

p1=gpool(sparent(ik),:); p2=gpool(sparent(jk),:); [c1 c2]=funcpmxco(N,ngpool,p1,p2);

newgpool(om,:)=c1; om=om+1; end

end gpool=newgpool; cost=costfn(N,ngpool,gpool,a);

end % Find the Minimum Distance Route [min_dist, index] = min(dist_history); op_rte = opt_rte(index,:); disp(['minimum cost in proposed selection = ' num2str(min_dist)]) disp('optimum points = ') disp(num2str(op_rte)) figure tblvarcost=avg_history; avgproposed=mean(tblvarcost); disp(['average fitness in roulette selection = ' num2str(avgproposed)]) y=[1:1:ngen]; x1 = tblvarcost; plot(x1,y) xlabel('Average Distance') ylabel('Generation') title('Proposed Selection')

195

tblvarmincost=dist_history; y=[1:1:ngen]; x2=tblvarmincost; figure plot(x2,y) xlabel('Minimum Distance') ylabel('Generation') title('Proposed Selection') y1=tblvarcost; y2=tblvarmincost; end ******************************************************************************* %fntabuknowledgeco.m %code for knowledge based tabu crossover function [y1, y2] =fntabuknowledgeco(N,ngpool,p1,p2,cost,a)

lk=1; s=cost(1); d1=p1(1); b1=p1(1); for i=1:N-1 c=a(p1(i),p1(i+1)); if c<s

d2=p1(i); l1=i; b2=p1(i+1); l2=i+1; s=c; end

end s=cost(1); for i=1:N-1

c=a(p2(i),p2(i+1)); if c<s

d12=p2(i); l12=i; b12=p2(i+1); l22=i+1; s=c; end end

s=0; for i=1:N-1

c=a(p1(i),p1(i+1)); if c>s

d1=p1(i); l3=i; b1=p1(i+1); l4=i+1; s=c; end end s=0; for i=1:N-1

c=a(p2(i),p2(i+1)); if c>s

d21=p2(i); l3=i; b21=p2(i+1); l4=i+1; s=c; end end po=zeros(1,N); ch=0; po(l1)=d2; po(l2)=b2; cn=p2(1); lk=1; ij=1; while ij<=N

ch=0; if (cn==d2)||(cn==b2)

lk=lk+1; if lk<= N

cn=p2(lk); end

196

end for it=1:N

if po(it)==cn ch=1;

end end if(ch==0)

if po(ij)==0 if cn==b1 %not good pair if ij~=1 if po(ij-1)~=d1

po(ij)=cn; lk=lk+1; end end

end if cn==d1

if ij~=1 if po(ij-1)~=b1

po(ij)=cn; lk=lk+1; end

end end if cn==b21 %not good pair

if ij~=1 if po(ij-1)~=d21

po(ij)=cn; lk=lk+1; end end

end if cn==d21 if ij~=1 if po(ij-1)~=b21

po(ij)=cn; lk=lk+1; end

end end if cn~=d1 && cn~=b1 && cn~=d21 && cn~=b21

po(ij)=cn; lk=lk+1; end

if lk<= N cn=p2(lk);

end end

end if lk<=N

cn=p2(lk); else

break; end

ij=ij+1; emch=0; for em=1:N if po(em)==0

197

emch=emch+1; end end

if emch==0 break

end end emch=0; for em=1:N

if po(em)==0 emch=emch+1; pq(em)=1;

else pq(em)=0;

end end if emch==0

po; else

ui=1; for emit=1:emch

ind=find(pq); for qw=1:N

nf=1; for qz= 1:N

if qw==po(qz) nf=0; end end if nf==1 st(ui)=qw; ui=ui+1; end end po(ind(emit))= st(emit); end end lk=1; po1=zeros(1,N); ch=0; po1(l12)=d12; po1(l22)=b12; cn=p1(1); lk=1; ij=1; while ij<=N ch=0; if (cn==d2)||(cn==b2) lk=lk+1; if lk<= N cn=p2(lk); end end for it=1:N if po1(it)==cn ch=1; end end if(ch==0) if po1(ij)==0 if cn==b1 %not good pair

198

if ij~=1 if po1(ij-1)~=d1 po1(ij)=cn; lk=lk+1; end end end if cn==d1 if ij~=1 if po1(ij-1)~=b1

po1(ij)=cn; lk=lk+1; end end end if cn==b21 %not good pair if ij~=1 if po1(ij-1)~=d21 po1(ij)=cn; lk=lk+1; end end end if cn==d21 if ij~=1 if po1(ij-1)~=b21 po1(ij)=cn; lk=lk+1; end end end if cn~=d1 && cn~=b1 && cn~=d21 && cn~=b21 po1(ij)=cn; lk=lk+1; end if lk<= N

cn=p1(lk); else break; end end end if lk<=N cn=p1(lk); else break; end ij=ij+1; emch=0; for em=1:N if po1(em)==0 emch=emch+1; end end if emch==0 po1; % 'complete' break end

199

end emch=0; for em=1:N if po1(em)==0 emch=emch+1; pq(em)=1; else pq(em)=0; end end if emch==0 po1; else ui=1; for emit=1:emch ind=find(pq); for qw=1:N nf=1; for qz= 1:N if qw==po1(qz) nf=0; end end if nf==1 st(ui)=qw; ui=ui+1; end end po1(ind(emit))= st(emit); end end y1=po; y2=po1; end ******************************************************************************* %encmain.m %code to test binary encoding and proposed encoding clc [d1 d2]=encod1bin; [a1 a2] =encod1; [b1 b2]= encod2; [c1 c2] = encod3; figure x=[1:1:10]; y1 = a1; y2=b1; y3 = c1; y7=d1; plot(x,y7,'-ob',x,y1,'-*k',x,y2,'-or',x,y3,'-*m') ylabel('Average fitness') xlabel('Generation') legend('Binary encoding + one point CO','Proposed encoding + one point CO','Proposed encoding + PMX CO','Proposed encoding + Inversion') title('Comparison of average fitness') figure x=[1:1:10]; y4 = a2; y5=b2; y6 = c2; y8=d2; plot(x,y8,'-ob',x,y4,'-*k',x,y5,'-or',x,y6,'-*m') ylabel('maximum fitness') xlabel('Generation')

200

legend('Binary encoding + one point CO','Proposed encoding + one point CO','Proposed encoding + PMX CO','Proposed encoding + Inversion') title('Comparison of maximum fitness') ******************************************************************************** %encod1.m %code to check proposed encoding with one point crossover function [y1 y2]=encod1() clc format short g N=5; % number of bits in a chromosome ngen=10; % number of generations global_min=inf; ngpool=6; data=zeros(ngen,ngpool); inpop=[ 22 13 15 2 10 11] binpool=binpop(inpop,ngpool,N); agpool=bintowtpool(binpool,ngpool,N); % initial population gpool=agpool mutrate=0.1; % mutation rate nmuts=mutrate*N; nm=ngen/nmuts; % number of mutations Z=zeros(10,10); maxfit=0; global_min=0; newgpool=zeros(ngpool,N); for ib=1:ngen csum=0; n = ngpool; for(j=1:ngpool) sum = 0; sum=binwttodec(gpool(j,:),N) ; z(ib,j)=sum; s(j)=sum; csum=csum+sum; end cmax=max(s); if maxfit<cmax maxfit=cmax; end avgfit=csum/ngpool; [costmin,idx]=max(s); distmin=gpool(idx,:); xj1(ib,:)=distmin; [csort,ridx]=sort(s); dist_history(ib) = costmin; avg_history(ib)=avgfit; min_history(ib)=cmax; if costmin < global_min global_min = costmin; opt_rte(ib,:) = gpool(idx,:); end sparent=roulettesimplega(gpool,N,ngpool,s); om=1; for ik=1:4 for jk=ik+1:5 p1=gpool(sparent(ik),:); p2=gpool(sparent(jk),:); cross=ceil(N.*rand(1,1)); for wc=1:cross c1(wc)=p1(wc); c2(wc)=p2(wc); end for wc=cross+1:N c1(wc)=p2(wc); c2(wc)=p1(wc); end if om<ngpool newgpool(om,:)=c1; om=om+1; newgpool(om,:)=c2; om=om+1; end end

201

end gpool=newgpool; end y2=min_history; y1=avg_history; end ***************************************************************** %encod2.m %code to check proposed encoding with PMX crossover function [y1 y2]=encod2() clc format short g N=5; % number of bits in a chromosome ngen=10; % number of generations ngpool=6; global_min=inf; data=zeros(ngen,ngpool); inpop=[ 22 13 15 2 10 11] binpool=binpop(inpop,ngpool,N); agpool=bintowtpool(binpool,ngpool,N); % initial population gpool=agpool mutrate=0.1; % mutation rate nmuts=mutrate*N; nm=ngen/nmuts; % number of mutations Z=zeros(10,10); maxfit=0; global_min=0; newgpool=zeros(ngpool,N); for ib=1:ngen csum=0; n = ngpool; for(j=1:ngpool) sum = 0; sum=binwttodec(gpool(j,:),N); z(ib,j)=sum; s(j)=sum; csum=csum+sum; end cmax=max(s); if maxfit<cmax maxfit=cmax; end avgfit=csum/ngpool; [costmin,idx]=max(s); distmin=gpool(idx,:); xj1(ib,:)=distmin; [csort,ridx]=sort(s); dist_history(ib) = costmin; avg_history(ib)=avgfit; min_history(ib)=cmax; if costmin < global_min global_min = costmin; opt_rte(ib,:) = gpool(idx,:); end sparent=roulettesimplega(gpool,N,ngpool,s); om=1; for ik=1:4 for jk=ik+1:5 p1=gpool(sparent(ik),:); p2=gpool(sparent(jk),:); [c1 c2]=funcpmxco(5,2,p1,p2); if om<ngpool newgpool(om,:)=c1; om=om+1; newgpool(om,:)=c2; om=om+1; end end end gpool=newgpool; end y2=min_history; y1=avg_history; end

202

******************************************************************************* %encod3.m %code to check proposed encoding with Inversion function [y1 y2]=encod3() clc format short g N=5; % number of bits in a chromosome ngen=10; % number of generations global_min=inf; ngpool=6; data=zeros(ngen,ngpool); inpop=[ 22 13 15 2 10 11] binpool=binpop(inpop,ngpool,N); agpool=bintowtpool(binpool,ngpool,N); % initial population gpool=agpool mutrate=0.1; nmuts=mutrate*N; newgpool=zeros(ngpool,N); nm=ngen/nmuts; Z=zeros(10,10); maxfit=0; global_min=0; for ib=1:ngen csum=0; n = ngpool; for(j=1:ngpool) sum = 0; sum=binwttodec(gpool(j,:),N) ; z(ib,j)=sum; s(j)=sum; csum=csum+sum; end cmax=max(s); if maxfit<cmax maxfit=cmax; end avgfit=csum/ngpool; [costmin,idx]=max(s); distmin=gpool(idx,:); xj1(ib,:)=distmin; [csort,ridx]=sort(s); dist_history(ib) = costmin; avg_history(ib)=avgfit; min_history(ib)=cmax; if costmin < global_min global_min = costmin; opt_rte(ib,:) = gpool(idx,:); end sparent=roulettesimplega(gpool,N,ngpool,s); om=1; for ik=1:4 for jk=ik+1:5 p1=gpool(sparent(ik),:); p2=gpool(sparent(jk),:); ix=sort(p1,'ascend'); iy=sort(p2,'ascend'); ix1=sort(p1,'descend'); iy1=sort(p2,'descend'); cp=3; for i= 1 : cp

of1(i)=p1(i); of2(i)=p2(i); end

for i=cp+1 : N of1(i)=iy(i); of2(i)=ix(i);

end c1=chk(of1); c2=chk(of2);

if om<ngpool newgpool(om,:)=c1; om=om+1; newgpool(om,:)=c2; om=om+1; end end end gpool=newgpool; end y2=min_history; y1=avg_history; end

203

******************************************************************************* %encod1bin.m %code to check binary encoding function [y1 y2]=encod1bin() clc format short g N=5; % number of bits in a chromosome ngen=10; % number of generations global_min=inf; data=zeros(ngen,ngpool); ngpool=6; inpop=[ 22 13 15 2 10 11] binpool=binpop(inpop,ngpool,N); agpool=binpool; gpool=agpool mutrate=0.1; nmuts=mutrate*N; nm=ngen/nmuts; Z=zeros(10,10); maxfit=0; global_min=0; c1=zeros(1,N); c2=zeros(1,N) newgpool=zeros(ngpool,N); for ib=1:ngen csum=0; n = ngpool; for(j=1:ngpool) sum = 0; sum=binwttodecbin(gpool(j,:),N); z(ib,j)=sum; s(j)=sum; csum=csum+sum; end cmax=max(s); if maxfit<cmax maxfit=cmax; end avgfit=csum/ngpool; [costmin,idx]=max(s); distmin=gpool(idx,:); xj1(ib,:)=distmin; [csort,ridx]=sort(s); dist_history(ib) = costmin; avg_history(ib)=avgfit; min_history(ib)=cmax; if costmin < global_min global_min = costmin; opt_rte(ib,:) = gpool(idx,:); end sparent=roulettesimplega(gpool,N,ngpool,s); om=1; for ik=1:4

for jk=ik+1:5 p1=gpool(sparent(ik),:); p2=gpool(sparent(jk),:); cross=ceil(N.*rand(1,1)); for wc=1:cross

c1(wc)=p1(wc); c2(wc)=p2(wc); end

for wc=cross+1:N c1(wc)=p2(wc); c2(wc)=p1(wc);

end if om<ngpool

newgpool(om,:)=c1; om=om+1; newgpool(om,:)=c2; om=om+1; end

end end gpool=newgpool; end y2=min_history; y1=avg_history; end *******************************************************************************

204

%code to covert binary weight to decimal function y=binwttodec(nm,x)

d=x; bin=nm; sum=0; for k=d:-1:1 n = bin(k); b=1; m=d-k; i=1; sum = sum + n; end y=sum*sum;

end ***************************************************************************** %code to generate binary population function y=binpop(inpop,ngpool,N)

r=0; outpop=zeros(ngpool,N); for i= 1 : ngpool d=inpop(i); p=1; bi=zeros(1,N); while d>0 r=rem(d,2); d=floor(d./2); bi(p)=r; p=p+1; end m=size(bi,2); p1=m; for k=1:p1 binr(k)=bi(m); m=m-1; end outpop(i,:)=binr; end y=outpop;

end ***************************************************************************** %code to convert binary code to binary weight function y=bintowtpool(bn,ngpool,N)

for in=1:ngpool bin=bn(in,:) d=size(bin,2); sum=0;

for k=d:-1:1 n = bin(k); b=1; m=d-k; i=1; while i <=m % 1 2 4 8 16 32 64 ... place-values, reversed here

b =b*2; i=i+1; end

c1(k)=n*b; end wtpool(in,:)=c1; end y=wtpool

end *****************************************************************************

205

%code for extended polygamy implementation with annealed selection function [y1,y2]=pgamycomptproposedseleloop(N,ngpool,agpool,a,ngen)

gpool=agpool; cost=costfn(N,ngpool,gpool,a); global_min = Inf; prevcost=inf; mutrate=0.5; nmuts=mutrate*N*(ngpool-1); for j=1:ngen

nogen=j; om=1; cost=costfn(N,ngpool,gpool,a); [costmin,idx]=min(cost); distmin=gpool(idx,:); cost(idx); [csort,ridx]=sort(cost);

dist_history(j) = costmin; avg_history(j)=mean(cost); min_history(j)=min(cost); if costmin < global_min

global_min = costmin; opt_rte(j,:) = gpool(idx,:); end if costmin<prevcost

prev=distmin; prevcost=costmin; % 'new best better'

else % 'prev better'

end p1=prev;

sparent=blendsel(gpool,N,ngpool,cost,nogen,ngen); ik=1; pc=1; [spcol spsize]=size(sparent); octr=1; while pc<=spsize p2=gpool(sparent(pc),:); pc=pc+1; [c1 c2]=funcpmxco(N,ngpool,p1,p2); offpool(octr,:)=c1; octr=octr+1; offpool(octr,:)=c2; octr=octr+1; end ocost=costfn(N,ngpool,offpool,a); [ofsort,odx]=sort(ocost); while om<= ngpool newgpool(om,:)=offpool(odx(om),:); om=om+1; end gpool=newgpool; inversion(nmuts,gpool,ngpool,N);

end [min_dist, index] = min(dist_history); op_rte = opt_rte(index,:); disp(['minimum cost in proposed selection = ' num2str(min_dist)]) disp('optimum points = ') disp(num2str(op_rte)) tblvarcost=avg_history; avgproposed=mean(tblvarcost); disp(['average fitness in PROPOSED selection = ' num2str(avgproposed)]) y=[1:1:ngen]; x1 = tblvarcost; tblvarmincost=dist_history; x2=tblvarmincost; y1=tblvarcost; y2=tblvarmincost;

end *******************************************************************************

206

%code for dejong’s sphere function &comparison of roulette wheel, rank & annealed selection clear all clc format short g N=10; % number of bits in a chromosome ngpool=10; w=0.3; global_min=inf; data=zeros(ngen,ngpool); ngen=20; % number of generations % creates M random chromosomes with N bits a=-5.12; b=5.12; agpool=a+(b-a)*rand(ngpool,N); % initial population gpool=agpool mutrate=0.1; nmuts=mutrate*N; nm=ngen/nmuts; Z=zeros(10,10); minfit=inf; newgpool=zeros(ngpool,N); for ib=1:ngen csum=0; n = ngpool; for j=1:ngpool sum=0; s = 0; for i=1:N s=s+(gpool(j,i)^2); end sum=s; z(ib,j)=sum; cost(j)=sum; csum=csum+cost(j); data(ib,j)=s; end Z(ib,:)=cost; cmin=min(cost); if minfit>cmin minfit=cmin; end avgfit=csum/ngpool; [costmin,idx]=min(cost); distmin=gpool(idx,:); xj1(ib,:)=distmin; [csort,ridx]=sort(cost); dist_history(ib) = costmin; avg_history(ib)=mean(cost); min_history(ib)=min(cost); if costmin < global_min global_min = costmin; opt_rte(ib,:) = gpool(idx,:); end sparent=roulettesimplega(gpool,N,ngpool,cost); om=1; for ik=1:4 for jk=ik+1:5 p1=gpool(sparent(ik),:); p2=gpool(sparent(jk),:); cross=ceil(N.*rand(1,1)); for wc=1:cross c1(wc)=p1(wc)*w; c2(wc)=p2(wc)*(1-w); end for wc=cross+1:N c1(wc)=p1(wc)*(1-w); c2(wc)=p2(wc)*w; end if om<ngpool newgpool(om,:)=c1; om=om+1; newgpool(om,:)=c2; om=om+1; end end end gpool=newgpool; if mod(j,nm)==0 for ic=1:nmuts

ix=ceil(ngpool*rand); iy=ceil(N*rand); gpool(ix,iy)=1-gpool(ix,iy); end %ic

end

207

w=w-0.01; end % Find the Maximum fitness [min_dist, index] = min(dist_history); op_rte = opt_rte(index,:); disp(['minimum cost in roulette selection = ' num2str(min_dist)]) disp('optimum points = ') disp(num2str(op_rte)) tblvarcost=avg_history; avgroulette=mean(tblvarcost); disp(['average fitness in roulette selection = ' num2str(avgroulette)]) y=[1:1:ngen]; x1 = tblvarcost; tblvarmincost=dist_history; x2=tblvarmincost; yl1=tblvarcost; yl2=tblvarmincost; % rank selection start gpool=agpool; w=0.3; minfit=inf; newgpool=zeros(ngpool,N); for ib=1:ngen csum=0; n = ngpool; for j=1:ngpool sum=0; s = 0; for i=1:N

s=s+(gpool(j,i)^2); end

sum=s; cost(j)=sum; csum=csum+cost(j); data(ib,j)=s; end Z(ib,:)=cost; cmin=min(cost); if minfit>cmin minfit=cmin; end avgfit=csum/ngpool; [costmin,idx]=min(cost); distmin=gpool(idx,:); xj1(ib,:)=distmin; [csort,ridx]=sort(cost); dist_history(ib) = costmin; avg_history(ib)=mean(cost); min_history(ib)=min(cost); if costmin < global_min global_min = costmin; opt_rte(ib,:) = gpool(idx,:); end for rk=1:ngpool

rnkarray(rk)=rk; end ranksum=0; for r=1:ngpool rankarray(r,1)=rnkarray(r); rankarray(r,2)=ridx(r); rankarray(r,3)=csort(r); ranksum=ranksum+rankarray(r,1); end for r=1:ngpool

prank(r)=(rankarray(r,1)/ranksum)*100; end ik=0; jk=0; sparent=ranksimplega(gpool,N,ngpool,cost,csort,rankarray,prank,ranksum);

om=1; for ik=1:4 for jk=ik+1:5 p1=gpool(sparent(ik),:); p2=gpool(sparent(jk),:); cross=ceil(N.*rand(1,1)); for wc=1:cross

c1(wc)=p1(wc)*w; c2(wc)=p2(wc)*(1-w);

208

end for wc=cross+1:N

c1(wc)=p1(wc)*(1-w); c2(wc)=p2(wc)*w; end if om<ngpool newgpool(om,:)=c1; om=om+1; newgpool(om,:)=c2; om=om+1; end end

end gpool=newgpool; if mod(j,nm)==0 for ic=1:nmuts

ix=ceil(ngpool*rand); iy=ceil(N*rand); gpool(ix,iy)=1-gpool(ix,iy); end %ic end w=w-0.01;

end [min_dist, index] = min(dist_history); op_rte = opt_rte(index,:); disp(['minimum cost in rank selection = ' num2str(min_dist)]) disp('optimum points = ') disp(num2str(op_rte)) tblvarcost=avg_history; avgroulette=mean(tblvarcost); disp(['average fitness in rank selection = ' num2str(avgroulette)]) y=[1:1:ngen]; x1 = tblvarcost; tblvarmincost=dist_history; x2=tblvarmincost; yl3=tblvarcost; yl4=tblvarmincost; %annealed selection start gpool=agpool; w=0.3; minfit=inf; newgpool=zeros(ngpool,N); for ib=1:ngen csum=0; n = ngpool; for j=1:ngpool sum=0; s = 0; for i=1:N s=s+(gpool(j,i)^2); end sum=s; cost(j)=sum; csum=csum+cost(j); data(ib,j)=s; end Z(ib,:)=cost; cmin=min(cost); if minfit>cmin minfit=cmin; end avgfit=csum/ngpool; [costmin,idx]=min(cost); distmin=gpool(idx,:); xj1(ib,:)=distmin; [csort,ridx]=sort(cost); dist_history(ib) = costmin; avg_history(ib)=mean(cost); min_history(ib)=min(cost); if costmin < global_min global_min = costmin; opt_rte(ib,:) = gpool(idx,:); end nogen=ib; sparent=proposedsimplega(gpool,N,ngpool,cost,nogen,ngen); om=1; for ik=1:4 for jk=ik+1:5

209

p1=gpool(sparent(ik),:); p2=gpool(sparent(jk),:); cross=ceil(N.*rand(1,1)); for wc=1:cross c1(wc)=p1(wc)*w; c2(wc)=p2(wc)*(1-w); end for wc=cross+1:N c1(wc)=p1(wc)*(1-w); c2(wc)=p2(wc)*w; end if om<ngpool newgpool(om,:)=c1; om=om+1; newgpool(om,:)=c2; om=om+1; end end end gpool=newgpool; if mod(j,nm)==0

for ic=1:nmuts ix=ceil(ngpool*rand); iy=ceil(N*rand); gpool(ix,iy)=1-gpool(ix,iy);

end %ic end w=w-0.01; end [min_dist, index] = min(dist_history); op_rte = opt_rte(index,:); disp(['minimum cost in proposed selection = ' num2str(min_dist)]) disp('optimum points = ') disp(num2str(op_rte)) tblvarcost=avg_history; avgroulette=mean(tblvarcost); disp(['average fitness in proposed selection = ' num2str(avgroulette)]) y=[1:1:ngen]; x1 = tblvarcost; tblvarmincost=dist_history; x2=tblvarmincost; yl5=tblvarcost; yl6=tblvarmincost; x=[1:1:ngen]; y1 = yl1; y2=yl3; y3=yl5; plot(x,y1,'-.*r',x,y2,'-.xg',x,y3,'-.ob') ylabel('Average fitness') xlabel('Generation') legend('Roulette wheel selection','Rank selection','Annealed selection') title('Comparison of average fitness in three approaches of Selection') figure x=[1:1:ngen]; y1= yl2; y2=yl4; y3=yl6; plot(x,y1,'-*r',x,y2,'-.xg',x,y3,'-.ob') ylabel('Minimum Fitness') xlabel('Generation') legend('Roulette wheel selection','Rank selection','Annealed selection') title('Comparison of Minimum fitness in three approaches of Selection') ******************************************************************************* %%code for rosenbrock’s function &comparison of roulette wheel, rank & annealed selection clear all clc format short g N=10; % number of bits in a chromosome ngpool=10; w=0.3; global_min=inf; data=zeros(ngen,ngpool); ngen=20; % number of generations % creates M random chromosomes with N bits a=-2.048; b=2.048; agpool=a+(b-a)*rand(ngpool,N); % initial population

210

gpool=agpool mutrate=0.1; nmuts=mutrate*N; nm=ngen/nmuts; Z=zeros(10,10); minfit=inf; newgpool=zeros(ngpool,N); for ib=1:ngen csum=0; n = ngpool; for j=1:ngpool sum=0; s = 0; for i=1:N-1 sum = sum+100*(gpool(j,i)^2-gpool(j,i+1))^2+(gpool(j,i)-1)^2; end sum=s; z(ib,j)=sum; cost(j)=sum; csum=csum+cost(j); data(ib,j)=s; end Z(ib,:)=cost; cmin=min(cost); if minfit>cmin minfit=cmin; end avgfit=csum/ngpool; [costmin,idx]=min(cost); distmin=gpool(idx,:); xj1(ib,:)=distmin; [csort,ridx]=sort(cost); dist_history(ib) = costmin; avg_history(ib)=mean(cost); min_history(ib)=min(cost); if costmin < global_min global_min = costmin; opt_rte(ib,:) = gpool(idx,:); end sparent=roulettesimplega(gpool,N,ngpool,cost); om=1; for ik=1:4 for jk=ik+1:5 p1=gpool(sparent(ik),:); p2=gpool(sparent(jk),:); cross=ceil(N.*rand(1,1)); for wc=1:cross c1(wc)=p1(wc)*w; c2(wc)=p2(wc)*(1-w); end for wc=cross+1:N c1(wc)=p1(wc)*(1-w); c2(wc)=p2(wc)*w; end if om<ngpool newgpool(om,:)=c1; om=om+1; newgpool(om,:)=c2; om=om+1; end end end gpool=newgpool; if mod(j,nm)==0 for ic=1:nmuts ix=ceil(ngpool*rand); iy=ceil(N*rand); gpool(ix,iy)=1-gpool(ix,iy); end %ic end w=w-0.01; end % Find the Maximum fitness [min_dist, index] = min(dist_history); op_rte = opt_rte(index,:); disp(['minimum cost in roulette selection = ' num2str(min_dist)]) disp('optimum points = ') disp(num2str(op_rte)) tblvarcost=avg_history; avgroulette=mean(tblvarcost);

211

disp(['average fitness in roulette selection = ' num2str(avgroulette)]) y=[1:1:ngen]; x1 = tblvarcost; tblvarmincost=dist_history; x2=tblvarmincost; yl1=tblvarcost; yl2=tblvarmincost; % rank selection start gpool=agpool; w=0.3; minfit=inf; newgpool=zeros(ngpool,N); for ib=1:ngen csum=0; n = ngpool; for j=1:ngpool sum=0; s = 0; for i=1:N-1 sum = sum+100*(gpool(j,i)^2-gpool(j,i+1))^2+(gpool(j,i)-1)^2; end sum=s; cost(j)=sum; csum=csum+cost(j); data(ib,j)=s; end Z(ib,:)=cost; cmin=min(cost); if minfit>cmin minfit=cmin; end avgfit=csum/ngpool; [costmin,idx]=min(cost); distmin=gpool(idx,:); xj1(ib,:)=distmin; [csort,ridx]=sort(cost); dist_history(ib) = costmin; avg_history(ib)=mean(cost); min_history(ib)=min(cost); if costmin < global_min global_min = costmin; opt_rte(ib,:) = gpool(idx,:); end for rk=1:ngpool rnkarray(rk)=rk; end ranksum=0; for r=1:ngpool rankarray(r,1)=rnkarray(r); rankarray(r,2)=ridx(r); rankarray(r,3)=csort(r); ranksum=ranksum+rankarray(r,1); end for r=1:ngpool prank(r)=(rankarray(r,1)/ranksum)*100; end ik=0; jk=0; sparent=ranksimplega(gpool,N,ngpool,cost,csort,rankarray,prank,ranksum); om=1; for ik=1:4 for jk=ik+1:5 p1=gpool(sparent(ik),:); p2=gpool(sparent(jk),:); cross=ceil(N.*rand(1,1)); for wc=1:cross c1(wc)=p1(wc)*w; c2(wc)=p2(wc)*(1-w); end for wc=cross+1:N c1(wc)=p1(wc)*(1-w); c2(wc)=p2(wc)*w; end if om<ngpool newgpool(om,:)=c1; om=om+1; newgpool(om,:)=c2; om=om+1; end end end

212

gpool=newgpool; if mod(j,nm)==0 for ic=1:nmuts ix=ceil(ngpool*rand); iy=ceil(N*rand); gpool(ix,iy)=1-gpool(ix,iy); end %ic end w=w-0.01; end [min_dist, index] = min(dist_history); op_rte = opt_rte(index,:); disp(['minimum cost in rank selection = ' num2str(min_dist)]) disp('optimum points = ') disp(num2str(op_rte)) tblvarcost=avg_history; avgroulette=mean(tblvarcost); disp(['average fitness in rank selection = ' num2str(avgroulette)]) y=[1:1:ngen]; x1 = tblvarcost; tblvarmincost=dist_history; x2=tblvarmincost; yl3=tblvarcost; yl4=tblvarmincost; %annealed selection start gpool=agpool; w=0.3; minfit=inf; newgpool=zeros(ngpool,N); for ib=1:ngen csum=0; n = ngpool; for j=1:ngpool sum=0; s = 0; for i=1:N-1 sum = sum+100*(gpool(j,i)^2-gpool(j,i+1))^2+(gpool(j,i)-1)^2; end sum=s; cost(j)=sum; csum=csum+cost(j); data(ib,j)=s; end Z(ib,:)=cost; cmin=min(cost); if minfit>cmin minfit=cmin; end avgfit=csum/ngpool; [costmin,idx]=min(cost); distmin=gpool(idx,:); xj1(ib,:)=distmin; [csort,ridx]=sort(cost); dist_history(ib) = costmin; avg_history(ib)=mean(cost); min_history(ib)=min(cost); if costmin < global_min global_min = costmin; opt_rte(ib,:) = gpool(idx,:); end nogen=ib; sparent=proposedsimplega(gpool,N,ngpool,cost,nogen,ngen); om=1; for ik=1:4 for jk=ik+1:5 p1=gpool(sparent(ik),:); p2=gpool(sparent(jk),:); cross=ceil(N.*rand(1,1)); for wc=1:cross c1(wc)=p1(wc)*w; c2(wc)=p2(wc)*(1-w); end for wc=cross+1:N c1(wc)=p1(wc)*(1-w); c2(wc)=p2(wc)*w; end if om<ngpool newgpool(om,:)=c1; om=om+1; newgpool(om,:)=c2; om=om+1;

213

end end end gpool=newgpool; if mod(j,nm)==0 for ic=1:nmuts ix=ceil(ngpool*rand); iy=ceil(N*rand); gpool(ix,iy)=1-gpool(ix,iy); end %ic end w=w-0.01; end [min_dist, index] = min(dist_history); op_rte = opt_rte(index,:); disp(['minimum cost in proposed selection = ' num2str(min_dist)]) disp('optimum points = ') disp(num2str(op_rte)) tblvarcost=avg_history; avgroulette=mean(tblvarcost); disp(['average fitness in proposed selection = ' num2str(avgroulette)]) y=[1:1:ngen]; x1 = tblvarcost; tblvarmincost=dist_history; x2=tblvarmincost; yl5=tblvarcost; yl6=tblvarmincost; x=[1:1:ngen]; y1 = yl1; y2=yl3; y3=yl5; plot(x,y1,'-.*r',x,y2,'-.xg',x,y3,'-.ob') ylabel('Average fitness') xlabel('Generation') legend('Roulette wheel selection','Rank selection','Annealed selection') title('Comparison of average fitness in three approaches of Selection') figure x=[1:1:ngen]; y1= yl2; y2=yl4; y3=yl6; plot(x,y1,'-*r',x,y2,'-.xg',x,y3,'-.ob') ylabel('Minimum Fitness') xlabel('Generation') legend('Roulette wheel selection','Rank selection','Annealed selection') title('Comparison of Minimum fitness in three approaches of Selection') ******************************************************************************* %code for rastrigin function &comparison of roulette wheel, rank & annealed selection clear all clc format short g N=10; % number of bits in a chromosome ngpool=10; w=0.3; global_min=inf; data=zeros(ngen,ngpool); ngen=20; % number of generations % creates M random chromosomes with N bits a=-5.12; b=5.12; pi=3.14; agpool=a+(b-a)*rand(ngpool,N); % initial population gpool=agpool mutrate=0.1; nmuts=mutrate*N; nm=ngen/nmuts; Z=zeros(10,10); minfit=inf; newgpool=zeros(ngpool,N); for ib=1:ngen csum=0; n = ngpool; for j=1:ngpool sum=0; s = 0; for i=1:N

214

s = s+(gpool(j,i)^2-10*cos(2*pi*gpool(j,i))); end sum = 10*n+s; z(ib,j)=sum; cost(j)=sum; csum=csum+cost(j); data(ib,j)=s; end Z(ib,:)=cost; cmin=min(cost); if minfit>cmin minfit=cmin; end avgfit=csum/ngpool; [costmin,idx]=min(cost); distmin=gpool(idx,:); xj1(ib,:)=distmin; [csort,ridx]=sort(cost); dist_history(ib) = costmin; avg_history(ib)=mean(cost); min_history(ib)=min(cost); if costmin < global_min global_min = costmin; opt_rte(ib,:) = gpool(idx,:); end sparent=roulettesimplega(gpool,N,ngpool,cost); om=1; for ik=1:4 for jk=ik+1:5 p1=gpool(sparent(ik),:); p2=gpool(sparent(jk),:); cross=ceil(N.*rand(1,1)); for wc=1:cross c1(wc)=p1(wc)*w; c2(wc)=p2(wc)*(1-w); end for wc=cross+1:N c1(wc)=p1(wc)*(1-w); c2(wc)=p2(wc)*w; end if om<ngpool newgpool(om,:)=c1; om=om+1; newgpool(om,:)=c2; om=om+1; end end end gpool=newgpool; if mod(j,nm)==0 for ic=1:nmuts ix=ceil(ngpool*rand); iy=ceil(N*rand); gpool(ix,iy)=1-gpool(ix,iy); end %ic end w=w-0.01; end % Find the Maximum fitness [min_dist, index] = min(dist_history); op_rte = opt_rte(index,:); disp(['minimum cost in roulette selection = ' num2str(min_dist)]) disp('optimum points = ') disp(num2str(op_rte)) tblvarcost=avg_history; avgroulette=mean(tblvarcost); disp(['average fitness in roulette selection = ' num2str(avgroulette)]) y=[1:1:ngen]; x1 = tblvarcost; tblvarmincost=dist_history; x2=tblvarmincost; yl1=tblvarcost; yl2=tblvarmincost; % rank selection start gpool=agpool; w=0.3; minfit=inf; newgpool=zeros(ngpool,N); for ib=1:ngen

215

csum=0; n = ngpool; for j=1:ngpool sum=0; s = 0; for i=1:N s = s+(gpool(j,i)^2-10*cos(2*pi*gpool(j,i))); end sum = 10*n+s; z(ib,j)=sum; cost(j)=sum; csum=csum+cost(j); data(ib,j)=s; end Z(ib,:)=cost; cmin=min(cost); if minfit>cmin minfit=cmin; end avgfit=csum/ngpool; [costmin,idx]=min(cost); distmin=gpool(idx,:); xj1(ib,:)=distmin; [csort,ridx]=sort(cost); dist_history(ib) = costmin; avg_history(ib)=mean(cost); min_history(ib)=min(cost); if costmin < global_min global_min = costmin; opt_rte(ib,:) = gpool(idx,:); end for rk=1:ngpool rnkarray(rk)=rk; end ranksum=0; for r=1:ngpool rankarray(r,1)=rnkarray(r); rankarray(r,2)=ridx(r); rankarray(r,3)=csort(r); ranksum=ranksum+rankarray(r,1); end for r=1:ngpool prank(r)=(rankarray(r,1)/ranksum)*100; end ik=0; jk=0; sparent=ranksimplega(gpool,N,ngpool,cost,csort,rankarray,prank,ranksum); om=1; for ik=1:4 for jk=ik+1:5 p1=gpool(sparent(ik),:); p2=gpool(sparent(jk),:); cross=ceil(N.*rand(1,1)); for wc=1:cross c1(wc)=p1(wc)*w; c2(wc)=p2(wc)*(1-w); end for wc=cross+1:N c1(wc)=p1(wc)*(1-w); c2(wc)=p2(wc)*w; end if om<ngpool newgpool(om,:)=c1; om=om+1; newgpool(om,:)=c2; om=om+1; end end end gpool=newgpool; if mod(j,nm)==0 for ic=1:nmuts ix=ceil(ngpool*rand); iy=ceil(N*rand); gpool(ix,iy)=1-gpool(ix,iy);

216

end %ic end w=w-0.01; end [min_dist, index] = min(dist_history); op_rte = opt_rte(index,:); disp(['minimum cost in rank selection = ' num2str(min_dist)]) disp('optimum points = ') disp(num2str(op_rte)) tblvarcost=avg_history; avgroulette=mean(tblvarcost); disp(['average fitness in rank selection = ' num2str(avgroulette)]) y=[1:1:ngen]; x1 = tblvarcost; tblvarmincost=dist_history; x2=tblvarmincost; yl3=tblvarcost; yl4=tblvarmincost; %annealed selection start gpool=agpool; w=0.3; minfit=inf; newgpool=zeros(ngpool,N); for ib=1:ngen csum=0; n = ngpool; for j=1:ngpool sum=0; s = 0; for i=1:N s = s+(gpool(j,i)^2-10*cos(2*pi*gpool(j,i))); end sum = 10*n+s; z(ib,j)=sum; cost(j)=sum; csum=csum+cost(j); data(ib,j)=s; end Z(ib,:)=cost; cmin=min(cost); if minfit>cmin minfit=cmin; end avgfit=csum/ngpool; [costmin,idx]=min(cost); distmin=gpool(idx,:); xj1(ib,:)=distmin; [csort,ridx]=sort(cost); dist_history(ib) = costmin; avg_history(ib)=mean(cost); min_history(ib)=min(cost); if costmin < global_min global_min = costmin; opt_rte(ib,:) = gpool(idx,:); end nogen=ib; sparent=proposedsimplega(gpool,N,ngpool,cost,nogen,ngen); om=1; for ik=1:4 for jk=ik+1:5 p1=gpool(sparent(ik),:); p2=gpool(sparent(jk),:); cross=ceil(N.*rand(1,1)); for wc=1:cross c1(wc)=p1(wc)*w; c2(wc)=p2(wc)*(1-w); end for wc=cross+1:N c1(wc)=p1(wc)*(1-w); c2(wc)=p2(wc)*w; end if om<ngpool newgpool(om,:)=c1; om=om+1; newgpool(om,:)=c2; om=om+1; end end end gpool=newgpool;

217

if mod(j,nm)==0 for ic=1:nmuts ix=ceil(ngpool*rand); iy=ceil(N*rand); gpool(ix,iy)=1-gpool(ix,iy); end %ic end w=w-0.01; end [min_dist, index] = min(dist_history); op_rte = opt_rte(index,:); disp(['minimum cost in proposed selection = ' num2str(min_dist)]) disp('optimum points = ') disp(num2str(op_rte)) tblvarcost=avg_history; avgroulette=mean(tblvarcost); disp(['average fitness in proposed selection = ' num2str(avgroulette)]) y=[1:1:ngen]; x1 = tblvarcost; tblvarmincost=dist_history; x2=tblvarmincost; yl5=tblvarcost; yl6=tblvarmincost; x=[1:1:ngen]; y1 = yl1; y2=yl3; y3=yl5; plot(x,y1,'-.*r',x,y2,'-.xg',x,y3,'-.ob') ylabel('Average fitness') xlabel('Generation') legend('Roulette wheel selection','Rank selection','Annealed selection') title('Comparison of average fitness in three approaches of Selection') figure x=[1:1:ngen]; y1= yl2; y2=yl4; y3=yl6; plot(x,y1,'-*r',x,y2,'-.xg',x,y3,'-.ob') ylabel('Minimum Fitness') xlabel('Generation') legend('Roulette wheel selection','Rank selection','Annealed selection') title('Comparison of Minimum fitness in three approaches of Selection') ******************************************************************************* %%code for ackley’s function &comparison of roulette wheel, rank & annealed selection clear all clc format short g N=10; % number of bits in a chromosome ngpool=10; w=0.3; global_min=inf; data=zeros(ngen,ngpool); ngen=20; % number of generations % creates M random chromosomes with N bits a=-30; b=30; agpool=a+(b-a)*rand(ngpool,N); % initial population gpool=agpool mutrate=0.1; nmuts=mutrate*N; nm=ngen/nmuts; Z=zeros(10,10); minfit=inf; newgpool=zeros(ngpool,N); for ib=1:ngen csum=0; n = ngpool; for j=1:ngpool sum=0; pi=3.14; s = 0; a = 20; b = 0.2; c = 2*pi;s1 = 0; s2 = 0;

for i=1:N; s1 = s1+gpool(j,i)^2; s2 = s2+cos(c*gpool(j,i)); end y = -a*exp(-b*sqrt(1/n*s1))-exp(1/n*s2)+a+exp(1); sum=y; z(ib,j)=sum; cost(j)=sum; csum=csum+cost(j); data(ib,j)=s;

218

end Z(ib,:)=cost; cmin=min(cost); if minfit>cmin minfit=cmin; end avgfit=csum/ngpool; [costmin,idx]=min(cost); distmin=gpool(idx,:); xj1(ib,:)=distmin; [csort,ridx]=sort(cost); dist_history(ib) = costmin; avg_history(ib)=mean(cost); min_history(ib)=min(cost); if costmin < global_min global_min = costmin; opt_rte(ib,:) = gpool(idx,:); end sparent=roulettesimplega(gpool,N,ngpool,cost); om=1; for ik=1:4 for jk=ik+1:5 p1=gpool(sparent(ik),:); p2=gpool(sparent(jk),:); cross=ceil(N.*rand(1,1)); for wc=1:cross c1(wc)=p1(wc)*w; c2(wc)=p2(wc)*(1-w); end for wc=cross+1:N c1(wc)=p1(wc)*(1-w); c2(wc)=p2(wc)*w; end if om<ngpool newgpool(om,:)=c1; om=om+1; newgpool(om,:)=c2; om=om+1; end end end gpool=newgpool; if mod(j,nm)==0 for ic=1:nmuts ix=ceil(ngpool*rand); iy=ceil(N*rand); gpool(ix,iy)=1-gpool(ix,iy); end %ic end w=w-0.01; end % Find the Maximum fitness [min_dist, index] = min(dist_history); op_rte = opt_rte(index,:); disp(['minimum cost in roulette selection = ' num2str(min_dist)]) disp('optimum points = ') disp(num2str(op_rte)) tblvarcost=avg_history; avgroulette=mean(tblvarcost); disp(['average fitness in roulette selection = ' num2str(avgroulette)]) y=[1:1:ngen]; x1 = tblvarcost; tblvarmincost=dist_history; x2=tblvarmincost; yl1=tblvarcost; yl2=tblvarmincost; % rank selection start gpool=agpool; w=0.3; minfit=inf; newgpool=zeros(ngpool,N); for ib=1:ngen csum=0; n = ngpool; for j=1:ngpool sum=0; pi=3.14; s = 0; a = 20; b = 0.2; c = 2*pi;s1 = 0; s2 = 0; for i=1:N;

219

s1 = s1+gpool(j,i)^2; s2 = s2+cos(c*gpool(j,i)); end y = -a*exp(-b*sqrt(1/n*s1))-exp(1/n*s2)+a+exp(1); sum=y; z(ib,j)=sum; cost(j)=sum; csum=csum+cost(j); data(ib,j)=s; end Z(ib,:)=cost; cmin=min(cost); if minfit>cmin minfit=cmin; end avgfit=csum/ngpool; [costmin,idx]=min(cost); distmin=gpool(idx,:); xj1(ib,:)=distmin; [csort,ridx]=sort(cost); dist_history(ib) = costmin; avg_history(ib)=mean(cost); min_history(ib)=min(cost); if costmin < global_min global_min = costmin; opt_rte(ib,:) = gpool(idx,:); end for rk=1:ngpool rnkarray(rk)=rk; end ranksum=0; for r=1:ngpool rankarray(r,1)=rnkarray(r); rankarray(r,2)=ridx(r); rankarray(r,3)=csort(r); ranksum=ranksum+rankarray(r,1); end for r=1:ngpool prank(r)=(rankarray(r,1)/ranksum)*100; end ik=0; jk=0; sparent=ranksimplega(gpool,N,ngpool,cost,csort,rankarray,prank,ranksum); om=1; for ik=1:4 for jk=ik+1:5 p1=gpool(sparent(ik),:); p2=gpool(sparent(jk),:); cross=ceil(N.*rand(1,1)); for wc=1:cross c1(wc)=p1(wc)*w; c2(wc)=p2(wc)*(1-w); end for wc=cross+1:N c1(wc)=p1(wc)*(1-w); c2(wc)=p2(wc)*w; end if om<ngpool newgpool(om,:)=c1; om=om+1; newgpool(om,:)=c2; om=om+1; end end end gpool=newgpool; if mod(j,nm)==0 for ic=1:nmuts ix=ceil(ngpool*rand); iy=ceil(N*rand); gpool(ix,iy)=1-gpool(ix,iy); end %ic end w=w-0.01; end

220

[min_dist, index] = min(dist_history); op_rte = opt_rte(index,:); disp(['minimum cost in rank selection = ' num2str(min_dist)]) disp('optimum points = ') disp(num2str(op_rte)) tblvarcost=avg_history; avgroulette=mean(tblvarcost); disp(['average fitness in rank selection = ' num2str(avgroulette)]) y=[1:1:ngen]; x1 = tblvarcost; tblvarmincost=dist_history; x2=tblvarmincost; yl3=tblvarcost; yl4=tblvarmincost; %annealed selection start gpool=agpool; w=0.3; minfit=inf; newgpool=zeros(ngpool,N); for ib=1:ngen csum=0; n = ngpool; for j=1:ngpool sum=0; pi=3.14; s = 0; a = 20; b = 0.2; c = 2*pi;s1 = 0; s2 = 0; for i=1:N; s1 = s1+gpool(j,i)^2; s2 = s2+cos(c*gpool(j,i)); end y = -a*exp(-b*sqrt(1/n*s1))-exp(1/n*s2)+a+exp(1); sum=y; z(ib,j)=sum; cost(j)=sum; csum=csum+cost(j); data(ib,j)=s; end Z(ib,:)=cost; cmin=min(cost); if minfit>cmin minfit=cmin; end avgfit=csum/ngpool; [costmin,idx]=min(cost); distmin=gpool(idx,:); xj1(ib,:)=distmin; [csort,ridx]=sort(cost); dist_history(ib) = costmin; avg_history(ib)=mean(cost); min_history(ib)=min(cost); if costmin < global_min global_min = costmin; opt_rte(ib,:) = gpool(idx,:); end nogen=ib; sparent=proposedsimplega(gpool,N,ngpool,cost,nogen,ngen); om=1; for ik=1:4 for jk=ik+1:5 p1=gpool(sparent(ik),:); p2=gpool(sparent(jk),:); cross=ceil(N.*rand(1,1)); for wc=1:cross c1(wc)=p1(wc)*w; c2(wc)=p2(wc)*(1-w); end for wc=cross+1:N c1(wc)=p1(wc)*(1-w); c2(wc)=p2(wc)*w; end if om<ngpool newgpool(om,:)=c1; om=om+1; newgpool(om,:)=c2; om=om+1; end end end gpool=newgpool; if mod(j,nm)==0 for ic=1:nmuts

221

ix=ceil(ngpool*rand); iy=ceil(N*rand); gpool(ix,iy)=1-gpool(ix,iy); end %ic end w=w-0.01; end [min_dist, index] = min(dist_history); op_rte = opt_rte(index,:); disp(['minimum cost in proposed selection = ' num2str(min_dist)]) disp('optimum points = ') disp(num2str(op_rte)) tblvarcost=avg_history; avgroulette=mean(tblvarcost); disp(['average fitness in proposed selection = ' num2str(avgroulette)]) y=[1:1:ngen]; x1 = tblvarcost; tblvarmincost=dist_history; x2=tblvarmincost; yl5=tblvarcost; yl6=tblvarmincost; x=[1:1:ngen]; y1 = yl1; y2=yl3; y3=yl5; plot(x,y1,'-.*r',x,y2,'-.xg',x,y3,'-.ob') ylabel('Average fitness') xlabel('Generation') legend('Roulette wheel selection','Rank selection','Annealed selection') title('Comparison of average fitness in three approaches of Selection') figure x=[1:1:ngen]; y1= yl2; y2=yl4; y3=yl6; plot(x,y1,'-*r',x,y2,'-.xg',x,y3,'-.ob') ylabel('Minimum Fitness') xlabel('Generation') legend('Roulette wheel selection','Rank selection','Annealed selection') title('Comparison of Minimum fitness in three approaches of Selection') ******************************************************************************* %code for continuous step function &comparison of roulette wheel, rank & annealed selection clear all clc format short g N=10; % number of bits in a chromosome ngpool=10; w=0.3; global_min=inf; data=zeros(ngen,ngpool); ngen=20; % number of generations % creates M random chromosomes with N bits a=-5.12; b=5.12; agpool=a+(b-a)*rand(ngpool,N); % initial population gpool=agpool mutrate=0.1; nmuts=mutrate*N; nm=ngen/nmuts; Z=zeros(10,10); minfit=inf; newgpool=zeros(ngpool,N); for ib=1:ngen csum=0; n = ngpool; for j=1:ngpool sum=0; s = 0; for i=1:N sum=sum+(abs(gpool(j,i)));); end z(ib,j)=sum; cost(j)=sum; csum=csum+cost(j); data(ib,j)=sum; end Z(ib,:)=cost; cmin=min(cost); if minfit>cmin minfit=cmin;

222

end avgfit=csum/ngpool; [costmin,idx]=min(cost); distmin=gpool(idx,:); xj1(ib,:)=distmin; [csort,ridx]=sort(cost); dist_history(ib) = costmin; avg_history(ib)=mean(cost); min_history(ib)=min(cost); if costmin < global_min global_min = costmin; opt_rte(ib,:) = gpool(idx,:); end sparent=roulettesimplega(gpool,N,ngpool,cost); om=1; for ik=1:4 for jk=ik+1:5 p1=gpool(sparent(ik),:); p2=gpool(sparent(jk),:); cross=ceil(N.*rand(1,1)); for wc=1:cross c1(wc)=p1(wc)*w; c2(wc)=p2(wc)*(1-w); end for wc=cross+1:N c1(wc)=p1(wc)*(1-w); c2(wc)=p2(wc)*w; end if om<ngpool newgpool(om,:)=c1; om=om+1; newgpool(om,:)=c2; om=om+1; end end end gpool=newgpool; if mod(j,nm)==0 for ic=1:nmuts ix=ceil(ngpool*rand); iy=ceil(N*rand); gpool(ix,iy)=1-gpool(ix,iy); end %ic end w=w-0.01; end % Find the Maximum fitness [min_dist, index] = min(dist_history); op_rte = opt_rte(index,:); disp(['minimum cost in roulette selection = ' num2str(min_dist)]) disp('optimum points = ') disp(num2str(op_rte)) tblvarcost=avg_history; avgroulette=mean(tblvarcost); disp(['average fitness in roulette selection = ' num2str(avgroulette)]) y=[1:1:ngen]; x1 = tblvarcost; tblvarmincost=dist_history; x2=tblvarmincost; yl1=tblvarcost; yl2=tblvarmincost; % rank selection start gpool=agpool; w=0.3; minfit=inf; newgpool=zeros(ngpool,N); for ib=1:ngen csum=0; n = ngpool; for j=1:ngpool sum=0; s = 0; for i=1:N

sum=sum+(abs(gpool(j,i))); end z(ib,j)=sum; cost(j)=sum; csum=csum+cost(j); data(ib,j)=sum; end

223

Z(ib,:)=cost; cmin=min(cost); if minfit>cmin minfit=cmin; end avgfit=csum/ngpool; [costmin,idx]=min(cost); distmin=gpool(idx,:); xj1(ib,:)=distmin; [csort,ridx]=sort(cost); dist_history(ib) = costmin; avg_history(ib)=mean(cost); min_history(ib)=min(cost); if costmin < global_min global_min = costmin; opt_rte(ib,:) = gpool(idx,:); end for rk=1:ngpool rnkarray(rk)=rk; end ranksum=0; for r=1:ngpool rankarray(r,1)=rnkarray(r); rankarray(r,2)=ridx(r); rankarray(r,3)=csort(r); ranksum=ranksum+rankarray(r,1); end for r=1:ngpool prank(r)=(rankarray(r,1)/ranksum)*100; end ik=0; jk=0; sparent=ranksimplega(gpool,N,ngpool,cost,csort,rankarray,prank,ranksum); om=1; for ik=1:4 for jk=ik+1:5 p1=gpool(sparent(ik),:); p2=gpool(sparent(jk),:); cross=ceil(N.*rand(1,1)); for wc=1:cross c1(wc)=p1(wc)*w; c2(wc)=p2(wc)*(1-w); end for wc=cross+1:N c1(wc)=p1(wc)*(1-w); c2(wc)=p2(wc)*w; end if om<ngpool newgpool(om,:)=c1; om=om+1; newgpool(om,:)=c2; om=om+1; end end end gpool=newgpool; if mod(j,nm)==0 for ic=1:nmuts ix=ceil(ngpool*rand); iy=ceil(N*rand); gpool(ix,iy)=1-gpool(ix,iy); end %ic end w=w-0.01; end [min_dist, index] = min(dist_history); op_rte = opt_rte(index,:); disp(['minimum cost in rank selection = ' num2str(min_dist)]) disp('optimum points = ') disp(num2str(op_rte)) tblvarcost=avg_history; avgroulette=mean(tblvarcost);

224

disp(['average fitness in rank selection = ' num2str(avgroulette)]) y=[1:1:ngen]; x1 = tblvarcost; tblvarmincost=dist_history; x2=tblvarmincost; yl3=tblvarcost; yl4=tblvarmincost; %annealed selection start gpool=agpool; w=0.3; minfit=inf; newgpool=zeros(ngpool,N); for ib=1:ngen csum=0; n = ngpool; for j=1:ngpool sum=0; s = 0; for i=1:N sum=sum+(abs(gpool(j,i))); end z(ib,j)=sum; cost(j)=sum; csum=csum+cost(j); data(ib,j)=sum; end Z(ib,:)=cost; cmin=min(cost); if minfit>cmin minfit=cmin; end avgfit=csum/ngpool; [costmin,idx]=min(cost); distmin=gpool(idx,:); xj1(ib,:)=distmin; [csort,ridx]=sort(cost); dist_history(ib) = costmin; avg_history(ib)=mean(cost); min_history(ib)=min(cost); if costmin < global_min global_min = costmin; opt_rte(ib,:) = gpool(idx,:); end nogen=ib; sparent=proposedsimplega(gpool,N,ngpool,cost,nogen,ngen); om=1; for ik=1:4 for jk=ik+1:5 p1=gpool(sparent(ik),:); p2=gpool(sparent(jk),:); cross=ceil(N.*rand(1,1)); for wc=1:cross c1(wc)=p1(wc)*w; c2(wc)=p2(wc)*(1-w); end for wc=cross+1:N c1(wc)=p1(wc)*(1-w); c2(wc)=p2(wc)*w; end if om<ngpool newgpool(om,:)=c1; om=om+1; newgpool(om,:)=c2; om=om+1; end end end gpool=newgpool; if mod(j,nm)==0 for ic=1:nmuts ix=ceil(ngpool*rand); iy=ceil(N*rand); gpool(ix,iy)=1-gpool(ix,iy); end %ic end w=w-0.01; end [min_dist, index] = min(dist_history); op_rte = opt_rte(index,:); disp(['minimum cost in proposed selection = ' num2str(min_dist)]) disp('optimum points = ')

225

disp(num2str(op_rte)) tblvarcost=avg_history; avgroulette=mean(tblvarcost); disp(['average fitness in proposed selection = ' num2str(avgroulette)]) y=[1:1:ngen]; x1 = tblvarcost; tblvarmincost=dist_history; x2=tblvarmincost; yl5=tblvarcost; yl6=tblvarmincost; x=[1:1:ngen]; y1 = yl1; y2=yl3; y3=yl5; plot(x,y1,'-.*r',x,y2,'-.xg',x,y3,'-.ob') ylabel('Average fitness') xlabel('Generation') legend('Roulette wheel selection','Rank selection','Annealed selection') title('Comparison of average fitness in three approaches of Selection') figure x=[1:1:ngen]; y1= yl2; y2=yl4; y3=yl6; plot(x,y1,'-*r',x,y2,'-.xg',x,y3,'-.ob') ylabel('Minimum Fitness') xlabel('Generation') legend('Roulette wheel selection','Rank selection','Annealed selection') title('Comparison of Minimum fitness in three approaches of Selection') ******************************************************************************* %%Code for GA search for TSP clear all close all clc tic; N=10; pos=rand(N,2); pointdistance=mydist(pos,pos); figure(1); plot(pos(:,1),pos(:,2),'o'); axis([0 1 0 1]), axis square; title('Plot of points to be searched'); for i=1:N text(pos(i,1)+.03,pos(i,2),int2str(i)); end ngen=5000; ngpool = 10; gpool=zeros(ngpool,N); for i=1:ngpool, gpool(i,:)=[1 randomize([2:N]')']; end costmin=N; distmin=zeros(1,N); cost=zeros(1,ngpool); for i=1:ngen, for i=1:ngpool, cost(i)=sum(diag(pointdistance(gpool(i,:)',rshift(gpool(i,:))'))); end [costmin,idx]=min(cost); distmin=gpool(idx,:); [csort,ridx]=sort(cost); mother=gpool(ridx(1),:); father=gpool(ridx(2),:); sameidx=[father==mother]; diffidx=find(sameidx==0); boy=father.*sameidx; boy(diffidx)=randomize(father(diffidx)')'; girl=mother.*sameidx; girl(diffidx)=randomize(mother(diffidx)')'; gpool=[gpool(ridx(1:ngpool-2),:);boy;girl]; end disp(['minmum cost with Haploid with only crossbreeding= ' num2str(costmin)]) disp('optimum points with haploid with only crossbreeding = ') disp(num2str(distmin))

226

disp(['time taken to search with Haploid with only crossbreeding= ' num2str(toc)]) tic; disp('-----------------------------------------------------------------------------'); figure(2); plot(pos(:,1),pos(:,2),'o'),axis([0 1 0 1]), axis square, hold on trip=pos(distmin',:); trip=[trip; trip(1,:)]; plot(trip(:,1),trip(:,2),'-') title(['Haploid search cost with only crossbreeding = ' num2str(costmin)]) hold off ngpool = 3; gpool=zeros(ngpool,N); for i=1:ngpool, gpool(i,:)=[1 randomize([2:N]')']; end costmin=N; distmin=zeros(1,N); cost=zeros(1,ngpool); for i=1:ngen, for i=1:ngpool, cost(i)=sum(diag(pointdistance(gpool(i,:)',rshift(gpool(i,:))'))); end [costmin,idx]=min(cost); distmin=gpool(idx,:); [csort,ridx]=sort(cost); mother=gpool(ridx(1),:); father=gpool(ridx(2),:); sameidx=[father==mother]; diffidx=find(sameidx==0); boy=father.*sameidx; boy(diffidx)=randomize(father(diffidx)')'; girl=mother.*sameidx; girl(diffidx)=randomize(mother(diffidx)')'; gpool=[gpool(ridx(1:ngpool-2),:);boy;girl]; end disp(['minmum cost with Diploid with only crossbreeding= ' num2str(costmin)]) disp('optimum points with Diploid with only crossbreeding = ') disp(num2str(distmin)) disp(['time taken to search with Diploid with only crossbreeding= ' num2str(toc)]) tic; disp('-----------------------------------------------------------------------------'); figure(3); plot(pos(:,1),pos(:,2),'o'),axis([0 1 0 1]), axis square, hold on trip=pos(distmin',:); trip=[trip; trip(1,:)]; plot(trip(:,1),trip(:,2),'-') title(['Diploid search cost with only crossbreeding = ' num2str(costmin)]) hold off ngen=1000; ngpool = 2; gpool=zeros(ngpool,N); for i=1:ngpool, gpool(i,:)=[1 randomize([2:N]')']; end costmin=N; distmin=zeros(1,N); cost=zeros(1,ngpool); for i=1:ngen, for i=1:ngpool, cost(i)=sum(diag(pointdistance(gpool(i,:)',rshift(gpool(i,:))'))); end [costmin,idx]=min(cost); distmin=gpool(idx,:); [csort,ridx]=sort(cost); mother=gpool(ridx(1),:); father=gpool(ridx(2),:) sameidx=[father==mother];

227

diffidx=find(sameidx==0); boy=[1 randomize([2:N]')']; girl=[1 randomize([2:N]')']; gpool=[gpool(ridx(1:ngpool-2),:);boy;girl];end disp(['minmum cost with Haploid with mutation= ' num2str(costmin)]) disp('optimum points with Haploid with mutation= ') disp(num2str(distmin)) disp(['time taken to search with Haploid with mutation= ' num2str(toc)]) tic; disp('-----------------------------------------------------------------------------'); figure(4); plot(pos(:,1),pos(:,2),'o'),axis([0 1 0 1]), axis square, hold on trip=pos(distmin',:); trip=[trip; trip(1,:)]; plot(trip(:,1),trip(:,2),'-') title(['Haploid search cost with mutation = ' num2str(costmin)]) hold off ngpool = 3; gpool=zeros(ngpool,N); for i=1:ngpool, gpool(i,:)=[1 randomize([2:N]')']; end costmin=N; distmin=zeros(1,N); cost=zeros(1,ngpool); for i=1:ngen, for i=1:ngpool, cost(i)=sum(diag(pointdistance(gpool(i,:)',rshift(gpool(i,:))'))); end [costmin,idx]=min(cost); distmin=gpool(idx,:); [csort,ridx]=sort(cost); mother=gpool(ridx(1),:); father=gpool(ridx(2),:); sameidx=[father==mother]; diffidx=find(sameidx==0); boy=[1 randomize([2:N]')']; girl=[1 randomize([2:N]')']; gpool=[gpool(ridx(1:ngpool-2),:);boy;girl]; end disp(['minmum cost with Diploid with mutation= ' num2str(costmin)]) disp('optimum points with Diploid with mutation= ') disp(num2str(distmin)) disp(['time taken to search with Diploid with mutation= ' num2str(toc)]) tic; disp('-----------------------------------------------------------------------------'); figure(5); plot(pos(:,1),pos(:,2),'o'),axis([0 1 0 1]), axis square, hold on trip=pos(distmin',:); trip=[trip; trip(1,:)]; plot(trip(:,1),trip(:,2),'-') title(['Diploid search cost with mutation= ' num2str(costmin)]) hold off ngen=1000; ngpool = 2; gpool=zeros(ngpool,N); for i=1:ngpool, gpool(i,:)=[0.1 randomize1([2:N]')']; end costmin=N; distmin=zeros(1,N); cost=zeros(1,ngpool); for i=1:ngen, for i=1:ngpool, cost(i)=sum(diag(pointdistance(10*gpool(i,:)',rshift(10*gpool(i,:))')));

228

end [costmin,idx]=min(cost); distmin=gpool(idx,:); [csort,ridx]=sort(cost); mother=gpool(ridx(1),:); father=gpool(ridx(2),:); sameidx=[father==mother]; diffidx=find(sameidx==0); boy=father.*sameidx; boy(diffidx)=randomize(father(diffidx)')'; girl=mother.*sameidx; girl(diffidx)=randomize(mother(diffidx)')'; gpool=[gpool(ridx(1:ngpool-2),:);boy;girl]; end disp(['minmum cost with Haploid with Real Number Encoding= ' num2str(costmin)]) disp('optimum points with haploid with Real Number Encoding = ') disp(num2str(distmin)) disp(['time taken to search with haploid with Real Number Encoding = ' num2str(toc)]) tic; disp('-----------------------------------------------------------------------------'); figure(6); plot(pos(:,1),pos(:,2),'o'),axis([0 1 0 1]), axis square, hold on trip=pos(10*distmin',:); trip=[trip; trip(1,:)]; plot(trip(:,1),trip(:,2),'-') title(['Haploid search cost with Real Number Encoding= ' num2str(costmin)]) hold off ngpool = 3; gpool=zeros(ngpool,N); for i=1:ngpool, gpool(i,:)=[0.1 randomize1([2:N]')']; end costmin=N; distmin=zeros(1,N); cost=zeros(1,ngpool); for i=1:ngen, for i=1:ngpool, cost(i)=sum(diag(pointdistance(10*gpool(i,:)',rshift(10*gpool(i,:))'))); end [costmin,idx]=min(cost); distmin=gpool(idx,:); [csort,ridx]=sort(cost); mother=gpool(ridx(1),:); father=gpool(ridx(2),:); sameidx=[father==mother]; diffidx=find(sameidx==0); boy=father.*sameidx; boy(diffidx)=randomize(father(diffidx)')'; girl=mother.*sameidx; girl(diffidx)=randomize(mother(diffidx)')'; gpool=[gpool(ridx(1:ngpool-2),:);boy;girl]; end disp(['minmum cost with Diploid with Binar Number Encoding= ' num2str(costmin)]) disp('optimum points with Diploid with Binary Number Encoding = ') disp(num2str(distmin)) disp(['time taken to search with Diploid with Binary Number Encoding = ' num2str(toc)]) figure(7); plot(pos(:,1),pos(:,2),'o'),axis([0 1 0 1]), axis square, hold on trip=pos(10*distmin',:); trip=[trip; trip(1,:)]; plot(trip(:,1),trip(:,2),'-') title(['Diploid search cost with Binary Number Encoding = ' num2str(costmin)]) hold off

229

%code to generate TSP distance function d=mydist(X,W,type,para) if nargin < 2, error('must have two or more arguments!'); d=[]; return; end [K,M]=size(X); [C,M1]=size(W); if M~=M1, error('X and W should have the same no of columns!'); end if nargin <3, type=0; % default is L2 norm end if type == 3, if nargin < 4, disp('weight matrices are not given, use identity matrices as default'); for i=1:C, para{i}=eye(M); end end end if type==0, % L2 norm d=[]; if C <=K, % compute by column for i=1:C, tmp=X-ones(K,1)*W(i,:); tmp1=sqrt(sum(tmp'.*tmp')); d=[d tmp1']; % K x i end elseif C>K, % compute by row for i=1:K, tmp=ones(C,1)*X(i,:)-W; tmp1=sqrt(tmp'.*tmp'); d=[d; tmp1]; end end elseif type==1, % L1 norm d=[]; if C <=K, % compute by column for i=1:C, d=[d sum(abs(X'-W(i,:)'*ones(1,K)))']; end elseif K < C, % compute by row for i=1:K, d=[d; sum(abs(X(i,:)'*ones(1,C)-W'))]; end end elseif type==2, % L_inf norm d=[]; if C <=K, % compute by column for i=1:C, d=[d max(abs(X'-W(i,:)'*ones(1,K)))']; end elseif K < C, % compute by row for i=1:K, d=[d; max(abs(X(i,:)'*ones(1,C)-W'))]; end end

230

elseif type==3, % L2 norm with covariance matrix % calculate x-w d=[]; for i=1:C, dxw=X-ones(K,1)*w(i,:); d = [d sum((para{i}*dxw').*dxw')']; end end ******************************************************************************* %code for randomising population function [B,I]=randomize(A,rowcol) rand('state',sum(100*clock)) if nargin == 1, rowcol=0; end if rowcol==0, [m,n]=size(A); p=rand(m,1); [p1,I]=sort(p); B=A(I,:); elseif rowcol==1, Ap=A'; [m,n]=size(Ap); p=rand(m,1); [p1,I]=sort(p); B=Ap(I,:)'; end ******************************************************************************** %code for random data function [B,I]=randomize1(A,rowcol) rand('state',sum(100*clock)) if nargin == 1, rowcol=0; end if rowcol==0, [m,n]=size(A); p=rand(m,1); [p1,I]=sort(p); B=A(I,:)/10; elseif rowcol==1, Ap=A'; [m,n]=size(Ap); p=rand(m,1); [p1,I]=sort(p); B=Ap(I,:)/10'; end ****************************************************************************** %DIPLOID 10CITIES %code for GA for TSP problem to compare haploid chromosome with diploid chromosome clear all clear clc close all tic; N=10; pos=rand(N,2); pointdistance=mydist(pos,pos); figure(1);

231

plot(pos(:,1),pos(:,2),'*'); axis([0 1 0 1]), axis square; title('Plot of points to be searched'); for i=1:N text(pos(i,1)+.03,pos(i,2),int2str(i)); end hold off ngen=1000; ngpool = 10; gpool=zeros(ngpool,N); newgpool=zeros(ngpool,N); newpop=zeros(ngpool,N); global_min = Inf; for i=1:ngpool, gpool(i,:)=randperm(N); end costmin=N; distmin=zeros(1,N); cost=zeros(1,ngpool); figure(2); for j=1:ngen for k=1:2:10 for s=1:ngpool cost(s)=sum(diag(pointdistance(gpool(s,:)',rshift(gpool(s,:))'))); end [costmin,idx]=min(cost); distmin=gpool(idx,:); [csort,ridx]=sort(cost); dist_history(j) = costmin; if costmin < global_min global_min = costmin; opt_rte(j,:) = gpool(idx,:); end rand_pair = randperm(ngpool); rtes = gpool(rand_pair(ridx(k)),:); parent(1,:)=rtes; parent(2,:)=rand_pair; nKids = 2; xoverKids = cell(nKids,1); index = 1; for i=1:nKids p1 = ceil((length(parent(1,:)) -1) * rand); p2 = p1 + ceil((length(parent(2,:)) - p1- 1) * rand); child = parent(i,:); child(p1:p2) = fliplr(child(p1:p2)); l=k+i-1; newgpool(l,:)=child; end end plot(pos(:,1),pos(:,2),'o'),axis([0 1 0 1]), axis square, hold on trip=pos(distmin',:); trip=[trip; trip(1,:)]; plot(trip(:,1),trip(:,2),'-') title(sprintf(' Haploid Total Distance = %1.4f, Iteration = %d',costmin,j)); gpool=newgpool; hold off end % Find the Minimum Distance Route [min_dist, index] = min(dist_history); op_rte = opt_rte(index,:); disp(['minimum cost with Haploid with only crossbreeding= ' num2str(min_dist)]) disp('optimum points with haploid with only crossbreeding = ') disp(num2str(op_rte)) disp(['time taken to search with Haploid with only crossbreeding= ' num2str(toc)]) tic; disp('-----------------------------------------------------------------------------'); figure(3); plot(pos(:,1),pos(:,2),'o'),axis([0 1 0 1]), axis square, hold on trip=pos(op_rte',:); trip=[trip; trip(1,:)]; plot(trip(:,1),trip(:,2),'-') title(['Haploid search cost with only crossbreeding = ' num2str(min_dist)])

232

hold off ngen=1000; ngpool = 20; gpool=zeros(ngpool,N); dminpool=zeros(10,N); newgpool=zeros(10,N); newpop=zeros(ngpool,N); global_min = Inf; for i=1:ngpool, gpool(i,:)=randperm(N); end costmin=N; distmin=zeros(1,N); dcost=zeros(1,ngpool); cost=zeros(1,10); figure(4); for s=1:ngpool dcost(s)=sum(diag(pointdistance(gpool(s,:)',rshift(gpool(s,:))'))); end ss=1; for sa=1:2:ngpool if dcost(sa)<dcost(sa+1) dminpool(ss,:)=gpool(sa,:); else dminpool(ss,:)=gpool(sa+1,:); end ss=ss+1; end for j=1:ngen for k=1:2:10 for s=1:10 cost(s)=sum(diag(pointdistance(dminpool(s,:)',rshift(dminpool(s,:))'))); end [costmin,idx]=min(cost); distmin=dminpool(idx,:); [csort,ridx]=sort(cost); dist_history(j) = costmin; if costmin < global_min global_min = costmin; opt_rte(j,:) = dminpool(idx,:); end rand_pair = randperm(10); rtes = dminpool(rand_pair(ridx(k)),:); parent(1,:)=rtes; parent(2,:)=rand_pair; nKids = 2; xoverKids = cell(nKids,1); index = 1; for i=1:nKids p1 = ceil((length(parent(1,:)) -1) * rand); p2 = p1 + ceil((length(parent(2,:)) - p1- 1) * rand); child = parent(i,:); child(p1:p2) = fliplr(child(p1:p2)); l=k+i-1; newgpool(l,:)=child; end end plot(pos(:,1),pos(:,2),'o'),axis([0 1 0 1]), axis square, hold on trip=pos(distmin',:); trip=[trip; trip(1,:)]; plot(trip(:,1),trip(:,2),'-') title(sprintf('Diploid Total Distance = %1.4f, Iteration = %d',costmin,j)); dminpool=newgpool; hold off end [min_dist, index] = min(dist_history); op_rte = opt_rte(index,:); disp(['minimum cost with Diploid with only crossbreeding= ' num2str(min_dist)]) disp('optimum points with diploid with only crossbreeding = ')

233

disp(num2str(op_rte)) disp(['time taken to search with Diploid with only crossbreeding= ' num2str(toc)]) tic; disp('-----------------------------------------------------------------------------'); figure(5); plot(pos(:,1),pos(:,2),'o'),axis([0 1 0 1]), axis square, hold on trip=pos(op_rte',:); trip=[trip; trip(1,:)]; plot(trip(:,1),trip(:,2),'-') title(['Diploid search cost with only crossbreeding = ' num2str(min_dist)]) hold off *************************************************************************** %GA FINAL POLYGAMY MAIN clear all clear clc close all N=51; ngen=100; ngpool = 50; gpool=zeros(ngpool,N); opt_rte=zeros(ngpool,N); newgpool=zeros(ngpool,N); newpop=zeros(ngpool,N); global_min = Inf; a=e51function(N); costmin=N; distmin=zeros(1,N); cost=zeros(1,N); for i=1:ngpool gpool(i,:)=randperm(N); end agpool=gpool; a agpool [rl1 rl2]=rouletteseleloop(N,ngpool,agpool,a,ngen); [rnk1 rnk2]=rankseleloop(N,ngpool,agpool,a,ngen); [pr1 pr2]= proposedseleloop(N,ngpool,agpool,a,ngen); [prl1 prl2]=pgamyrouletteseleloop(N,ngpool,agpool,a,ngen); [prnk1 prnk2]=pgamyrankseleloop(N,ngpool,agpool,a,ngen); [ppr1 ppr2]= pgamyproposedseleloop(N,ngpool,agpool,a,ngen); figure x=[1:1:ngen]; y1 = rl1; y2=rnk1; y3=pr1; y4 = prl1; y5=prnk1; y6=ppr1; plot(x,y1,'-.*r',x,y2,'-.*b',x,y3,'-.*m',x,y4,'-.or',x,y5,'-.ob',x,y6,'-.om') ylabel('Average tour length') xlabel('Generation') legend('Roulette Wheel Selection','Rank Selection','Annealed Selection','Polygamy with Roulette Wheel Selection','Polygamy with Rank Selection','Polygamy with Annealed Selection') title('Comparison of Average tour length in six approaches of Selection') figure x=[1:1:ngen]; y1= rl2; y2=rnk2; y3=pr2; y4= prl2; y5=prnk2; y6=ppr2; plot(x,y1,'-.*r',x,y2,'-.*b',x,y3,'-.*m',x,y4,'-.or',x,y5,'-.ob',x,y6,'-.om') ylabel('Minimum tour length') xlabel('Generation') legend('Roulette Wheel Selection','Rank Selection','Annealed Selection','Polygamy with Roulette Wheel Selection','Polygamy with Rank Selection','Polygamy with Annealed Selection') title('Comparison of Minimum tour length in six approaches of Selection') ********************************************************************************

234

%code to implement annealed selection with polygamy function [y1,y2]=pgamyproposedseleloop(N,ngpool,agpool,a,ngen)

gpool=agpool; cost=costfn(N,ngpool,gpool,a); global_min = Inf; mutrate=0.05; nmuts=mutrate*N; nm=ngen/nmuts; for j=1:ngen

nogen=j; om=1; [costmin,idx]=min(cost); distmin=gpool(idx,:); [csort,ridx]=sort(cost); dist_history(j) = costmin; avg_history(j)=mean(cost); min_history(j)=min(cost);

if costmin < global_min global_min = costmin; opt_rte(j,:) = gpool(idx,:); end p1=distmin; sparent=blendsel(gpool,N,ngpool,cost,nogen,ngen); ik=1; pc=1; [spcol spsize]=size(sparent); octr=1; while pc<=spsize p2=gpool(sparent(pc),:); pc=pc+1; [c1 c2]=funcpmxco(N,ngpool,p1,p2); offpool(octr,:)=c1; octr=octr+1; offpool(octr,:)=c2; octr=octr+1; end ocost=costfn(N,ngpool,offpool,a); [ofsort,odx]=sort(ocost); while om<= ngpool newgpool(om,:)=offpool(odx(om),:); om=om+1; end gpool=newgpool; if mod(j,nm)==0

inversion(nmuts,gpool,ngpool,N); end cost=costfn(N,ngpool,gpool,a);

end % Find the Minimum Distance Route [min_dist, index] = min(dist_history); op_rte = opt_rte(index,:); disp(['minimum cost in proposed selection = ' num2str(min_dist)]) disp('optimum points = ') disp(num2str(op_rte)) tblvarcost=avg_history; avgproposed=mean(tblvarcost); disp(['average fitness in roulette selection = ' num2str(avgproposed)]) y=[1:1:ngen]; x1 = tblvarcost; tblvarmincost=dist_history; x2=tblvarmincost; y1=tblvarcost; y2=tblvarmincost; end ******************************************************************************* %code for main ga for extended polygamy clear all clear clc close all N=51; ngen=100; ngpool = 50; gpool=zeros(ngpool,N); opt_rte=zeros(ngpool,N); newgpool=zeros(ngpool,N); newpop=zeros(ngpool,N); global_min = Inf; a=e51function(N); costmin=N; distmin=zeros(1,N); cost=zeros(1,N); for i=1:ngpool gpool(i,:)=randperm(N);

235

end agpool=gpool; p=size(agpool); [rl1 rl2]=rouletteseleloop(N,ngpool,agpool,a,ngen); [rnk1 rnk2]=rankseleloop(N,ngpool,agpool,a,ngen); [pr1 pr2]= proposedseleloop(N,ngpool,agpool,a,ngen); [prl1 prl2]=pgamyrouletteseleloop(N,ngpool,agpool,a,ngen); [prnk1 prnk2]=pgamyrankseleloop(N,ngpool,agpool,a,ngen); [ppr1 ppr2]= pgamyproposedseleloop(N,ngpool,agpool,a,ngen); [crl1 crl2]=pgamycomptrouletteseleloop(N,ngpool,agpool,a,ngen); [crnk1 crnk2]=pgamycomptrankseleloop(N,ngpool,agpool,a,ngen); [cpr1 cpr2]= pgamycomptproposedseleloop(N,ngpool,agpool,a,ngen); [abprl1 abprl2]=aplusbrouletteseleloop(N,ngpool,agpool,a,ngen); [abprnk1 abprnk2]=aplusbrankseleloop(N,ngpool,agpool,a,ngen); [abppr1 abppr2]=aplusbproposedseleloop(N,ngpool,agpool,a,ngen); figure x=[1:1:ngen]; y1 = rl1; y2=rnk1; y3=pr1; y4 = prl1; y5=prnk1; y6=ppr1; y7 = crl1; y8=crnk1; y9=cpr1; y10=abprl1; y11=abprnk1; y12=abppr1; plot(x,y1,'-.*k',x,y2,'-.xk',x,y3,'-.ok',x,y4,'-.*r',x,y5,'-.xr',x,y6,'-.or',x,y7,'-.*b',x,y8,'-.xb',x,y9,'-.ob',x,y10,'-.*m',x,y11,'-.xm',x,y12,'-.om') ylabel('Average Distance') xlabel('Generation') legend('Roulette wheel selection','Rank selection','Annealed selection','Polygamy & Roulette wheel','Polygamy & Rank','Polgamy & Annealed','\mu+\lambda Polygamy & Roulette wheel','\mu+\lambda Polygamy & Rank','\mu+\lambda Polygamy & Annealed','Extended \mu+\lambda Polygamy & Roulette wheel','Extended \mu+\lambda Polygamy & Rank','Extended \mu+\lambda Polygamy & Annealed') title('Comparison of average tourlength') figure x=[1:1:ngen]; y1= rl2; y2=rnk2; y3=pr2; y4= prl2; y5=prnk2; y6=ppr2; y7= crl2; y8=crnk2; y9=cpr2; y10=abprl2; y11=abprnk2; y12=abppr2; plot(x,y1,'-.*k',x,y2,'-.xk',x,y3,'-.ok',x,y4,'-.*r',x,y5,'-.xr',x,y6,'-.or',x,y7,'-.*b',x,y8,'-.xb',x,y9,'-.ob',x,y10,'-.*m',x,y11,'-.xm',x,y12,'-.om') ylabel('Minimum Distance') xlabel('Generation') legend('Roulette wheel selection','Rank selection','Annealed selection','Polygamy & Roulette wheel','Polygamy & Rank','Polgamy & Annealed','\mu+\lambda Polygamy & Roulette wheel','\mu+\lambda Polygamy & Rank','\mu+\lambda Polygamy & Annealed','Extended \mu+\lambda Polygamy & Roulette wheel','Extended \mu+\lambda Polygamy & Rank','Extended \mu+\lambda Polygamy & Annealed') title('Comparison of minimum tourlength') ******************************************************************************* %code for µ+λ polygamy with annealed selection function [y1,y2]=aplusbproposedseleloop(N,ngpool,agpool,a,ngen)

gpool=agpool; cost=costfn(N,ngpool,gpool,a); global_min = Inf; prevcost=inf; mutrate=0.5; nmuts=mutrate*N*(ngpool-1); for j=1:ngen nogen=j; om=1; cost=costfn(N,ngpool,gpool,a); [costmin,idx]=min(cost); distmin=gpool(idx,:);

236

[csort,ridx]=sort(cost); dist_history(j) = costmin; avg_history(j)=mean(cost); min_history(j)=min(cost); if costmin < global_min global_min = costmin;

opt_rte(j,:) = gpool(idx,:); end if costmin<prevcost prev=distmin; prevcost=costmin;

% 'new best better' else

% 'prev better' prevcost=csort(2); prev=gpool(ridx(2),:); end

p1=prev; sparent=blendsel(gpool,N,ngpool,cost,nogen,ngen);

ik=1; pc=1; [spcol spsize]=size(sparent); octr=1; while pc<=spsize p2=gpool(sparent(pc),:); pc=pc+1; [c1 c2]=funcpmxco(N,ngpool,p1,p2); offpool(octr,:)=c1; octr=octr+1; offpool(octr,:)=c2; octr=octr+1; end ocost=costfn(N,ngpool,offpool,a); [ofsort,odx]=sort(ocost); while om<= ngpool newgpool(om,:)=offpool(odx(om),:); om=om+1;

end gpool=newgpool; inversion(nmuts,gpool,ngpool,N); end [min_dist, index] = min(dist_history); op_rte = opt_rte(index,:); disp(['minimum cost in proposed selection = ' num2str(min_dist)]) disp('optimum points = ') disp(num2str(op_rte)) tblvarcost=avg_history; avgproposed=mean(tblvarcost); disp(['average fitness in PROPOSED selection = ' num2str(avgproposed)]) y=[1:1:ngen]; x1 = tblvarcost; tblvarmincost=dist_history; x2=tblvarmincost; y1=tblvarcost; y2=tblvarmincost;

end ***************************************************************************** %code for main GA program for comparing replacement strategies clear all clear clc close all N=51; ngen=100; ngpool = 50; gpool=zeros(ngpool,N); opt_rte=zeros(ngpool,N); newgpool=zeros(ngpool,N); newpop=zeros(ngpool,N); global_min = Inf; a=e51function(N); costmin=N; distmin=zeros(1,N); cost=zeros(1,N); for i=1:ngpool gpool(i,:)=randperm(N);

237

end agpool=gpool; p=size(agpool); agpool [rl1 rl2]=rouletteseleloop(N,ngpool,agpool,a,ngen); [rpl1 rpl2]=replrouletteseleloop(N,ngpool,agpool,a,ngen); [rnk1 rnk2]=rankseleloop(N,ngpool,agpool,a,ngen); [rnkp1 rnkp2]=replrankseleloop(N,ngpool,agpool,a,ngen); [pr1 pr2]= proposedseleloop(N,ngpool,agpool,a,ngen); [prp1 prp2]= replproposedseleloop(N,ngpool,agpool,a,ngen); figure x=[1:1:ngen]; y1 = rl1; y2=rpl1; y3 = rnk1; y4=rnkp1; y5=pr1; y6=prp1; plot(x,y1,'-.*k',x,y2,'-.ok',x,y3,'-.*b',x,y4,'-.ob',x,y5,'-.*m',x,y6,'-.om') ylabel('Average Distance') xlabel('Generation') legend('Roulette wheel selection + generational replacement','Roulette wheel selection + \mu+\lambda replacement','Rank Selection + generational replacement','Rank Selection + \mu+\lambda replacement','Annealed Selection + generational replacement','Annealed Selection + \mu+\lambda replacement') title('Comparison of average tourlength') figure x=[1:1:ngen]; y1 = rl2; y2=rpl2; y3 = rnk2; y4=rnkp2; y5=pr2; y6=prp2; plot(x,y1,'-.*k',x,y2,'-.ok',x,y3,'-.*b',x,y4,'-.ob',x,y5,'-.*m',x,y6,'-.om') ylabel('Minimum Distance') xlabel('Generation') legend('Roulette wheel selection + generational replacement','Roulette wheel selection + \mu+\lambda replacement','Rank Selection + generational replacement','Rank Selection + \mu+\lambda replacement','Annealed Selection + generational replacement','Annealed Selection + \mu+\lambda replacement') title('Comparison of minimum tourlength') ******************************************************************************* %code for comparing different replacement methods in combination with annealed selection function [y1,y2]=replproposedseleloop(N,ngpool,agpool,a,ngen)

gpool=agpool; cost=costfn(N,ngpool,gpool,a); global_min = Inf; newgpool=zeros(ngpool,N); npool=zeros(ngpool*2,N); snpool=zeros(ngpool,N);

mutrate=0.5; nmuts=mutrate*N*(ngpool-1); for j=1:ngen

npool=gpool; nogen=j; om=1; [costmin,idx]=min(cost); distmin=gpool(idx,:); [csort,ridx]=sort(cost);

dist_history(j) = costmin; avg_history(j)=mean(cost); min_history(j)=min(cost); if costmin < global_min global_min = costmin; opt_rte(j,:) = gpool(idx,:);

end sparent=blendsel(gpool,N,ngpool,cost,nogen,ngen) ;

for ik=1:(ngpool/2)-1 for jk=ik+1:ngpool/2 p1=gpool(sparent(ik),:); p2=gpool(sparent(jk),:); [c1 c2]=funcpmxco(N,ngpool,p1,p2); if om<N newgpool(om,:)=c1; om=om+1; newgpool(om,:)=c2; om=om+1; end

238

end end

j=ngpool+1; k=ngpool*2; l=1; for i=j:k npool(i,:)=newgpool(l,:); l=l+1; end newcost=costfn(N,ngpool,newgpool,a); cost=costfn(N,ngpool*2,npool,a); [nsort,idp]=sort(cost); for i=1:ngpool q(i)=idp(i); end for i=1:ngpool snpool(i,:)=npool(q(i),:); end gpool=snpool; inversion(nmuts,gpool,ngpool,N);

cost=costfn(N,ngpool,gpool,a); end

% Find the Minimum Distance Route [min_dist, index] = min(dist_history); op_rte = opt_rte(index,:);

disp(['minimum cost in proposed selection = ' num2str(min_dist)]) disp('optimum points = ') disp(num2str(op_rte)) tblvarcost=avg_history; avgproposed=mean(tblvarcost); disp(['average fitness in PROPOSED selection = ' num2str(avgproposed)])

y=[1:1:ngen]; x1 = tblvarcost; tblvarmincost=dist_history; x2=tblvarmincost; y1=tblvarcost; y2=tblvarmincost;

end ******************************************************************************** %Code To Compare Different Replacement Strategies In Combination With Different Selection % Methods On Benchmark Sphere Function clear all clc format short g N=20; ngpool=20; w=0.35; ngen=50; global_min=inf; data=zeros(ngen,ngpool); a=-5.12; b=5.12; agpool=a+(b-a)*rand(ngpool,N); % initial population gpool=agpool minfit=inf; newgpool=zeros(ngpool,N); q=zeros(ngpool,1); for ib=1:ngen csum=0; npool=gpool; n = ngpool; for j=1:ngpool

sum=0; s = 0; for i=1:N

sum=sum+(gpool(j,i)^2); end cost(j)=sum; csum=csum+cost(j); data(ib,j)=s;

end cmin=min(cost); if minfit>cmin

239

minfit=cmin; end avgfit=csum/ngpool; [costmin,idx]=min(cost); distmin=gpool(idx,:); xj1(ib,:)=distmin; [csort,ridx]=sort(cost); dist_history(ib) = costmin; avg_history(ib)=mean(cost); min_history(ib)=min(cost); if costmin < global_min global_min = costmin; opt_rte(ib,:) = gpool(idx,:); end sparent=roulettesimplega(gpool,N,ngpool,cost); om=1; for ik=1:4 for jk=ik+1:5 p1=gpool(sparent(ik),:); p2=gpool(sparent(jk),:); cross=ceil(N.*rand(1,1)); for wc=1:cross c1(wc)=p1(wc)*w; c2(wc)=p2(wc)*(1-w); end for wc=cross+1:N c1(wc)=p1(wc)*(1-w); c2(wc)=p2(wc)*w; end if om<ngpool newgpool(om,:)=c1; om=om+1; newgpool(om,:)=c2; om=om+1; end end end %generational replacement and roulette wheel selection j=ngpool+1; k=ngpool*2; l=1; for i=j:k npool(i,:)=newgpool(l,:); l=l+1; end for j=1:ngpool*2 sum=0; s = 0; for i=1:N sum=sum+(npool(j,i)^2); end newcost(j)=sum; csum=csum+newcost(j); end [nsort,idp]=sort(newcost); mi=1; ki=k; for i=1:ngpool*2 q(mi)=idp(i); mi=mi+1; end for i=1:ngpool snpool(i,:)=npool(q(i),:); end gpool=snpool; end % Find the Maximum fitness [min_dist, index] = min(dist_history); op_rte = opt_rte(index,:); disp(['minimum cost in roulette selection = ' num2str(min_dist)]) disp('optimum points = ') disp(num2str(op_rte)) tblvarcost=avg_history; avgroulette=mean(tblvarcost);

240

disp(['average fitness in roulette selection = ' num2str(avgroulette)]) tblvarmincost=dist_history; rpl1=tblvarcost; rpl2=tblvarmincost; %µ+λ replacement and roulette wheel selection gpool=agpool; minfit=inf; newgpool=zeros(ngpool,N); for ib=1:ngen csum=0; n = ngpool; for j=1:ngpool sum=0; s = 0; for i=1:N sum=sum+(gpool(j,i)^2); end cost(j)=sum; csum=csum+cost(j); data(ib,j)=s; end cmin=min(cost); if minfit>cmin minfit=cmin; end avgfit=csum/ngpool; [costmin,idx]=min(cost); distmin=gpool(idx,:); xj1(ib,:)=distmin; [csort,ridx]=sort(cost); dist_history(ib) = costmin; avg_history(ib)=mean(cost); min_history(ib)=min(cost); if costmin < global_min global_min = costmin; opt_rte(ib,:) = gpool(idx,:); end sparent=roulettesimplega(gpool,N,ngpool,cost); om=1; for ik=1:4 for jk=ik+1:5 p1=gpool(sparent(ik),:); p2=gpool(sparent(jk),:); cross=ceil(N.*rand(1,1)); for wc=1:cross c1(wc)=p1(wc)*w; c2(wc)=p2(wc)*(1-w); end for wc=cross+1:N c1(wc)=p1(wc)*(1-w); c2(wc)=p2(wc)*w; end if om<ngpool newgpool(om,:)=c1; om=om+1; newgpool(om,:)=c2; om=om+1; end end end gpool=newgpool; end % Find the Maximum fitness [min_dist, index] = min(dist_history); op_rte = opt_rte(index,:); disp(['minimum cost in roulette selection = ' num2str(min_dist)]) disp('optimum points = ') disp(num2str(op_rte)) tblvarcost=avg_history; tblvarmincost=dist_history; rl1=tblvarcost; rl2=tblvarmincost; avgroulette=mean(tblvarcost); disp(['average fitness in roulette selection = ' num2str(avgroulette)])

241

%generational replacement with rank selection gpool=agpool; minfit=inf; newgpool=zeros(ngpool,N); for ib=1:ngen csum=0; n = ngpool; for j=1:ngpool sum=0; s = 0; for i=1:N sum=sum+(gpool(j,i)^2); end cost(j)=sum; csum=csum+cost(j); data(ib,j)=s; end cmin=min(cost); if minfit>cmin minfit=cmin; end avgfit=csum/ngpool; [costmin,idx]=min(cost); distmin=gpool(idx,:); xj1(ib,:)=distmin; [csort,ridx]=sort(cost); dist_history(ib) = costmin;

avg_history(ib)=mean(cost); min_history(ib)=min(cost); if costmin < global_min global_min = costmin; opt_rte(ib,:) = gpool(idx,:); end for rk=1:ngpool

rnkarray(rk)=rk; end ranksum=0; for r=1:ngpool rankarray(r,1)=rnkarray(r); rankarray(r,2)=ridx(r); rankarray(r,3)=csort(r); ranksum=ranksum+rankarray(r,1); end for r=1:ngpool

prank(r)=(rankarray(r,1)/ranksum)*100; end ik=0; jk=0; sparent=ranksimplega(gpool,N,ngpool,cost,csort,rankarray,prank,ranksum);

om=1; for ik=1:4 for jk=ik+1:5 p1=gpool(sparent(ik),:); p2=gpool(sparent(jk),:); cross=ceil(N.*rand(1,1)); for wc=1:cross

c1(wc)=p1(wc)*w; c2(wc)=p2(wc)*(1-w); end for wc=cross+1:N

c1(wc)=p1(wc)*(1-w); c2(wc)=p2(wc)*w; end

if om<ngpool newgpool(om,:)=c1; om=om+1; newgpool(om,:)=c2; om=om+1; end end end gpool=newgpool;

end % Find the Maximum fitness

242

[min_dist, index] = min(dist_history); op_rte = opt_rte(index,:); disp(['minimum cost in rank selection = ' num2str(min_dist)]) disp('optimum points = ') disp(num2str(op_rte)) tblvarcost=avg_history; tblvarmincost=dist_history; rnk1=tblvarcost; rnk2=tblvarmincost; avgroulette=mean(tblvarcost); disp(['average fitness in rank selection = ' num2str(avgroulette)]) %µ+λ replacement and roulette wheel selection gpool=agpool; minfit=inf; newgpool=zeros(ngpool,N); for ib=1:ngen csum=0; npool=gpool; n = ngpool; for j=1:ngpool sum=0; s = 0; for i=1:N sum=sum+(gpool(j,i)^2); end cost(j)=sum; csum=csum+cost(j); data(ib,j)=s; end cmin=min(cost); if minfit>cmin minfit=cmin; end avgfit=csum/ngpool; [costmin,idx]=min(cost); distmin=gpool(idx,:); xj1(ib,:)=distmin; [csort,ridx]=sort(cost); dist_history(ib) = costmin;

avg_history(ib)=mean(cost); min_history(ib)=min(cost); if costmin < global_min global_min = costmin; opt_rte(ib,:) = gpool(idx,:); end for rk=1:ngpool rnkarray(rk)=rk; end ranksum=0; for r=1:ngpool rankarray(r,1)=rnkarray(r); rankarray(r,2)=ridx(r); rankarray(r,3)=csort(r); ranksum=ranksum+rankarray(r,1); end for r=1:ngpool

prank(r)=(rankarray(r,1)/ranksum)*100; end ik=0; jk=0; sparent=ranksimplega(gpool,N,ngpool,cost,csort,rankarray,prank,ranksum);

om=1; for ik=1:4 for jk=ik+1:5 p1=gpool(sparent(ik),:); p2=gpool(sparent(jk),:); cross=ceil(N.*rand(1,1)); for wc=1:cross

c1(wc)=p1(wc)*w; c2(wc)=p2(wc)*(1-w); end for wc=cross+1:N

c1(wc)=p1(wc)*(1-w); c2(wc)=p2(wc)*w;

243

end if om<ngpool

newgpool(om,:)=c1; om=om+1; newgpool(om,:)=c2; om=om+1; end end end j=ngpool+1; k=ngpool*2; l=1; for i=j:k

npool(i,:)=newgpool(l,:); l=l+1; end for j=1:ngpool*2 sum=0; s = 0;

for i=1:N sum=sum+(npool(j,i)^2); end

newcost(j)=sum; csum=csum+newcost(j); end [nsort,idp]=sort(newcost); mi=1; ki=k; for i=1:ngpool*2

q(mi)=idp(i); mi=mi+1; end for i=1:ngpool

snpool(i,:)=npool(q(i),:); end gpool=snpool;

end % Find the Maximum fitness [min_dist, index] = min(dist_history); op_rte = opt_rte(index,:); disp(['minimum cost in rank selection = ' num2str(min_dist)]) disp('optimum points = ') disp(num2str(op_rte)) tblvarcost=avg_history; tblvarmincost=dist_history; rnkp1=tblvarcost; rnkp2=tblvarmincost; avgroulette=mean(tblvarcost); disp(['average fitness in rank selection = ' num2str(avgroulette)]) %generational replacement with annealed selection gpool=agpool; minfit=inf; newgpool=zeros(ngpool,N); for ib=1:ngen csum=0; n = ngpool; npool=gpool; for j=1:ngpool sum=0; s = 0; for i=1:N

sum=sum+(gpool(j,i)^2); end

cost(j)=sum; csum=csum+cost(j); data(ib,j)=s; end cmin=min(cost); if minfit>cmin minfit=cmin; end avgfit=csum/ngpool;

244

[costmin,idx]=min(cost); distmin=gpool(idx,:); xj1(ib,:)=distmin; [csort,ridx]=sort(cost); dist_history(ib) = costmin;

avg_history(ib)=mean(cost); min_history(ib)=min(cost); if costmin < global_min global_min = costmin; opt_rte(ib,:) = gpool(idx,:); end nogen=ib; sparent=proposedsimplega(gpool,N,ngpool,cost,nogen,ngen); om=1; for ik=1:4 for jk=ik+1:5 p1=gpool(sparent(ik),:); p2=gpool(sparent(jk),:); cross=ceil(N.*rand(1,1)); for wc=1:cross c1(wc)=p1(wc)*w; c2(wc)=p2(wc)*(1-w); end for wc=cross+1:N c1(wc)=p1(wc)*(1-w); c2(wc)=p2(wc)*w; end if om<ngpool newgpool(om,:)=c1; om=om+1; newgpool(om,:)=c2; om=om+1; end end end j=ngpool+1; k=ngpool*2; l=1; for i=j:k npool(i,:)=newgpool(l,:); l=l+1; end for j=1:ngpool*2 sum=0; s = 0; for i=1:N sum=sum+(npool(j,i)^2); end newcost(j)=sum; csum=csum+newcost(j); end [nsort,idp]=sort(newcost); mi=1; ki=k; for i=1:ngpool*2 q(mi)=idp(i); mi=mi+1; end for i=1:ngpool snpool(i,:)=npool(q(i),:); end gpool=snpool; end % Find the Maximum fitness [min_dist, index] = min(dist_history); op_rte = opt_rte(index,:); disp(['minimum cost in proposed selection = ' num2str(min_dist)]) disp('optimum points = ') disp(num2str(op_rte)) tblvarcost=avg_history; tblvarmincost=dist_history; prp1=tblvarcost; prp2=tblvarmincost; avgroulette=mean(tblvarcost); disp(['average fitness in proposed selection = ' num2str(avgroulette)])

245

%µ+λ replacement and annealed selection gpool=agpool; minfit=inf; newgpool=zeros(ngpool,N); for ib=1:ngen csum=0; n = ngpool; for j=1:ngpool sum=0; s = 0; for i=1:N sum=sum+(gpool(j,i)^2);

end cost(j)=sum; csum=csum+cost(j); data(ib,j)=s;

end cmin=min(cost); if minfit>cmin minfit=cmin; end avgfit=csum/ngpool; [costmin,idx]=min(cost); distmin=gpool(idx,:); xj1(ib,:)=distmin; [csort,ridx]=sort(cost); dist_history(ib) = costmin;

avg_history(ib)=mean(cost); min_history(ib)=min(cost); if costmin < global_min global_min = costmin; opt_rte(ib,:) = gpool(idx,:); end nogen=ib; sparent=proposedsimplega(gpool,N,ngpool,cost,nogen,ngen); om=1; for ik=1:4 for jk=ik+1:5 p1=gpool(sparent(ik),:); p2=gpool(sparent(jk),:); cross=ceil(N.*rand(1,1)); for wc=1:cross c1(wc)=p1(wc)*w; c2(wc)=p2(wc)*(1-w); end for wc=cross+1:N c1(wc)=p1(wc)*(1-w); c2(wc)=p2(wc)*w; end if om<ngpool newgpool(om,:)=c1; om=om+1; newgpool(om,:)=c2; om=om+1; end end end gpool=newgpool; end % Find the Maximum fitness [min_dist, index] = min(dist_history); op_rte = opt_rte(index,:); disp(['minimum cost in proposed selection = ' num2str(min_dist)]) disp('optimum points = ') disp(num2str(op_rte)) tblvarcost=avg_history; tblvarmincost=dist_history; pr1=tblvarcost; pr2=tblvarmincost; avgroulette=mean(tblvarcost); disp(['average fitness in proposed selection = ' num2str(avgroulette)]) x=[1:1:ngen]; y1 = rl1; y2=rpl1; y3 = rnk1; y4=rnkp1;

246

y5=pr1; y6=prp1; plot(x,y1,'-.*k',x,y2,'-.ok',x,y3,'-.*b',x,y4,'-.ob',x,y5,'-.*m',x,y6,'-.om') ylabel('Average Fitness') xlabel('Generation') legend('Roulette wheel selection + generational replacement','Roulette wheel selection + \mu+\lambda replacement','Rank Selection + generational replacement','Rank Selection + \mu+\lambda replacement','Annealed Selection + generational replacement','Annealed Selection + \mu+\lambda replacement') title('Comparison of Average Fitness') figure x=[1:1:ngen]; y1 = rl2; y2=rpl2; y3 = rnk2; y4=rnkp2; y5=pr2; y6=prp2; plot(x,y1,'-.*k',x,y2,'-.ok',x,y3,'-.*b',x,y4,'-.ob',x,y5,'-.*m',x,y6,'-.om') ylabel('Minimum Fitness') xlabel('Generation') legend('Roulette wheel selection + generational replacement','Roulette wheel selection + \mu+\lambda replacement','Rank Selection + generational replacement','Rank Selection + \mu+\lambda replacement','Annealed Selection + generational replacement','Annealed Selection + \mu+\lambda replacement') title('Comparison of Minimum Fitness') %code for main ga program to implement tabu crossover clear all clear clc close all N=51; ngen=500; ngpool = 50; gpool=zeros(ngpool,N); opt_rte=zeros(ngpool,N); newgpool=zeros(ngpool,N); newpop=zeros(ngpool,N); global_min = Inf; a=e51function(N); costmin=N; distmin=zeros(1,N); cost=zeros(1,N); for i=1:ngpool gpool(i,:)=randperm(N); end agpool=gpool; a p=size(agpool); agpool [rl1 rl2]=rouletteseleloop(N,ngpool,agpool,a,ngen); [rpl1 rpl2]=roulettetabuloop(N,ngpool,agpool,a,ngen); [rnk1 rnk2]=rankseleloop(N,ngpool,agpool,a,ngen); [rnkp1 rnkp2]=ranktabuloop(N,ngpool,agpool,a,ngen); [pr1 pr2]= proposedseleloop(N,ngpool,agpool,a,ngen); [prp1 prp2]= proposedtabuloop(N,ngpool,agpool,a,ngen); figure x=[1:1:ngen]; y1 = rl1; y2=rpl1; y3 = rnk1; y4=rnkp1; y5=pr1; y6=prp1; plot(x,y1,'-.*k',x,y2,'-.ok',x,y3,'-.*b',x,y4,'-.ob',x,y5,'-.*m',x,y6,'-.om') ylabel('Average Distance') xlabel('Generation') legend('Roulette wheel selection + PMX CO','Roulette wheel selection + Proposed CO','Rank Selection + PMX CO','Rank Selection + Proposed CO','Annealed Selection + PMX CO','Annealed Selection + Proposed CO') title('Comparison of average tourlength')

247

figure x=[1:1:ngen]; y1 = rl2; y2=rpl2; y3 = rnk2; y4=rnkp2; y5=pr2; y6=prp2; plot(x,y1,'-.*k',x,y2,'-.ok',x,y3,'-.*b',x,y4,'-.ob',x,y5,'-.*m',x,y6,'-.om') ylabel('Minimum Distance') xlabel('Generation') legend('Roulette wheel selection + PMX CO','Roulette wheel selection + Proposed CO','Rank Selection + PMX CO','Rank Selection + Proposed CO','Annealed Selection + PMX CO','Annealed Selection + Proposed CO') title('Comparison of minimum tourlength') ******************************************************************************** %code to implement tabu ccrossover with annealed selection function [y1,y2]=proposedtabuloop(N,ngpool,agpool,a,ngen)

gpool=agpool; cost=costfn(N,ngpool,gpool,a); global_min = Inf; mutrate=0.5; nmuts=mutrate*N*(ngpool-1); for j=1:ngen

nogen=j; om=1; [costmin,idx]=min(cost); distmin=gpool(idx,:); [csort,ridx]=sort(cost); dist_history(j) = costmin; avg_history(j)=mean(cost); min_history(j)=min(cost);

if costmin < global_min global_min = costmin; opt_rte(j,:) = gpool(idx,:);

end sparent=blendsel(gpool,N,ngpool,cost,nogen,ngen) ;

for ik=1:(ngpool/2)-1 for jk=ik+1:ngpool/2

p1=gpool(sparent(ik),:); p2=gpool(sparent(jk),:); [c1 c2]=fntabuknowledgeco(N,ngpool,p1,p2,cost,a); if om<N newgpool(om,:)=c1; om=om+1; newgpool(om,:)=c2; om=om+1; end

end end

gpool=newgpool; inversion(nmuts,gpool,ngpool,N);

cost=costfn(N,ngpool,gpool,a); end % Find the Minimum Distance Route [min_dist, index] = min(dist_history); op_rte = opt_rte(index,:);

disp(['minimum cost in proposed selection = ' num2str(min_dist)]) disp('optimum points = ') disp(num2str(op_rte)) tblvarcost=avg_history; avgproposed=mean(tblvarcost); disp(['average fitness in PROPOSED selection = ' num2str(avgproposed)])

y=[1:1:ngen]; x1 = tblvarcost; tblvarmincost=dist_history; x2=tblvarmincost; y1=tblvarcost; y2=tblvarmincost;

end *******************************************************************************