www.pudn.com > NSGAII.rar > non_domination_sort_mod.html, change:2006-03-07,size:11714b


<html xmlns:mwsh="http://www.mathworks.com/namespace/mcode/v1/syntaxhighlight.dtd"> 
   <head> 
      <meta http-equiv="Content-Type" content="text/html; charset=utf-8"> 
    
      <!-- 
This HTML is auto-generated from an M-file. 
To make changes, update the M-file and republish this document. 
      --> 
      <title>Non-Donimation Sort</title> 
      <meta name="generator" content="MATLAB 7.0"> 
      <meta name="date" content="2006-03-07"> 
      <meta name="m-file" content="non_domination_sort_mod"><style> 
body { 
  background-color: white; 
  margin:10px; 
} 
h1 { 
  color: #990000;  
  font-size: x-large; 
} 
h2 { 
  color: #990000; 
  font-size: medium; 
} 
p.footer { 
  text-align: right; 
  font-size: xx-small; 
  font-weight: lighter; 
  font-style: italic; 
  color: gray; 
} 
 
pre.codeinput { 
  margin-left: 30px; 
} 
 
span.keyword {color: #0000FF} 
span.comment {color: #228B22} 
span.string {color: #A020F0} 
span.untermstring {color: #B20000} 
span.syscmd {color: #B28C00} 
 
pre.showbuttons { 
  margin-left: 30px; 
  border: solid black 2px; 
  padding: 4px; 
  background: #EBEFF3; 
} 
 
pre.codeoutput { 
  color: gray; 
  font-style: italic; 
} 
pre.error { 
  color: red; 
} 
 
/* Make the text shrink to fit narrow windows, but not stretch too far in  
wide windows.  On Gecko-based browsers, the shrink-to-fit doesn't work. */  
p,h1,h2,div { 
  /* for MATLAB's browser */ 
  width: 600px; 
  /* for Mozilla, but the "width" tag overrides it anyway */ 
  max-width: 600px; 
  /* for IE */ 
  width:expression(document.body.clientWidth > 620 ? "600px": "auto" ); 
} 
 
    </style></head> 
   <body> 
      <h1>Non-Donimation Sort</h1> 
      <p>This function sort the current popultion based on non-domination. All the individuals in the first front are given a rank 
         of 1, the second front individuals are assigned rank 2 and so on. After assigning the rank the crowding in each front is calculated. 
      </p><pre class="codeinput">[N,M] = size(x); 
<span class="keyword">switch</span> problem 
    <span class="keyword">case</span> 1 
        M = 2; 
        V = 6; 
    <span class="keyword">case</span> 2 
        M = 3; 
        V = 12; 
<span class="keyword">end</span> 
front = 1; 
 
<span class="comment">% There is nothing to this assignment, used only to manipulate easily in</span> 
<span class="comment">% MATLAB.</span> 
F(front).f = []; 
individual = []; 
<span class="keyword">for</span> i = 1 : N 
    <span class="comment">% Number of individuals that dominate this individual</span> 
    individual(i).n = 0; 
    <span class="comment">% Individuals which this individual dominate</span> 
    individual(i).p = []; 
    <span class="keyword">for</span> j = 1 : N 
        dom_less = 0; 
        dom_equal = 0; 
        dom_more = 0; 
        <span class="keyword">for</span> k = 1 : M 
            <span class="keyword">if</span> (x(i,V + k) < x(j,V + k)) 
                dom_less = dom_less + 1; 
            <span class="keyword">elseif</span> (x(i,V + k) == x(j,V + k)) 
                dom_equal = dom_equal + 1; 
            <span class="keyword">else</span> 
                dom_more = dom_more + 1; 
            <span class="keyword">end</span> 
        <span class="keyword">end</span> 
        <span class="keyword">if</span> dom_less == 0 & dom_equal ~= M 
            individual(i).n = individual(i).n + 1; 
        <span class="keyword">elseif</span> dom_more == 0 & dom_equal ~= M 
            individual(i).p = [individual(i).p j]; 
        <span class="keyword">end</span> 
    <span class="keyword">end</span> 
    <span class="keyword">if</span> individual(i).n == 0 
        x(i,M + V + 1) = 1; 
        F(front).f = [F(front).f i]; 
    <span class="keyword">end</span> 
<span class="keyword">end</span> 
<span class="comment">% Find the subsequent fronts</span> 
<span class="keyword">while</span> ~isempty(F(front).f) 
   Q = []; 
   <span class="keyword">for</span> i = 1 : length(F(front).f) 
       <span class="keyword">if</span> ~isempty(individual(F(front).f(i)).p) 
        	<span class="keyword">for</span> j = 1 : length(individual(F(front).f(i)).p) 
            	individual(individual(F(front).f(i)).p(j)).n = <span class="keyword">...</span> 
                	individual(individual(F(front).f(i)).p(j)).n - 1; 
        	   	<span class="keyword">if</span> individual(individual(F(front).f(i)).p(j)).n == 0 
               		x(individual(F(front).f(i)).p(j),M + V + 1) = <span class="keyword">...</span> 
                        front + 1; 
                    Q = [Q individual(F(front).f(i)).p(j)]; 
                <span class="keyword">end</span> 
            <span class="keyword">end</span> 
       <span class="keyword">end</span> 
   <span class="keyword">end</span> 
   front =  front + 1; 
   F(front).f = Q; 
<span class="keyword">end</span> 
[temp,index_of_fronts] = sort(x(:,M + V + 1)); 
<span class="keyword">for</span> i = 1 : length(index_of_fronts) 
    sorted_based_on_front(i,:) = x(index_of_fronts(i),:); 
<span class="keyword">end</span> 
current_index = 0; 
<span class="comment">% Find the crowding distance for each individual in each front</span> 
<span class="keyword">for</span> front = 1 : (length(F) - 1) 
    objective = []; 
    distance = 0; 
    y = []; 
    previous_index = current_index + 1; 
    <span class="keyword">for</span> i = 1 : length(F(front).f) 
        y(i,:) = sorted_based_on_front(current_index + i,:); 
    <span class="keyword">end</span> 
    current_index = current_index + i; 
    <span class="comment">% Sort each individual based on the objective</span> 
    sorted_based_on_objective = []; 
    <span class="keyword">for</span> i = 1 : M 
        [sorted_based_on_objective, index_of_objectives] = <span class="keyword">...</span> 
            sort(y(:,V + i)); 
        sorted_based_on_objective = []; 
        <span class="keyword">for</span> j = 1 : length(index_of_objectives) 
            sorted_based_on_objective(j,:) = y(index_of_objectives(j),:); 
        <span class="keyword">end</span> 
        f_max = <span class="keyword">...</span> 
            sorted_based_on_objective(length(index_of_objectives), V + i); 
        f_min = sorted_based_on_objective(1, V + i); 
        y(index_of_objectives(length(index_of_objectives)),M + V + 1 + i)<span class="keyword">...</span> 
            = Inf; 
        y(index_of_objectives(1),M + V + 1 + i) = Inf; 
         <span class="keyword">for</span> j = 2 : length(index_of_objectives) - 1 
            next_obj  = sorted_based_on_objective(j + 1,V + i); 
            previous_obj  = sorted_based_on_objective(j - 1,V + i); 
            <span class="keyword">if</span> (f_max - f_min == 0) 
                y(index_of_objectives(j),M + V + 1 + i) = Inf; 
            <span class="keyword">else</span> 
                y(index_of_objectives(j),M + V + 1 + i) = <span class="keyword">...</span> 
                     (next_obj - previous_obj)/(f_max - f_min); 
            <span class="keyword">end</span> 
         <span class="keyword">end</span> 
    <span class="keyword">end</span> 
    distance = []; 
    distance(:,1) = zeros(length(F(front).f),1); 
    <span class="keyword">for</span> i = 1 : M 
        distance(:,1) = distance(:,1) + y(:,M + V + 1 + i); 
    <span class="keyword">end</span> 
    y(:,M + V + 2) = distance; 
    y = y(:,1 : M + V + 2); 
    z(previous_index:current_index,:) = y; 
<span class="keyword">end</span> 
f = z(); 
</pre><p class="footer"><br> 
         Published with MATLAB® 7.0<br></p> 
      <!-- 
##### SOURCE BEGIN ##### 
%% Non-Donimation Sort 
% This function sort the current popultion based on non-domination. All the 
% individuals in the first front are given a rank of 1, the second front 
% individuals are assigned rank 2 and so on. After assigning the rank the 
% crowding in each front is calculated. 
 
 
[N,M] = size(x); 
switch problem 
    case 1 
        M = 2; 
        V = 6; 
    case 2 
        M = 3; 
        V = 12; 
end 
front = 1; 
 
% There is nothing to this assignment, used only to manipulate easily in 
% MATLAB. 
F(front).f = []; 
individual = []; 
for i = 1 : N 
    % Number of individuals that dominate this individual 
    individual(i).n = 0; 
    % Individuals which this individual dominate 
    individual(i).p = []; 
    for j = 1 : N 
        dom_less = 0; 
        dom_equal = 0; 
        dom_more = 0; 
        for k = 1 : M 
            if (x(i,V + k) < x(j,V + k)) 
                dom_less = dom_less + 1; 
            elseif (x(i,V + k) == x(j,V + k)) 
                dom_equal = dom_equal + 1; 
            else 
                dom_more = dom_more + 1; 
            end 
        end 
        if dom_less == 0 & dom_equal ~= M 
            individual(i).n = individual(i).n + 1; 
        elseif dom_more == 0 & dom_equal ~= M 
            individual(i).p = [individual(i).p j]; 
        end 
    end    
    if individual(i).n == 0 
        x(i,M + V + 1) = 1; 
        F(front).f = [F(front).f i]; 
    end 
end 
% Find the subsequent fronts 
while ~isempty(F(front).f) 
   Q = []; 
   for i = 1 : length(F(front).f) 
       if ~isempty(individual(F(front).f(i)).p) 
        	for j = 1 : length(individual(F(front).f(i)).p) 
            	individual(individual(F(front).f(i)).p(j)).n = ... 
                	individual(individual(F(front).f(i)).p(j)).n - 1; 
        	   	if individual(individual(F(front).f(i)).p(j)).n == 0 
               		x(individual(F(front).f(i)).p(j),M + V + 1) = ... 
                        front + 1; 
                    Q = [Q individual(F(front).f(i)).p(j)]; 
                end 
            end 
       end 
   end 
   front =  front + 1; 
   F(front).f = Q; 
end 
[temp,index_of_fronts] = sort(x(:,M + V + 1)); 
for i = 1 : length(index_of_fronts) 
    sorted_based_on_front(i,:) = x(index_of_fronts(i),:); 
end 
current_index = 0; 
% Find the crowding distance for each individual in each front 
for front = 1 : (length(F) - 1) 
    objective = []; 
    distance = 0; 
    y = []; 
    previous_index = current_index + 1; 
    for i = 1 : length(F(front).f) 
        y(i,:) = sorted_based_on_front(current_index + i,:); 
    end 
    current_index = current_index + i; 
    % Sort each individual based on the objective 
    sorted_based_on_objective = []; 
    for i = 1 : M 
        [sorted_based_on_objective, index_of_objectives] = ... 
            sort(y(:,V + i)); 
        sorted_based_on_objective = []; 
        for j = 1 : length(index_of_objectives) 
            sorted_based_on_objective(j,:) = y(index_of_objectives(j),:); 
        end 
        f_max = ... 
            sorted_based_on_objective(length(index_of_objectives), V + i); 
        f_min = sorted_based_on_objective(1, V + i); 
        y(index_of_objectives(length(index_of_objectives)),M + V + 1 + i)... 
            = Inf; 
        y(index_of_objectives(1),M + V + 1 + i) = Inf; 
         for j = 2 : length(index_of_objectives) - 1 
            next_obj  = sorted_based_on_objective(j + 1,V + i); 
            previous_obj  = sorted_based_on_objective(j - 1,V + i); 
            if (f_max - f_min == 0) 
                y(index_of_objectives(j),M + V + 1 + i) = Inf; 
            else 
                y(index_of_objectives(j),M + V + 1 + i) = ... 
                     (next_obj - previous_obj)/(f_max - f_min); 
            end 
         end 
    end 
    distance = []; 
    distance(:,1) = zeros(length(F(front).f),1); 
    for i = 1 : M 
        distance(:,1) = distance(:,1) + y(:,M + V + 1 + i); 
    end 
    y(:,M + V + 2) = distance; 
    y = y(:,1 : M + V + 2); 
    z(previous_index:current_index,:) = y; 
end 
f = z(); 
##### SOURCE END ##### 
--> 
   </body> 
</html>