changes

Author: wittfabian

change_in_path_length.m

@@ -0,0 +1,8 @@
+function result = change_in_path_length(path, i, j, distances)
+
+    before = distances(path(r(i, path)), path(r(i+1,path))) + distances(path(r(i+1+j, path)), path(r(i+2+j, path)));
+    
+    after = distances(path(r(i, path)), path(r(i+1+j, path))) + distances(path(r(i+1, path)), path(r(i+2+j, path)));
+    
+    result = after - before; 
+end

change_path.m

@@ -0,0 +1,16 @@
+function path = change_path(path, i, j)
+
+    oldPath = path;
+    %fprintf('i: %i, j: %i\n', i, j);
+    %fprintf('oldPath: %s\n', sprintf('%i ', oldPath));
+    % exchange edge cities
+    path(r(i+1, path)) = oldPath(r(i+1+j, path));
+    path(r(i+1+j, path)) = oldPath(r(i+1, path));
+    
+    % change direction of intermediate path 
+    for k=1:j-1
+        path(r(i+1+k, path)) = oldPath(r(i+1+j-k, path));
+    end
+    
+    %fprintf('newPath: %s\n', sprintf('%i ', path));
+end

dPsoOpt.m

@@ -1,11 +1,11 @@
-function dist = distancePath(data, path)
+function dist = distancePath(distances, path)
 
     dist = 0.0;
 
     for e=1:1:size(path,2)-1
-       
-        dist = dist + pdist([data(path(e),:); data(path(e+1),:)], 'euclidean');
+        
+        dist = dist + distances(path(e), path(e+1));
     end
 
-    dist = dist + pdist([data(path(end),:); data(path(1),:)], 'euclidean');
+    dist = dist + distances(path(end), path(1));
 end

distancePath.m

@@ -5,11 +5,11 @@
     end
 
     globalBestCoord = globalBest;
-    globalBestDist = distancePath(globalBest, path);
+    globalBestDist = distancePath(distance(globalBest), path);
 
     for d=1:1:size(personalBest,3)
 
-        personalBestDist = distancePath(personalBest(:,:,d), path);
+        personalBestDist = distancePath(distance(personalBest(:,:,d)), path);
 
         if personalBestDist < globalBestDist
             globalBestCoord = personalBest(:,:,d);

findGlobalBestFullPath.m

@@ -1,18 +1,18 @@
-function [ globalBestPath, globalBestDist ] = findGlobalBestPermutation( data, personalBest, globalBest )
+function [ globalBestPath, globalBestDist ] = findGlobalBestPermutation( distances, personalBest, globalBest )
 
     if nargin == 2
         globalBest = personalBest(1,:);
     end
 
     globalBestPath = globalBest;
-    globalBestDist = distancePath(data, globalBestPath);
+    globalBestDist = distancePath(distances, globalBestPath);
 
     for d=1:1:size(personalBest,1)
 
-        personalBestDist = distancePath(data, personalBest(d,:));
+        personalBestDist = distancePath(distances, personalBest(d,:));
 
         if personalBestDist < globalBestDist
-            globalBestPath =  personalBest(d,:);
+            globalBestPath = personalBest(d,:);
             globalBestDist = personalBestDist;
         end
     end

findGlobalBestPermutation.m

@@ -1,10 +1,14 @@
-function list = getListOfEdgeExchanges( ~, ispath, shallpath )
+function list = getListOfEdgeExchanges( ispath, shallpath )
 
+    list = [];
+
     if size(ispath,2) ~= size(shallpath,2)
         return
     end
 
-    list = [];
+    if sum( ispath == shallpath ) == size(shallpath,2)
+        return 
+    end
 
     while sum( ispath == shallpath ) ~= size(shallpath,2)
 

getListOfEdgeExchanges.m

@@ -3,6 +3,9 @@
     switch(type)
         case 'random'
             particlePos = randomInitialization( data, quantity );
+            
+        case 'randomFif'
+            particlePos = randomInitializationFif( data, quantity );
 
         otherwise
             particlePos = randomInitialization( data, quantity );
@@ -14,7 +17,7 @@
     particlePos = zeros(quantity, size(data,1));
 
     if quantity > factorial(size(data,1))
-        return
+        quantity = factorial(size(data,1));
     end
 
     for p=1:1:quantity % iterate through particles
@@ -29,3 +32,24 @@
         end
     end
 end
+
+function particlePos = randomInitializationFif( data, quantity )
+
+    particlePos = zeros(quantity, size(data,1));
+
+    if quantity > factorial(size(data,1))
+        quantity = factorial(size(data,1));
+    end
+
+    for p=1:1:quantity % iterate through particles
+    
+        while true
+            newPermutation = [1 randsample(2:size(data,1), size(data,1)-1)];
+        
+            if ~ismember(newPermutation, particlePos, 'rows')
+                particlePos(p,:) = newPermutation;
+                break
+            end
+        end
+    end
+end

initializeSwarmMemberPermutation.m

@@ -0,0 +1,14 @@
+function [path, total_length] = opt2(path, distances)
+
+    n = size(path,2);
+    
+    for i=1:n
+        for j=1:n-3
+            if change_in_path_length(path, i, j, distances) < 0 
+                path = change_path(path, i, j);
+            end
+        end
+    end
+    
+    total_length = distancePath(distances, path);
+end

opt2.m

@@ -56,8 +56,8 @@
                 end
 
                 % find new personalBest for city n
-                distpersonalBest = distancePath( personalBest(:,:,p), path );
-                distAktPos = distancePath( particlePos(:,:,p), path );
+                distpersonalBest = distancePath( distance(personalBest(:,:,p)), path );
+                distAktPos = distancePath( distance(particlePos(:,:,p)), path );
                 if distAktPos < distpersonalBest
                     personalBest(n,:,p) = particlePos(n,:,p);
                 end
@@ -105,6 +105,6 @@
     travelPoints = globalBest;
 
     % calculate the total_length of the cycle
-    total_length = total_length_of_cycle(distance(travelPoints), path);
+    total_length = distancePath(distance(travelPoints), path);
 end