└── AUV_GA
    ├── coor.mat
    ├── InitPop.m
    ├── Fitness.m
    ├── Mutation.m
    ├── Nearest.m
    ├── README.txt
    ├── Select.m
    ├── RP_coordinate.m
    ├── DynamicProgram.m
    ├── NN.m
    ├── Crossover.m
    ├── main.m
    └── tsp_dp1.m


/AUV_GA/coor.mat:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/MagRUAski/4th_year_project/HEAD/AUV_GA/coor.mat


--------------------------------------------------------------------------------
/AUV_GA/InitPop.m:
--------------------------------------------------------------------------------
 1 | %Generate 1st population
 2 | function popparent = InitPop(Popsize,RPNUM,adjacency,Mixrate)
 3 | popparent = zeros(Popsize,RPNUM);
 4 | for i = 1:Popsize
 5 |     %if(i<=(Mixrate*Popsize))
 6 |     %Normal 1st gen
 7 |     %popparent(i,:)=randperm(RPNUM); %1:RPNUM integers without repetition 
 8 |     %else
 9 |     %Elite 1st gen
10 |     popparent(i,:) = Nearest(RPNUM,adjacency); %Use Nearest Neighbor to get Elite 1st gen
11 |     %end
12 | end
13 | 
14 | 


--------------------------------------------------------------------------------
/AUV_GA/Fitness.m:
--------------------------------------------------------------------------------
 1 | % Function of calculating fitness for population
 2 | function fitness = Fitness(pop,adjacency)
 3 | for i = 1:size(pop,1)
 4 |    
 5 |     dist=0;
 6 |     for k = 2:size(pop,2)
 7 |         dist = dist + adjacency(pop(i,k-1),pop(i,k)); %Add the distance between points
 8 |     end
 9 |     dist = dist + adjacency(pop(i,1),pop(i,size(pop,2)));%Add the distance from end point to start point
10 |     fit(i).fitness=dist;
11 |   
12 | end
13 | fitness = [fit.fitness];


--------------------------------------------------------------------------------
/AUV_GA/Mutation.m:
--------------------------------------------------------------------------------
 1 | %Mutation by swaping genes and get Chindren population
 2 | function Childpop = Mutation(crossover,Pmutation)
 3 | Childpop = crossover;
 4 | k=1;
 5 | while(k<=size(Childpop,1))
 6 |     %Russian roulette
 7 |     Pm = unifrnd(0,1);
 8 |     if(Pm<Pmutation)
 9 |         
10 |         Gene=Childpop(k,:);
11 |         a = unidrnd(size(Childpop,2));
12 |         b = unidrnd(size(Childpop,2));
13 |         while(a==b)
14 |             b = unidrnd(size(Childpop,2));
15 |         end
16 |         %Mutation by swapping genes
17 |         Temp=Gene(a);
18 |         Gene(a)=Gene(b);
19 |         Gene(b)=Temp;
20 |         Childpop(k,:)=Gene;
21 |     end
22 |     k=k+1;
23 | end
24 | 
25 | 
26 | 


--------------------------------------------------------------------------------
/AUV_GA/Nearest.m:
--------------------------------------------------------------------------------
 1 | %Function nearest()
 2 | function NNPath = Nearest(RPNUM,adjacency)
 3 |     k = 1;
 4 |     Next = randi(RPNUM);            %Start from random node
 5 | 
 6 | while(k<=RPNUM)
 7 |     
 8 |     Neighbors = adjacency(Next,:);  %Get distances of all Neighbors
 9 |     Previous(k) = Next;             %Record nodes that have been visited
10 |     Neighbors(Previous) = inf;      %Exclude distances of visited nodes
11 |     Dissorted=sort(Neighbors,'ascend');  %sort distance
12 | 
13 |     i=1;
14 |     Nexts=(find(Neighbors==Dissorted(i)));%Find the ID of the node to visit, there could be multiple nearest neighbors
15 |     Next = Nexts(1);
16 |     k=k+1;
17 |     
18 | end
19 | 
20 | NNPath = Previous;


--------------------------------------------------------------------------------
/AUV_GA/README.txt:
--------------------------------------------------------------------------------
 1 | -------------------------------------------------------------------
 2 | -------------------------------------------------------------------
 3 | This is a Genetic Algorithm using Nearest Neighbor for solving AUV
 4 | Path Planning problem in UASNs with Data Harvesting.
 5 | It can simulate the path planning process using GA and show evolution
 6 | of fitness.
 7 | 
 8 | To simulate:
 9 | 
10 | 1. Run 'RP_coordinate.m' to generate nodes randomly. Coordinates and
11 |    Adjacency Matrix will be saved in 'coor.mat'.
12 | 
13 | 2. Run 'main.m', set population size and iteration threshold.
14 | 
15 | 3. To compare performance differences between GA,NN, and Dynamic Programming,
16 |    Run 'NN.m' and 'DynamicProgram.m'.
17 | 
18 |  


--------------------------------------------------------------------------------
/AUV_GA/Select.m:
--------------------------------------------------------------------------------
 1 | %Select the first half best fitnesses 
 2 | function nextpop = Select(combopop,fitness)
 3 | 
 4 | m=size(combopop,1);
 5 | nextpopTEMP=combopop;
 6 | fitsorted=sort(fitness,'ascend');  %sort fitness
 7 | i=1;
 8 | BestPlans=(find(fitness==fitsorted(i)));%Find positions of best fitness, there could be multiple best fitness
 9 | BestPlan=BestPlans(1);
10 | while(i<=(m/2))
11 |     numelement=find(fitness==fitsorted(i));
12 |     n = size(numelement,2);
13 |     for j = 1:n
14 |         ROW=numelement(j);
15 |         nextpopTEMP(i+j-1,:)=combopop(ROW,:);%Select the first half of best according to best fitness position
16 |     end
17 |     i = i+j;
18 | end
19 | nextpop.pop=nextpopTEMP(1:(m/2),:);
20 | nextpop.bestplan=BestPlan;
21 |     
22 | 
23 | 
24 | 
25 |         
26 |         
27 |     
28 | 
29 | 


--------------------------------------------------------------------------------
/AUV_GA/RP_coordinate.m:
--------------------------------------------------------------------------------
 1 | %Coordinates obtained by localization
 2 | clear;
 3 | RPNUM = 25;
 4 | xm = 60000;
 5 | ym = 60000;
 6 | zm = -30;
 7 | AUV = [0,0,0];
 8 | vAUV = 10*0.5144; %10 knots
 9 | 
10 | for i=1:1:RPNUM
11 |         RP(i).x=unifrnd(0,1)*xm;       %Generate coordinates uniformly
12 |         RP(i).y=unifrnd(0,1)*ym;
13 |         RP(i).z=unifrnd(0,1)*zm;
14 |         
15 |         figure(1);
16 |         subplot(2,1,1);
17 |         plot3(RP(i).x,RP(i).y, RP(i).z,'o');
18 |         text(RP(i).x,RP(i).y, RP(i).z,num2str(i));
19 |         title('3D Postions of rendezvous points');
20 |         grid on;
21 |         hold on;
22 |         subplot(2,1,2);
23 |         plot(RP(i).x,RP(i).y,'o');
24 |         text(RP(i).x,RP(i).y,num2str(i));
25 |         title('2D Postions of rendezvous points');
26 |         grid on;
27 |         hold on;
28 | end
29 | 
30 | hold off;
31 | 
32 | %Calculate Adjacency Matrix
33 | for m=1:1:RPNUM
34 |     for n=1:1:RPNUM
35 |     adjacency(m,n) = sqrt((RP(m).x - RP(n).x)^2+(RP(m).y - RP(n).y)^2+(RP(m).z - RP(n).z)^2);
36 |     end
37 | end
38 | 
39 | save coor
40 | 
41 | 
42 | 
43 | 


--------------------------------------------------------------------------------
/AUV_GA/DynamicProgram.m:
--------------------------------------------------------------------------------
 1 | %Coordinates obtained by localization
 2 | clear all;
 3 | close all;
 4 | 
 5 | tic;
 6 | load('coor.mat');
 7 | 
 8 | %using function by Elad Kivelevitch
 9 | 
10 | [DPplan,DPcost] = tsp_dp1(RP,adjacency);
11 | tDelay = DPcost/vAUV;
12 | hour = (tDelay - mod(tDelay,3600))/3600;
13 | minute = (tDelay-hour*3600 - mod(tDelay-hour*3600,60))/60;
14 | second = tDelay-hour*3600-minute*60;
15 | traveldelay = [hour,minute,second];
16 | 
17 | DPplancoor = [RP(DPplan).x;RP(DPplan).y; RP(DPplan).z].';
18 | toc;
19 |         figure(2);
20 |         for i=1:RPNUM
21 |         subplot(2,1,1);
22 |         plot3(RP(i).x,RP(i).y,RP(i).z,'o');
23 |         text(RP(i).x,RP(i).y, RP(i).z,num2str(i));
24 |         hold on;
25 |         subplot(2,1,2);
26 |         plot(RP(i).x,RP(i).y,'o');
27 |         text(RP(i).x,RP(i).y,num2str(i));
28 |         hold on;
29 |         end
30 |         subplot(2,1,1);
31 |         plot3(DPplancoor(:,1),DPplancoor(:,2),DPplancoor(:,3),'r--');
32 |         title('3D Path of AUV');
33 |         grid on;
34 |         subplot(2,1,2);
35 |         plot(DPplancoor(:,1),DPplancoor(:,2),'r--');
36 |         title('2D Path of AUV');
37 |         grid on;
38 | 
39 | 


--------------------------------------------------------------------------------
/AUV_GA/NN.m:
--------------------------------------------------------------------------------
 1 | % Nearest Neighbor Method
 2 | clear all;
 3 | close all;
 4 | 
 5 | tic;
 6 | load('coor.mat');
 7 | 
 8 | k = 1;
 9 | 
10 | Next = randi(RPNUM);
11 | 
12 | while(k<=RPNUM)
13 |     Neighbors = adjacency(Next,:);
14 |     Previous(k) = Next;
15 |     Neighbors(Previous) = inf;
16 |     Dissorted=sort(Neighbors,'ascend');  %sort distance
17 | 
18 |     i=1;
19 |     Nexts=(find(Neighbors==Dissorted(i)));
20 |     Next = Nexts(1);
21 |     k=k+1;
22 | end
23 | 
24 | NNPath = Previous;
25 | NNPath(RPNUM+1)=NNPath(1);
26 | 
27 | NNPathcoor = [RP(NNPath).x;RP(NNPath).y; RP(NNPath).z].';
28 | toc;
29 | 
30 | cost=0;
31 |     for c = 2:RPNUM
32 |         cost = cost + adjacency(NNPath(c-1),NNPath(c));
33 |     end
34 |     cost = cost + adjacency(NNPath(1),NNPath(RPNUM));
35 | 
36 |         figure(1);
37 |         for i=1:RPNUM
38 |         subplot(2,1,1);     %Plot all rendezvous points
39 |         plot3(RP(i).x,RP(i).y,RP(i).z,'o');
40 |         text(RP(i).x,RP(i).y, RP(i).z,num2str(i));
41 |         hold on;
42 |         subplot(2,1,2);
43 |         plot(RP(i).x,RP(i).y,'o');
44 |         text(RP(i).x,RP(i).y,num2str(i));
45 |         hold on;
46 |         end
47 |         subplot(2,1,1);
48 |         plot3(NNPathcoor(:,1),NNPathcoor(:,2),NNPathcoor(:,3),'r-.');
49 |         title('3D Path of AUV');
50 |         grid on;
51 |         subplot(2,1,2);
52 |         plot(NNPathcoor(:,1),NNPathcoor(:,2),'r-.');
53 |         title('2D Path of AUV');
54 |         grid on;


--------------------------------------------------------------------------------
/AUV_GA/Crossover.m:
--------------------------------------------------------------------------------
 1 | % Function for crossover and avoiding conflicts
 2 | function crossover = Crossover(pop,Pcross)
 3 | crossover=pop;
 4 | k=1;
 5 | while (k<=(size(crossover,1)-1))
 6 |     %Russian roulette to decide whether crossover occurs
 7 |     Pc = unifrnd(0,1);      
 8 |     if(Pc<Pcross)
 9 |         SS = unidrnd(size(crossover,2)); %Start point of crossover section
10 |         SE = unidrnd(size(crossover,2));   %End point of crossover section
11 |         while(SS == SE) 
12 |             SE = unidrnd(size(crossover,2));
13 |         end
14 |         if(SE<SS) %Order
15 |             temp = SE;
16 |             SE = SS;
17 |             SS=temp;
18 |         end
19 |         Chrom1=crossover(k,:);          %First chromosome for crossover
20 |         Chrom2=crossover(k+1,:);        %Second chromosome for crossover
21 |         CS2=Chrom1(SS:SE);        %crossover section 1
22 |         CS1=Chrom2(SS:SE);        %crossover section 2
23 |         Chrom1(SS:SE)=CS1;        %crossover finished
24 |         Chrom2(SS:SE)=CS2;        %crossover finished
25 |         
26 |         %Avoid conflict
27 |         LIST=unique(Chrom1); %list all unique numbers
28 |         COUNTA=hist(Chrom1,unique(Chrom1)); %Distribute elements on chromosomes to corresponding unique numbers
29 |         ISDUP = COUNTA - ones(1,size(COUNTA,2)); %If there is a duplicate number, the result will be non-zero array
30 |         DUPElem=LIST(find(ISDUP));          %Find the duplicate elements
31 |         ElemPosition=ismember(CS1,DUPElem); %Find the duplicate elements' position
32 |         RELATION=zeros(1,size(Chrom1,2));
33 |         
34 |         %Set up relacement relation table
35 |         i=1;
36 |         while i<=size(CS1,2)
37 |             if((ElemPosition(i)==0))
38 |                 i=i+1;
39 |             else
40 |                 a=CS1(i);
41 |                 b=CS2(i);
42 |                 if (~ismember(b,CS1))
43 |                     RELATION(a)=b;
44 |                     RELATION(b)=a;
45 |                 else
46 |                     while(ismember(b,CS1))
47 |                         temp=b;
48 |                         position=find(CS1==temp);
49 |                         b=CS2(position); %#ok<FNDSB>
50 |                     end
51 |                     RELATION(a)=b;
52 |                     RELATION(b)=a;
53 |                 end
54 |                 i=i+1;
55 |             end
56 |         end
57 |         j=1;
58 |         %Replacement
59 |         while(j<=size(Chrom1,2))
60 |             while(j>=SS&&j<=SE)
61 |                 j=j+1;
62 |             end
63 |             if(j>size(Chrom1,2))
64 |                 break
65 |             end
66 |             if(RELATION(Chrom1(j))==0)
67 |                 j=j+1;
68 |             else
69 |                 Chrom1(j)=RELATION(Chrom1(j));
70 |                 j=j+1;
71 |             end
72 |         end
73 |         j=j-1;
74 |         while(j~=0)
75 |             while(j>=SS&&j<=SE)
76 |                 j=j-1;
77 |             end
78 |             if(j==0)
79 |                 break;
80 |             end
81 |             if(RELATION(Chrom2(j))==0)
82 |                 j=j-1;
83 |             else
84 |                 Chrom2(j)=RELATION(Chrom2(j));
85 |                 j=j-1;
86 |             end
87 |         end
88 |         
89 |         crossover(k,:)=Chrom1;
90 |         crossover(k+1,:)=Chrom2;
91 |         
92 |     end
93 |     k=k+2;
94 | end
95 | 
96 | 
97 |     
98 |         
99 |     


--------------------------------------------------------------------------------
/AUV_GA/main.m:
--------------------------------------------------------------------------------
  1 | %%%%%%%%%% AUV path planning using GA %%%%%%%%%%
  2 | %%%%%Run 'RP_coordinate.m' before running main %%%%
  3 | 
  4 | clear all;
  5 | close all;
  6 | tic;%Runtime timer
  7 | %% global variables
  8 | 
  9 | load ('coor.mat');   %Load data generated by RP_coordinate.m
 10 | 
 11 | Popsize =50;         %Population size, should be an even integer
 12 | 
 13 | %Genetic parameters
 14 | %MIXRATE = 0.3;
 15 | ITERATION = 10000;   %Number of iteration
 16 | THRESHOLD = 100;
 17 | Pcross = 0.7;       %Crossover rate
 18 | Pmutation = 0.3;    %Mutation rate
 19 | 
 20 | %Begin
 21 | Parentpop=InitPop(Popsize,RPNUM,adjacency);
 22 | Fitnesscurve=[];
 23 | Generation = 1; 
 24 | 
 25 | Fitconst=0;         %Number of generations that fitness values remain constant
 26 | %% Genetic algorithm
 27 | while(Generation <= ITERATION)
 28 |     if (Fitconst<=THRESHOLD) %Stop iteration if fitness value is constant in threshold number of genreations
 29 |         fitness = Fitness(Parentpop,adjacency);       %Calculate fitness of parents
 30 |         crossover = Crossover(Parentpop,Pcross);      %Crossover
 31 |         Childpop = Mutation(crossover,Pmutation);     %Mutate and get chindren
 32 |         combopop=[Parentpop;Childpop];                %Combine parents and chindren
 33 |         combofitness=Fitness(combopop,adjacency);       %Calculate overall fitness
 34 |         nextpop=Select(combopop,combofitness);        %Select the first half of best to get 2nd gen
 35 |         Parentpop=nextpop.pop;
 36 |         if(Generation ==1)
 37 |             Best_GApath=Parentpop(1,:);
 38 |             Best_Fitness=combofitness(nextpop.bestplan);
 39 |         else
 40 |             New_Best_Fitness=combofitness(nextpop.bestplan);%Evaluate best solution
 41 |             New_Best_GApath=Parentpop(1,:);
 42 |             
 43 |             if(New_Best_Fitness<Best_Fitness)
 44 |                 Best_Fitness=New_Best_Fitness;
 45 |                 Best_GApath=New_Best_GApath;
 46 |                 Fitconst = 0;
 47 |                 
 48 |                 %%%%%%%%Visualize planning process%%%%%%%%
 49 | %                     GENERATION=[1:Generation-1];
 50 | %                     GAplancoor = [RP(Best_GApath).x;RP(Best_GApath).y; RP(Best_GApath).z].';
 51 | %                     figure(1);
 52 | %                     for i=1:RPNUM
 53 | %                         subplot(2,1,1);     %Plot all rendezvous points
 54 | %                         plot3(RP(i).x,RP(i).y,RP(i).z,'o');
 55 | %                         text(RP(i).x,RP(i).y, RP(i).z,num2str(i));
 56 | %                         hold on;
 57 | %                         subplot(2,1,2);
 58 | %                         plot(RP(i).x,RP(i).y,'o');
 59 | %                         text(RP(i).x,RP(i).y,num2str(i));
 60 | %                         hold on;
 61 | %                     end
 62 | %                     subplot(2,1,1);
 63 | %                     plot3(GAplancoor(:,1),GAplancoor(:,2),GAplancoor(:,3),'r-.');
 64 | %                     title('3D Path of AUV');
 65 | %                     grid on;
 66 | %                     hold off;
 67 | %                     subplot(2,1,2);
 68 | %                     plot(GAplancoor(:,1),GAplancoor(:,2),'r-.');
 69 | %                     title('2D Path of AUV');
 70 | %                     grid on;
 71 | %                     hold off;
 72 |                 %%%%%%%%Visualize planning process%%%%%%%%
 73 |                 
 74 |             else
 75 |                 Fitconst=Fitconst+1;
 76 |             end
 77 |         end
 78 |         
 79 |         Fitnesscurve(Generation)=Best_Fitness;
 80 |     
 81 |     else
 82 |         
 83 |         break
 84 |         
 85 |     end
 86 |     
 87 |     Generation = Generation +1;
 88 |     
 89 | end
 90 | 
 91 | Best_GApath(RPNUM+1)=Best_GApath(1); %Add the path from end to start
 92 | GENERATION=[1:Generation-1];
 93 | toc;
 94 | %% plot result plan
 95 |  GAplancoor = [RP(Best_GApath).x;RP(Best_GApath).y; RP(Best_GApath).z].';
 96 |         figure(1);
 97 |         for i=1:RPNUM
 98 |         subplot(2,1,1);     %Plot all rendezvous points
 99 |         plot3(RP(i).x,RP(i).y,RP(i).z,'o');
100 |         text(RP(i).x,RP(i).y, RP(i).z,num2str(i));
101 |         hold on;
102 |         subplot(2,1,2);
103 |         plot(RP(i).x,RP(i).y,'o');
104 |         text(RP(i).x,RP(i).y,num2str(i));
105 |         hold on;
106 |         end
107 |         subplot(2,1,1);
108 |         plot3(GAplancoor(:,1),GAplancoor(:,2),GAplancoor(:,3),'r-.');
109 |         title('3D Path of AUV');
110 |         grid on;
111 |         subplot(2,1,2);
112 |         plot(GAplancoor(:,1),GAplancoor(:,2),'r-.');
113 |         title('2D Path of AUV');
114 |         grid on;
115 |  %% Plot iteration of fitness
116 |  figure(2);
117 |  plot(GENERATION,Fitnesscurve,'r.-');
118 |  title('Minimum distance in each generation');
119 |  xlabel('Generation');
120 |  ylabel('Fitness value');
121 |  legend('Best Fitness Value');
122 |  set(gca, 'Fontname', 'Times New Roman', 'FontSize', 14);
123 |  grid on;
124 |  
125 | 


--------------------------------------------------------------------------------
/AUV_GA/tsp_dp1.m:
--------------------------------------------------------------------------------
  1 | %=======Traveling Salesman Problem Dynamic Programming Function ===========
  2 | %= This function solves the Traveling Salesman Problem (TSP) using Dynamic=
  3 | %= programming (DP).                                                      =
  4 | %= The function is based on the paper by Held and Karp from 1962. The DP  =
  5 | %= is guaranteed to provide the accurate (optimal) result to the TSP, but =
  6 | %= the time complexity of this algorithm is O(2^n n^2), which limits the  =
  7 | %= the use of this algorithm to 15 cities or less.                        =
  8 | %= NOTE: For reasonable runtime, please do not try to calculate a tour of =
  9 | %        more than 13 cities. DP is not for large sets of cities.         =
 10 | %= Inputs:                                                                =
 11 | %       Cities: an n-by-2 (or n-by-3) matrix of city locations. If this   =
 12 | %               input is not given, a set of 10 cities will be randomly   =
 13 | %               generated.                                                =
 14 | %       Dmatrix: This is an n-by-n matrix of the distances between the    =
 15 | %               cities. If not given, this matrix will be calculated at   =
 16 | %               initialization.                                           =
 17 | %= Outputs:                                                               =
 18 | %       OptimalTour: a vector with indices of the cities, according to the=
 19 | %               the optimal order of cities to visit. It is a closed tour =
 20 | %               that will return to city 1, which is assumed to be the    =
 21 | %               salesman's origin (depot).                                =
 22 | %=      mincost: the total length of the optimal route.                   =
 23 | %= Developed by: Elad Kivelevitch                                         =
 24 | %= Version: 1.0                                                           =
 25 | %= Date: 15 May 2011                                                      =
 26 | %==========================================================================
 27 | function [OptimalTour,mincost]=tsp_dp1(cities, Dmatrix)
 28 | % Initialization Process
 29 | if nargin==0
 30 |     cities=random('unif',0,100,10,2);
 31 | end
 32 | [dummy,NumOfCities]=size(cities);
 33 | Primes=primes(NumOfCities*10);
 34 | if nargin<2 %No Dmatrix used    
 35 |     D=diag(inf*ones(1,NumOfCities)); %Assign an inifinite cost to traveling from a city to itself
 36 |     for i=1:NumOfCities %Assign the distances between pairs of cities
 37 |         for j=i+1:NumOfCities
 38 |             D(i,j)=norm(cities(i,:)-cities(j,:));
 39 |             D(j,i)=D(i,j);
 40 |         end
 41 |     end
 42 | else
 43 |     D=Dmatrix;
 44 | end
 45 | NumOfDataSets=1;
 46 | for i=2:NumOfCities
 47 |     NumOfDataSets=NumOfDataSets+nchoosek(NumOfCities,i);
 48 | end
 49 | Data(NumOfDataSets).S=[];
 50 | Data(NumOfDataSets).l=0;
 51 | Data(NumOfDataSets).cost=inf;
 52 | Data(NumOfDataSets).pre=[];
 53 | Data(NumOfDataSets).m=[];
 54 | LookUpTable(NumOfDataSets)=0;
 55 | %Define a data structure that holds the following pieces of data we need
 56 | %for later. This data structure uses the same notation used in the paper 
 57 | %by Held and Karp (1962):
 58 | % S - the set of cities in the tour.
 59 | % l - the last city visited in the set S. 
 60 | % cost - the cost of a tour, which includes all city in S and ends at l.
 61 | %In addition, the following data items are used in the dataset for reducing
 62 | %runtime:
 63 | % Pre - the index of predecessor dataset, i.e. the one with Spre=S-{l}
 64 | % m - the city in S-{l} that yielded the lowest cost C(Spre,m)+D(m,l).
 65 | % This index will facilitate the generation of the optimal tour without
 66 | % further calculations.
 67 | Data(1).S=[1];
 68 | Data(1).l=1;
 69 | Data(1).cost=0;
 70 | Data(1).Pre=[];
 71 | Data(1).m=[];
 72 | for s=2:NumOfCities
 73 |     Data(s).S=[Data(1).S,s];
 74 |     Data(s).l=s;
 75 |     Data(s).cost=D(s,1);
 76 |     Data(s).Pre=1;
 77 |     Data(s).m=1;
 78 |     LUT=calcLUT(Data(s).S,s,Primes);
 79 |     LookUpTable(s)=LUT;
 80 | end
 81 | IndexStartPrevStep=2; %index into Data that marks the beginning of the previous step
 82 | IndexLastStep=NumOfCities; %index into Data that marks the end of the previous step
 83 | CurrentData=IndexLastStep; %index into Data that marks the current dataset
 84 | %This is the main Dynamic Programming loop
 85 | for s=3:NumOfCities
 86 |     %generate possible sets with s-1 cities out of the possible N-1 cities
 87 |     %(not including city 1)
 88 |     TempSets=nchoosek(2:NumOfCities,s-1);
 89 |     NumOfSets=size(TempSets);
 90 |     for j=1:NumOfSets(1) %iterate through all the sets
 91 |         for k=1:NumOfSets(2) %iterate through all the elements in each set
 92 |             SminuskSet=[1,TempSets(j,1:k-1),TempSets(j,k+1:NumOfSets(2))]; %this is the set S-{k}               
 93 |             candidatecost(2:length(SminuskSet))=inf;
 94 |             indices=[];
 95 |             for mm=2:length(SminuskSet) %choose a city in S-{k} that will be last
 96 |                 LUV=calcLUT(SminuskSet,SminuskSet(mm),Primes);
 97 |                 index=find(LUV==LookUpTable(IndexStartPrevStep:IndexLastStep));  
 98 |                 index=index+IndexStartPrevStep-1;
 99 |                 if index==0
100 |                     candidatecost(mm)=inf;                    
101 |                 else
102 |                     candidatecost(mm)=Data(index).cost+D(SminuskSet(mm),TempSets(j,k));
103 |                     indices(mm)=index;
104 |                 end                
105 |             end
106 |             [mincost,indexcost]=min(candidatecost(2:end));
107 |             CurrentData=CurrentData+1;
108 |             Data(CurrentData).S=[1,TempSets(j,:)];
109 |             Data(CurrentData).l=TempSets(j,k);
110 |             Data(CurrentData).cost=mincost;
111 |             Data(CurrentData).Pre=indices(indexcost+1);
112 |             Data(CurrentData).m=SminuskSet(indexcost+1);
113 |             LookUpTable(CurrentData)=calcLUT(Data(CurrentData).S,TempSets(j,k),Primes);
114 |         end
115 |     end
116 |     IndexStartPrevStep=IndexLastStep+1;
117 |     IndexLastStep=CurrentData;    
118 | end
119 | mm=0;
120 | %Now add the distance back from the last city to city 1
121 | for i=IndexStartPrevStep:IndexLastStep
122 |     mm=mm+1;
123 |     candidatecost(mm)=Data(i).cost+D(Data(i).l,1);
124 | end
125 | %Find the one that minimizes the total distance
126 | [mincost,indexcost]=min(candidatecost);
127 | Temp=Data(IndexStartPrevStep+indexcost-1);
128 | %Generate the optimal tour by traversing back from the last city to its
129 | %predecessors
130 | OptimalTour=1;
131 | while ~isempty(Temp.Pre)
132 |     OptimalTour=[OptimalTour,Temp.l];
133 |     Temp=Data(Temp.Pre);
134 | end
135 | OptimalTour=[OptimalTour,1];
136 | function LUT=calcLUT(vec,last,Primes)
137 | j=length(vec);
138 | LUT=Primes(last);
139 | for i=2:j
140 |     LUT=LUT*Primes(vec(i));
141 | end


--------------------------------------------------------------------------------