0 Up votes0 Down votes

10 views83 pagesA final year project submitted in partial fulfillment of the requirement for the degree of Bachelor of Science in CSIT.
Among different algorithms of ACO, Ant System and Ant Colony System are the most used algorithm in solving TSP, which uses probability calculation and global pheromone update. We researched on the ACO, and adopt it to solve the TSP problem. The simulation results show how this ACO algorithm is able to solve TSP with varying city numbers.

Jun 26, 2018

© © All Rights Reserved

PDF, TXT or read online from Scribd

A final year project submitted in partial fulfillment of the requirement for the degree of Bachelor of Science in CSIT.
Among different algorithms of ACO, Ant System and Ant Colony System are the most used algorithm in solving TSP, which uses probability calculation and global pheromone update. We researched on the ACO, and adopt it to solve the TSP problem. The simulation results show how this ACO algorithm is able to solve TSP with varying city numbers.

© All Rights Reserved

10 views

A final year project submitted in partial fulfillment of the requirement for the degree of Bachelor of Science in CSIT.
Among different algorithms of ACO, Ant System and Ant Colony System are the most used algorithm in solving TSP, which uses probability calculation and global pheromone update. We researched on the ACO, and adopt it to solve the TSP problem. The simulation results show how this ACO algorithm is able to solve TSP with varying city numbers.

© All Rights Reserved

You are on page 1of 83

XAVIER’S COLLEGE

(Affiliated to Tribhuvan University)

Maitighar, Kathmandu

on

“ANT COLONY OPTIMIZATION FOR SOLVING

TRAVELLING SALESMAN PROBLEM” - [CSC - 404]

“Er. Rajan Karmacharya”

Submitted by

Sanjay Paudel (TU Exam Roll No-510/066)

Suman Karki (TU Exam Roll No-518/066)

Suraj Shrestha (TU Exam Roll No-519/066)

Submitted to

ST. XAVIER’S COLLEGE

Department of Computer Science

Maitighar, Kathmandu, Nepal

October 7, 2013

Ant Colony Optimization for solving

Travelling Salesman Problem

[CSC-404]

for the degree of Bachelor of Science in Computer Science and

Information Technology.

Submitted by:

Sanjay Paudel (TU Exam Roll No-510/066)

Suman Karki (TU Exam Roll No-518/066)

Suraj Shrestha (TU Exam Roll No-519/066)

Submitted to:

ST. XAVIER’S College

Department of Computer Science

Maitighar, Kathmandu

Nepal

October 7, 2013

CERTIFICATE OF APPROVAL

The undersigned certify that they have read and recommended to the Department of

Computer Science for acceptance, a project report entitled “Ant Colony Optimization

for solving Travelling Salesman Problem” submitted by Sanjay Paudel, Suman

Karki and Suraj Shrestha in partial fulfillment for the degree of Bachelor of Science

in Computer Science & Information Technology.

…………………………..

Supervisor

Department Of Computer Science

St. Xavier’s College, Maitighar, Kathmandu, Nepal

……………………………..

External Examiner

Department Of Computer Science

Tribhuvan University

……………………………..

Head of Department

Department Of Computer Science

St. Xavier’s College, Maitighar, Kathmandu, Nepal

i

ACKNOWLEDGEMENT

The success and final outcome of this project required a lot of guidance and assistance

from many people and we are very fortunate to have got this all along the completion

of this project. We are very glad to express our deepest sense of gratitude and sincere

thanks to our highly respected and esteemed supervisor Er. Rajan Karmacharya for

his valuable supervision, guidance, encouragement and support for completing this

work. His useful suggestions for this whole work and co-operative behavior are

sincerely acknowledged.

We would like to express our sincere thanks to our Head of Department Mr. Vishnu

Kumar Rana, for giving us an opportunity to undertake this project being a subject

teacher as well as for guiding us to achieve our ultimate goal on behalf of Head of

Department. His inspiration and helpful guidance has made this project successful.

We are also grateful to our teachers Mr. Jeetendra Manandhar, Miss Shova

Shrestha, Mr. Bal Krishna Subedi, Mr. Sanjay Kumar Yadav for their constant

support and guidance. As well lab’s technicians Mr. Om Shrestha and Mr. Sunim

Shrestha for assisting us and providing required lab and other necessity throughout our

project duration. We would also like to thank Mr. Chiranjivi Sitaula to assist us and

supporting us in need.

At the end we would like to express our sincere thanks to all our friends and others who

helped us directly or indirectly during this project work.

Suman Karki (TU Exam Roll No-518/066)

Suraj Shrestha (TU Exam Roll No-519/066)

ii

ABSTRACT

The travelling salesman problem is one of the most important combinatorial problems

and a NP-hard problem whose challenge is to complete Hamilton circle selecting the

shortest path without leaving any cities behind.

Nature is the solution to every problem and creatures are the actor. In ant colony, real

ants are able to create successively shorter feasible tours to their food, by using

information accumulated in the form of a pheromone trail deposited on their path. The

intelligence of the colony arises from indirect communication between individual ants

through pheromones in getting food with shorter path. ACO is a heuristic algorithm

which has been proven a successful technique and applied to a number of combinatorial

optimization problems where real ants are represented by the artificial ant. These

artificial ants are placed at random points, which spread pheromone on their travelling

route and with use of information of pheromone on their path, they find the shortest

path.

Among different algorithms of ACO, Ant System and Ant Colony System are the most

used algorithm in solving TSP, which uses probability calculation and global

pheromone update. Here in our project also we researched on the ACO, and adopt it to

solve the TSP problem. The simulation results show how this ACO algorithm is able

to solve TSP with varying city numbers.

We have selected the C# as programming language and Visual Studio as our platform

and for designing the application of our project. For user friendly, we have designed

the graphical user interface that can take input either map image or the manual input of

the nodes. User can enter the required parameter value as desired and save the generated

output either on local directory. Our project’s application can be used to determine the

optimal path for the other development project like road construction, water

distribution, network routing, etc.

iii

Table of Contents

ACKNOWLEDGEMENT ............................................................................................ ii

ABSTRACT ................................................................................................................. iii

A. List of Figures ...................................................................................................... vii

B. List of Tables ...................................................................................................... viii

C. List of Symbols ..................................................................................................... ix

D. List of Abbreviation............................................................................................... x

Chapter 1: Project Overview ......................................................................................... 1

1.1 Introduction ............................................................................................................. 1

1.1.1 Ant’s foraging behavior .......................................................................... 2

1.1.2 Problem Statement .................................................................................. 3

1.1.3 Travelling salesman problem .................................................................. 4

1.1.4 Ant Colony Optimization........................................................................ 6

1.1.5 Why ACO?.............................................................................................. 8

1.1.6 Why to use ACO for TSP?...................................................................... 8

1.2 Scope .............................................................................................................. 9

1.3 Objectives ....................................................................................................... 9

1.4 Project features ............................................................................................. 10

1.5 Feasibility ..................................................................................................... 10

1.5.1 Technology and system feasibility........................................................ 10

1.5.1.1 Why Visual Studio platform and Visual C#? .................................... 11

1.5.2 Legal feasibility .................................................................................... 11

1.5.3 Operational feasibility........................................................................... 11

1.5.4 Schedule feasibility ............................................................................... 12

1.6 System requirements .................................................................................... 12

Chapter 2: Literature Review ...................................................................................... 13

2.1 Double bridge experiments .......................................................................... 16

iv

2.2 Problems in Artificial Intelligence related to Travelling Salesman Problem18

2.3 Algorithms of ACO ...................................................................................... 19

2.3.1 Ant System ............................................................................................ 19

2.3.2 Ant Colony System ............................................................................... 20

2.4 Comparison of computational time of ACO with other algorithms ............. 22

Chapter 3: System Development ................................................................................ 23

3.1 Method ......................................................................................................... 23

3.1.1 Digital Representation of ant ................................................................ 24

3.1.2 General technique ................................................................................. 25

3.1.3 Tour Construction ................................................................................. 25

3.1.3.1 Role of α and β .................................................................................. 26

3.1.4 Pheromone updating and evaporation ................................................... 26

3.1.5 Constants ............................................................................................... 27

3.2 Design........................................................................................................... 28

3.2.1 Data Structures ...................................................................................... 28

3.2.1.1 Problem and Data Representation ..................................................... 28

3.2.1.2 Ant representation ............................................................................. 29

3.2.2 The Algorithm ....................................................................................... 31

3.2.2.1 Data Initialization .............................................................................. 34

3.2.2.2 Construct Solution and Update Statistics .......................................... 35

3.2.2.3 Probability Calculation ...................................................................... 38

3.2.2.4 Tour Length Calculation ................................................................... 41

3.2.2.5 Pheromone update ............................................................................. 41

3.2.2.6 Program Termination ........................................................................ 43

3.3 Development ................................................................................................ 44

3.3.1 Program Structure ................................................................................. 44

3.3.2 Interface of program ............................................................................. 46

3.4 Testing .......................................................................................................... 48

3.4.1 Unit testing ............................................................................................ 48

v

3.4.2 Integration testing ................................................................................. 49

3.4.3 System testing ....................................................................................... 49

3.5 Validation ..................................................................................................... 50

Chapter 4: Epilogue .................................................................................................... 51

4.1 Result............................................................................................................ 51

4.2 Result Analysis ............................................................................................. 53

4.3 Critical Analysis ........................................................................................... 55

4.4 Limitation ..................................................................................................... 59

4.5 Future enhancement ..................................................................................... 59

4.6 Conclusion.................................................................................................... 59

References ................................................................................................................... 60

Bibliography ............................................................................................................... 62

Appendices .................................................................................................................. 64

A. Time Schedule ................................................................................................. 64

B. Gantt Chart ....................................................................................................... 65

C. Source Code ..................................................................................................... 66

vi

A. List of Figures

Figure 2-1: Experimental Setup for double bridge experiment 16

Figure 3-1: Flow chart of system design 33

Figure 3-2: Program Flow Diagram 45

Figure 3-3: Snapshot for startup form 46

Figure 3-4: Snapshot after point selection 47

Figure 3-5: Snapshot showing the optimal path 48

Figure 3-6: Validating Program 50

Figure 4-1: City selection 51

Figure 4-2: Result obtained showing optimal path 52

Figure 4-3: Graph showing computational time and number of cities 54

Figure 4-4: Graph showing straight connection in between cities 58

vii

B. List of Tables

Table 2: Value of Constants 27

Table 3: Result showing computational time 53

viii

C. List of Symbols

n Number of cities

m Number of ants

β Heuristic information

τ Pheromone value

η Heuristic visibility

ix

D. List of Abbreviation

AI Artificial Intelligence

AS Ant System

CO Combinational Optimization

EN Elastic Net

FI Farthest Insertion

OS Operating System

SA Simulated Annealing

SO Self-Organization

x

Chapter 1: Project Overview

1.1 Introduction

Ants exhibit complex social behaviors that have long since attracted the attention of

human beings. Ant is a kind of animal which is puny and almost has no eyesight, but it

can achieve very complex action when ants are communal, which can not only transport

the food number of times larger than the ant in volume and weight to the ant hold, but

also can find the shortest path between food and ant hole.

The individual agents are not able to solve the problem by themselves, but a solution

emerges from the cooperative behavior of all associated individuals. Ants may not be

very clever individual, but ant colonies can be. Individual insects living in colonies,

such as ants, bees or wasps do their own specific task and yet the colony is very

organized, it does not require any kind of supervision. This is called self-organization

(SO).The mechanism that allows the SO in insect colonies is the stigmergy (mechanism

of indirect coordination between agents), which consists of the indirect communication

between pairs of individuals through the change of some environment property; in the

ant colonies case, this property is the pheromone concentration. [1]

The ants release chemicals known as pheromone on the ground while walking from

their nest to food and then go back to the nest. Ants can communicate with one another

through pheromones in their immediate environment. The ants move according to the

amount of pheromones, the richer the pheromone trail on a path is, the more likely it

would be followed by other ants. So a shorter path has a higher amount of pheromone

in probability, ants will tend to choose a shorter path. Through this mechanism, ants

will eventually find the shortest path.

1

1.1.1 Ant’s foraging behavior

When an ant is searching for the nearest food source and arrives at several possible

trails, it tends to choose the trail with the largest concentration of pheromones, with a

certain probability. After choosing the trail, it deposits another pheromone, increasing

the concentration of pheromones in this trail. The ants return to the nest using always

the same path, depositing another portion of pheromone in the way back. Imagine then,

that two ants at the same location choose two different trails at the same time.

The pheromone concentration on the shortest way will increase faster than the other:

the ant that chooses this way, will deposit more pheromone in a smaller period of time,

because it returns earlier. If a whole colony of thousands of ants follows this behavior,

soon the concentration of pheromone on the shortest path will be much higher than the

concentration in other paths. Then the probability of choosing any other way will be

very small and only very few ants among the colony will fail to follow the shortest

path.

2

(A) Real ants follow a path between nest and food source. (B) An obstacle appears on

the path: Ants choose whether to turn left or right with equal probability. (C)

Pheromone is deposited more quickly on the shorter path. (D) All ants have chosen the

shorter path.

(Source: Marco Dorigo, Ant colonies for the traveling salesman problem,

TR/IRIDIA/1996-3Université Libre de Bruxelles Belgium pg: 3)

chemical substance, it tends to evaporate, so the concentration of pheromones vanishes

along the time. In this way, the concentration of the less used paths will be much lower

than that of the most used ones, not only because the concentration increases on the

other paths, but also because its own concentration decreases [1].

By sensing pheromone trails foragers can follow the path to food discovered by other

ants. This collective trail-laying and trail-following behavior whereby an ant is

influenced by a chemical trail left by other ants is the inspiring source of ACO. [2]

In the field of computer science all the problems are defined under the NP class

problem. The class NP is the set of problems that can be solved by a non-deterministic

Turing machine that can be solved in polynomial time. These problems have the

solution on non-polynomial time. The processing time for those problems takes infinite

time to execute in compare to those class p problems. P-Class problem is the subset of

NP-class problems. That means NP contains many problem not in P. The best example

for this is TSP problem.

In real world experience time is most crucial factor to get every development work

optimal. And with time the complexity in doing such work is also a great problem.

Development work like vehicle routing, networking, water distribution, etc. are lacking

3

the proper analysis before their implementation on due to which more resources with

time acquired. TSP problem represent such real world problem regarding its

importance in real life our project is based on solving the TSP problem.

Traveling salesman problem is one of the well-known and extensively studied problems

in discrete or combinational optimization and asks for the shortest round trip of minimal

total cost visiting each given city exactly once. TSP is an NP-hard problem and it is so

easy to describe but so difficult to solve. [3] The class NP contains all decision

problems that are decidable by a non-deterministic algorithm that runs in polynomial

time. A problem n is NP-hard if a polynomial-time algorithm for n would imply a

polynomial-time algorithm for every problem in NP. In other words: n is NP-hard- if n

can be solved in polynomial time. [4]

Intuitively, the TSP is the problem of a salesman who, starting from his hometown,

wants to find a shortest tour that takes him through a given set of customer cities and

then back home, visiting each customer city exactly once. More formally, the TSP can

be represented by a complete weighted graph G = (N, A) with N being the set of nodes

representing the cities, and A being the set of arcs. (Note that if the graph is not

complete, one can always add arcs to obtain a new, complete graph G with exactly the

same optimal solutions as G; this can be achieved by assigning to the additional arcs

weights that are large enough to guarantee that they will not be used in any optimal

solution.) Each arc (i, j) ε A is assigned a value (length) dij, which is the distance

between cities i and j, with i, j ε N. Then the goal of TSP is to find the shortest path that

could be used to visit every city and then return back to the starting city with minimum

cost. In the general case of the asymmetric TSP, the distance between a pair of nodes

i, j is dependent on the direction of traversing the arc, that is, there is at least one arc (i,

j) for which dij≠dji. For any two points i and j, with (xi, yi) and (xj, yj), their distance is

calculated by the given equation (1.1).

4

2 2

𝑑𝑖 𝑗 = √(𝑥𝑖 − 𝑥𝑗 ) + (𝑦𝑖 − 𝑦𝑗 ) …………. (1.1)

In the symmetric TSP, dij =dji holds for all the arcs in A. The goal in the TSP is to find

a minimum length Hamiltonian circuit of the graph, where a Hamiltonian circuit is a

closed path visiting each of the n = |N| nodes of G exactly once. Thus, an optimal

solution to the TSP is a permutation p of the node indices (1, 2 . . . n) such that the

length 𝑓(𝜋) is minimal, where 𝑓(𝜋)is given by

𝑓(𝜋) = ∑𝑛−1

𝑖=1 𝑑𝜋(𝑖)𝜋(𝑖+1) + 𝑑𝜋(𝑛)𝜋(1) …………. (1.2)

TSP consists of finding the shortest route in complete weighted graph G with n nodes

and n (n-1) edges; so that the start node and the end node are identical and all other

nodes in this tour are visited exactly once. The most popular practical application of

TSP are: regular distribution of goods or resources, finding of the shortest of costumer

servicing route, planning bus lines etc., but also in the areas that have nothing to do

with travel routes. [5]

The TSP problem belongs in the class of combinatorial optimization problems known

as NP-complete. Specifically, if one can find an efficient algorithm (i.e., an algorithm

that will be guaranteed to find the optimal solution in a polynomial number of steps)

for the traveling salesman problem, then efficient algorithms could be found for all

other problems in the NP-complete class [6].Unfortunately, the TSP is a very difficult

problem. A brute force approach to a TSP of n cities would have a computational

complexity of

(𝑛−1)!

…………. (1.3)

2

However, Ant Colony Optimization is taken as one of the high performance computing

methods for TSP. [7]

5

1.1.4 Ant Colony Optimization

Ant Colony Optimization (ACO) is the only algorithm that implements the foraging

behavior of the ants. ACO is a paradigm for designing meta-heuristic algorithms for

combinatorial optimization problems. This algorithm is a member of the ant colony

algorithms family, in swarm intelligence methods, and it constitutes some

metaheuristic optimizations. Metaheuristic algorithms are algorithms which, in order

to escape from local optima, drive some basic heuristic: either a constructive heuristic

starting from a null solution and adding elements to build a good complete one, or a

local search heuristic starting from a complete solution and iteratively modifying some

of its elements in order to achieve a better one. The metaheuristic part permits the low-

level heuristic to obtain solutions better than those it could have achieved alone, even

if iterated. Usually, the controlling mechanism is achieved either by constraining or by

randomizing the set of local neighbor solutions to consider in local search (as is the

case of simulated annealing or tabu search), or by combining elements taken by

different solutions (as is the case of evolution strategies and genetic or bionomic

algorithms). [8]

Initially proposed by Marco Dorigo in 1992 in his PhD thesis, the first algorithm was

aiming to search for an optimal path in a graph, based on the behavior of ants seeking

a path between their colony and a source of food. And, since then, many diverse

variants of the basic principle have been reported in the literature [2]. The essential trait

of ACO algorithms is the combination of a priori information about the structure of a

promising solution with a posteriori information about the structure of previously

obtained good solutions.

This algorithm is inspired by the fact that ants are able to find the shortest route between

their nest and a food source, even though they are almost blind. This is accomplished

by using pheromone chemical trails as a form of indirect communication. Ants deposit

pheromone trails whenever they travel. The path taken by individual ants from the nest

6

in search for a food source is essentially random ~Dorigo et al. 1996. However, when

many ants are searching for a food source simultaneously, the paths taken are affected

by the pheromone trails laid by other ants. When ants encounter pheromone trails, there

is a higher probability that trails with higher pheromone intensities will be chosen. As

more ants travel on paths with higher pheromone intensities, the pheromone on these

paths builds up further, making it more likely to be chosen by other ants .[9]

Thus, after starting with the random path that might be/might not be shortest path, they

end up with the optimal path to reach their colony from their food and vice – versa.

7

1.1.5 Why ACO?

ACO has a number of advantages, for which it has been used in different fields. Some

of them are given below:

Inherent parallelism

Positive feedback accounts for rapid discovery of good solution

Efficient for travelling salesman problem and similar problems

Can be used in dynamic applications where it can adapt to changes like new

distance, etc.

There are numerous reasons for the choice of the TSP as the problem to explain the

working of ACO algorithms:

applications;

TSP is a problem to which ACO algorithms are easily applied;

TSP is easily understandable, so that the algorithm behavior is not obscured by

too many technicalities;

TSP is a standard test bed for new algorithmic ideas - a good performance on

the TSP is often taken as a proof of their usefulness.

Additionally, the history of ACO shows that very often the most efficient ACO

algorithms for the TSP were also found to be among the most efficient ones for a wide

variety of other problems.

8

1.2 Scope

The research on ACO doesn’t just limit on development of certain application in spite

it is very vast and require to make more efficient. After the development of the ACO

algorithm the concept of this algorithm can be implemented in the various aspects. As

similar to search algorithm, it can be used to trace the various database server. Beside

this there are more real world areas where ACO concept can be implemented like water

distribution in city, Data mining, network routing, travelling salesman problem,

comparison in searching algorithm, robot path planning, etc. Regarding the wide scope

and even helpful to day to day life this project will add some more milestone on the

development of the country.

This project has certain scope to solve TSP problem and implement that algorithm in

the development procedure like road construction for road development department

and optimal path finding for any circumstances like water distribution, electricity

wiring, etc. inside our country for the development.

1.3 Objectives

1. To develop computer programs that can solve TSP with the use of ACO

algorithm.

2. To compare ACO algorithm that addresses and solves TSP with other

algorithms that are capable of solving TSP.

3. To analysis the data and generate report for ACO and TSP.

9

1.4 Project features

Our project is based on ACO to solve the TSP problem using AS algorithm. Here using

the probability and pheromone update we have succeeded to generalize the TSP

problem. With detailed research we have implement the ACO in real application. Using

our project development project work like road mapping, drinking water distribution

planning can be implemented inside the country with optimal path of selection. Our

project helps for the projection of the optimal path through which with minimum

expenses and time also other development project can be done in accordance.

Studying the current system feasibility our application has been developed in .net

framework depended system like Microsoft windows XP, windows 7, using Visual

C# programming language. It can be executed in every Microsoft OS dependent

machine. Our project is the windows form based application. In spite of better user

interface, it also uses map coordinates as input which may be either points selected

through random drawing or selected from a browsed map which dynamically get into

program and gives result after the various calculation and manipulation rounds in the

form of map with highlighted selected optimal path.

1.5 Feasibility

With detailed research and analyzing the necessity of TSP solution in the country

development aspect we had proposed this project. .Our application is feasible in the

following factors:

Our application is built in Visual Studio 2012 platform using Visual C# programming

language and can run in every Microsoft OS products later from windows XP having

.net framework version greater than 3.5.It’s very reliable and can perform even in lower

10

processor like pentium4 but its execution get a little slow with that because of less

number of core processor. Talking about the input data, user can just browse their map

or other pictures and select required points as cities. Our product is more feasible and

can run efficiently with current available any system.

The main advantage of C# is that it runs on the CLR, making it easy to integrate with

components written in other languages (specifically, CLR-compatible languages) and

many of Microsoft's proprietary technologies. Also note that much of .NET has been

standardized, which means that it could run on other platforms.

Writing in C# also gives one access to all the .NET Framework class libraries, which

are quite extensive. While these libraries might support specific features better than in

Java (WPF is arguably better suited for rich multimedia GUIs than java.Swing), on the

whole Java SDK's feature set if very similar to the .NET Framework and one can't say

one is better than the other in general.

This application will not violate any rules and regulation. Whatever the formulas and

measures were researched and used are noted with references of their paper published

and author names. Also this project will not violate copyright act because with full

description of references we have documented each and every minor parts thinking

sensitively. And in regards of codes, they are coded by our team members and the

copyright solely goes to our team member only.

As we have already mentioned about the technical feasibility, there is no errors and

bugs are found during our runtime procedure as well this application solves even TSP

11

problem with more than 100 nodes with assigned value of ants but that may take long

enough time for calculation and manipulation.

This project and application has wide space of scope so whatever are described above

this product can adequately solve every development works if applied with intelligence

conscience.

We had given the period of this whole semester to fulfill the proposed project so now

we think we had successfully accomplished the project with proposed time schedule

though there were certain activity risk occurred in between they are represented in Time

Schedule and Gantt chart as final schedule of our project in appendix A and B.

Operating System: OS later from Microsoft XP, Microsoft products.

Processors: Pentium 4 or any greater processor.

Ram: 512 MB minimum

Display: Graphical over 64mb

12

Chapter 2: Literature Review

In the history of the ACO, First of all, the first ACO system was introduced by Marco

Dorigo in his Ph.D. thesis (1992), and was called Ant System. AS is the result of a

research on computational intelligence approaches to combinatorial optimization that

Dorigo conducted at Politecnico di Milano in collaboration with Alberto Colorni and

Vittorio Maniezzo. AS was initially applied to the travelling salesman problem, and to

the quadratic assignment problem. Alberto Colorni and Vittorio Maniezzo contributed

at the beginning. Alberto and Vittorio collaborated closely with Marco Dorigo in the

definition of the first ACO algorithms while Marco was a doctoral student at

Politecnico di Milano, in Milan, Italy. Marco Dorigo (born 26 August 1961, in Milan,

Italy) is a research director for the Belgian Funds for Scientific Research (FNRS), a

professor in the computer science department of the University of Paderborn and a co-

director of IRIDIA, the artificial intelligence lab of the Université Libre de Bruxelles.

He is the proponent of the ant colony optimization metaheuristic , and one of the

founders of the swarm intelligence research field. Recently he got involved with

research in swarm robotics.

Jean-Louis Deneubourg and Luca Maria Gambardella, recognized experts in the study

of social insects, provided the inspiration for the ACO work. Luca, a computer scientist

with a strong feeling for practical applications, was the one who most helped in

transforming ACO from a fascinating toy into a competitive metaheuristic[2].Since

then ACO has been weapons to solve many major problems like Routing Problems,

Assignment Problems, Scheduling Problems, Subset Problems, Other NP-Hard

Problems, Machine Learning Problems, etc.

Blum & Dorigo (2003, 2004) experimentally and theoretically studied the behavior of

AS applied to unconstrained binary problems, that is, binary problems for which the

values of different decision variables are independent of each other. They were able to

13

prove that, in this setting, the expected quality of the solutions generated by AS

increases monotonically over time. Although their result cannot be transferred to the

application of AS to constrained problems, in Blum & Dorigo (2003) they give

empirical evidence that it holds for one of the most studied constrained problems: the

TSP. In 2003, Marco Dorigo received the European Commission's Marie Curie

Excellence Award for his research on Ant Colony Optimization and Ant Algorithms.

In recent years, many research works have been devoted to ant colony optimization

(ACO) techniques in different areas. It is a relatively novel meta-heuristic technique

and has been successfully used in many applications especially problems in

combinatorial optimization. ACO has been widely applied to solving various

combinatorial optimization problems such as Traveling Salesman Problem (TSP), Job-

shop Scheduling Problem (JSP), Vehicle Routing Problem (VRP), Quadratic

Assignment Problem (QAP), etc. [3]

ANTS 2012: Eighth International Conference on Ant Colony Optimization and

Swarm Intelligence, Brussels, Belgium, 12.-14. September 2012.

ANTS 2010: Seventh International Conference on Ant Colony Optimization

and Swarm Intelligence, Brussels, Belgium, 08.-10. September 2010.

ANTS 2008: Sixth International Conference on Ant Colony Optimization and

Swarm Intelligence, Brussels, Belgium, 22.-24. September 2008.

IEEE Swarm Intelligence Symposium 2007, Hilton Hawaiian Village,

Honolulu, Hawaii, April 1-5, 2007.

ANTS 2006: Fifth International Workshop on Ant Colony Optimization and

Swarm Intelligence, Brussels, Belgium, 4.-7. September 2006.

IEEE Swarm Intelligence Symposium 2006, Indianapolis, Indiana, USA, 12.-

14. May 2006.

14

ACO/Swarm Intelligence Track at GECCO 2005 Washington D.C., USA, June

25-29, 2005

IEEE 2005: Swarm Intelligence Symposium, The Westin Pasadena, Pasadena,

California, USA, June 8-10, 2005.

ANTS 2004: Fourth International Workshop on Ant Colony Optimization and

Swarm Intelligence, Brussels, Belgium, 5.-8. September 2004.

ANTS 2002 - From Ant Colonies to Artificial Ants: Third International

Workshop on Ant Algorithms, Brussels, Belgium, 11.-14. September 2002.

Special ACO session at MIC-2001 Porto, Portugal, July 16-20, 2001.

ACO special track at GECCO-2001 San Francisco, USA, July 7-11, 2001.

ANTS'2000 - From Ant Colonies to Artificial Ants: Second International

Workshop on Ant Algorithms, Brussels, Belgium, September 8-9, 2000.

Ant Colony Methods Session at 1999 Congress on Evolutionary Computation,

Washington DC, USA, July 6-9, 1999

ANTS'98 - From Ant Colonies to Artificial Ants: First International Workshop

on Ant Colony Optimization, Brussels, Belgium, October 15-16, 1998.

Ant Colony Optimization Session at INFORMS Tel Aviv 1998

Tel Aviv, Israel, June 28 - July 1, 1998

(Source:aco-metaheuristic.org)

15

2.1 Double bridge experiments

The foraging behavior of many ant species, as, for example, I. humilis (Goss et al.,

1989), Linepithemahumile, and Lasiusniger (Bonabeau et al., 1997), is based on

indirect communication mediated by pheromones. While walking from food sources to

the nest and vice versa, ants deposit pheromones on the ground, forming in this waya

pheromone trail. Ants can smell the pheromone and they tend to choose,

probabilistically, paths marked by strong pheromone concentrations. The pheromone

trail-laying and -following behavior of some ant species has been investigated in

controlled experiments by several researchers. One particularly brilliant experiment

was designed and run by Deneubourg and colleagues (Deneubourg, Aron, Goss,

&Pasteels, 1990; Goss et al., 1989), who used a double bridge connecting a nest of ants

of the Argentine ant species I. humilis and a food source. They ran experiments varying

the ratio r =1, ll=ls between the length of the two branches of the double bridge, where

ll was the length of the longer branch and ls the length of the shorter one.

(a) Branches have equal length. (b) Branches have different length.

16

In the first experiment the bridge had two branches of equal length (r=1, in figure

2.1(a)). At the start, ants were left free to move between the nest and the food source

and the percentage of ants that chose one or the other of the two branches were observed

over time. The outcome was that see figure 2.1(a), although in the initial phase random

choices occurred, eventually all the ants used the same branch. This result can be

explained as follows. When a trial starts there is no pheromone on the two branches.

Hence, the ants do not have a preference and they select with the same probability any

of the branches. Yet, because of random fluctuations, a few more ants will select one

branch over the other. Because ants deposit pheromone while walking, a larger number

of ants on a branch results in a larger amount of pheromone on that branch; this larger

amount of pheromone in turn stimulates more ants to choose that branch again, and so

on until finally the ants converge to one single path.

organizing behavior of the ants: a macroscopic pattern (corresponding to the

convergence toward one branch) emerges out of processes and interactions taking place

at a ‘‘microscopic’’ level (Camazine, Deneubourg, Franks, Sneyd, Theraulaz, &

Bonabeau, 2001; Haken, 1983; Nicolis& Prigogine, 1977). In our case the convergence

of the ants’ paths to one branch represents the macroscopic collective behavior, which

can be explained by the microscopic activity of the ants, that is, by thelocal interactions

among the individuals of the colony. It is also an example of stigmergic

communication; ants coordinate their activities, exploiting indirect communication

mediated by modifications of the environment in which they move.

In the second experiment, the length ratio between the two branches was set to r = 2

(Goss et al., 1989), so that the long branch was twice as long as the short one(figure

2.1(b) shows the experimental setup). In this case, in most of the trials, after some time

all the ants chose to use only the short branch (in figure 2.1(b)). As in the first

experiment, ants leave the nest to explore the environment and arrive at a decision point

where they have to choose one of the two branches. Because the two branches initially

17

appear identical to the ants, they choose randomly. Therefore, it can be expected that,

on average, half of the ants choose the short branch and the other half the Long Branch,

although stochastic oscillations may occasionally favor one branch over the other.

However, this experimental setup presents a remarkable difference with respect to the

previous one: because one branch is shorter than the other (in figure 2.1(b)), the ants

choosing the short branch are the first to reach the food and to start their return to the

nest. But then, when they must make a decision between the short and the Long Branch,

the higher level of pheromone on the short branch will bias their decision in its favor.

Therefore, pheromone starts to accumulate faster on the short branch, which will

eventually be used by all the ants because of the autocatalytic process described

previously. When compared to the experiment with the two branches of equal length,

the influence of initial random fluctuations is much reduced, and stigmergy,

autocatalysis, and differential path length are the main mechanisms at work.

Interestingly, it can be observed that, even when the Long Branch is twice as long as

the short one, not all the ants use the short branch, but a small percentage may take the

longer one. This may be interpreted as a type of ‘‘path exploration’’ [2].

Salesman Problem

TSP could be used in the ordering of genes on a chromosome (Gunnels et al. 1994),

problems in cryptanalysis, such as the discovery of a key of a simple substitution cipher

(Spillmann et al. 1993), or breaking of transportation ciphers in cryptographic system

(Matthews 1993). In addition work carried out on systems identification, specifically

those related with the induction of stochastic models, could benefit on the information

about the genetic operators.Likewise, on the topic of Bayesian networks, a problem of

evidence propagation according to Lauritzen and Spiegelhalter’s algorithm (1988), can

used in searching of the optimal order of elimination of vertexes that cause

triangularization of moral graph associated to the Bayesian network. Optimality is

defined according to the weight of the triangulated graph (Larranaga et al. 1990).

18

Another classic problem in statistics, called Cluster Analysis, which consists of

obtaining the optimal classification of a set of individuals characterized by any number

of variables. [10]

Ant System is the first ACO algorithm proposed in the literature. Initially, each ant is

randomly put on a city. During the construction of a feasible solution, ants select the

following city to be visited through a probabilistic decision rule. When an ant k states

in city i and constructs the partial solution, the probability moving to the next city j

neighboring on city i is given by following equation.

𝛼 𝛽

[𝜏𝑖𝑗 (𝑡)] [𝜂𝑖𝑗 ]

𝑘

𝑝𝑖𝑗 (𝑡) = { 𝛼

∑𝑢𝜖𝑗 [𝜏𝑖𝑗 (𝑡)] [𝜂𝑖𝑗 ]

𝛽

𝑖𝑓 𝑗𝜖𝑗𝑘 (𝑖) …………. (2.1)

𝑘

0 𝑜𝑡ℎ𝑒𝑟𝑤𝑖𝑠𝑒

where 𝜏𝑖 𝑗 is the intensity of trails between edge (i, j) and 𝜂𝑖𝑗 is the heuristic visibility

of edge (i, j), and 𝜂𝑖𝑗 =1/𝑑𝑖𝑗 . 𝑗𝑘 (i) is a set of cities which remain to be visited when the

ant is at city i. α and β are two adjustable positive parameters that control the relative

weights of the pheromone trail and of the heuristic visibility. After each ant completes

its tour, the pheromone amount on each path will be adjusted with equation (2.2).

𝑘

𝜏𝑖 𝑗 (𝑡 + 1) ← (1 − 𝜌) ∙ 𝜏𝑖 𝑗(𝑡) + ∑𝑚

𝑘=1 ∆𝜏𝑖 𝑗 (𝑡) …………. (2.2)

𝑄

∆𝜏𝑖𝑘𝑗 ={ 𝐿𝑘 if ant 𝑘 used edge (𝑖, 𝑗)in its tour…………. (2.3)

0 𝑜𝑡ℎ𝑒𝑟𝑤𝑖𝑠𝑒

19

(1- ρ) is the pheromone decay parameter (0<ρ<1) where it represents the trail

evaporation when the ant chooses a city and decide to move and𝐿𝑘 is the length of the

tour performed by ant k and m is the number of ants.[3]

The global updating rules are different;

Local updating rules which adjust the amount of the pheromone on various

paths are newly added.

Step 1: Initiation. The amount of the pheromone on each side is initiated into a tiny

constant value; allocate m ants randomly to n cities.

Step 2: In ACS, the so-called pseudorandom proportional rule is used: the probability

for an ant to move from city i to city j depends on a random variable q uniformly

distributed over [0, 1], and a predefined parameter q0.

𝛼 𝛽

arg 𝑚𝑎𝑥𝑢𝜖𝑎𝑙𝑙𝑜𝑤𝑒𝑑𝑘(𝑖) {[𝜏𝑖𝑗 (𝑡)] [𝜂𝑖𝑗 ] } 𝑖𝑓 𝑞 < 𝑞0

𝑗={ …………. (2.4)

𝑗 𝑜𝑡ℎ𝑒𝑟𝑤𝑖𝑠𝑒

obviously increases the variety of any searching, thus avoiding any premature falling

into the local optimal solution and getting bogged down.

Step 3: The local pheromone update is performed by all the ants after each construction

step. Each ant applies it only to the chosen city,

20

𝜏𝑖 𝑗 (t + 1) = (1 − ρ )𝜏𝑖 𝑗 (t ) + ρ .τ 0 …………. (2.5)

where 0< ρ<= 1 is a decay parameter, τ0=1/n.𝐿𝑛𝑛 is the initial values of the pheromone

trails, where n is the number of cities in the TSP and 𝐿𝑛𝑛 is the cost produced by the

nearest neighbor heuristic. Equation (2.5) is mainly to avoid very strong pheromone

paths to be chosen by other ants and to increase the explorative probability for other

paths. Once the edge between city i and city j has been visited by all ants, the local

updating rule makes pheromone level diminish on the edge. So, the effect of the local

updating rule is to make an already edge less desirable for a following ant.

Step 4: Computing of the optimal path. After m ants have travelled through all the

cities, compute the length of the optimal.

Step 5: Global updating of pheromone. After all the ants have travelled through all the

cities, update only the amount of the pheromone on the optimal path with equation

(2.6):

1

∆𝜏𝑖𝑗 (𝑡) = { 𝐿𝑔𝑏 , if (𝑖, 𝑗)ϵ global best tour, …………. (2.7)

0 , 𝑜𝑡ℎ𝑒𝑟𝑤𝑖𝑠𝑒

Step 6: If the designated search number is not attained, then repeat the above steps. [3]

21

2.4 Comparison of computational time of ACO with other

algorithms

five different city sets with 50 cities, the obtained result shows that ACO is better than

other type of algorithms for solving TSP like SA(Simulated Annealing), EN(elastic

net), SOM(Self-Organizing Map) and FI(Farthest Insertion). The result of average tour

length obtained from their experiment is shown below, where the best one is

highlighted:

Problem Name ACS SA EN SOM FI

City set 1 5.86 5.88 5.98 6.06 6.03

City set 2 6.05 6.01 6.03 6.25 6.28

City set 3 5.57 5.65 5.70 5.83 5.85

City set 4 5.70 5.81 5.86 5.87 5.96

City set 5 6.17 6.33 6.49 6.70 6.71

Table 1: Comparison of ACO with other algorithms

(Source: Marco Dorigo, Luca Maria Gambardella, Ant Colonies for travelling salesman

problem, 1997)

These results were averaged over 15 trials starting from different initial cities.

22

Chapter 3: System Development

3.1 Method

While implementing ACO, we used ACS (Ant Colony System) to solve the TSP

problem. ACS is the modified algorithm from AS (Ant system). In between AS and

ACS the difference is in pheromone update procedure. Though both algorithms uses

the global pheromone update trail there is the difference in procedure. In AS at first,

the evaporation procedure is done on all the city then after the update is carried out on

all the state where as in ACS, pheromone evaporation and pheromone update are done

simultaneously. Consequently ACS seems to work faster and advance one. The ACS

is mainly different from the AS in these aspects: The decision rules of the ants are

different; the global updating rules are different; and local updating rules which adjust

the amount of the pheromone on various paths are newly added.

is available, then the same graph used by the construction procedure can be used as a

construction graph, and then it is only necessary to (1) add pheromone trail variables

to the construction graph and (2) define the set of artificial ants to be used for

constructing solutions in such a way that they implement, according to a randomized

version of the construction procedure. It must be noted, however, that in order to have

an efficient implementation, often additional data structures are required, like arrays,

to represent the TSP instance and the pheromone trails, and representing artificial ants.

23

3.1.1 Digital Representation of ant

In computer science, artificial ant is the barrier of the real ant. In this work an artificial

ant is an agent which moves from city to city on a TSP graph. It chooses the city to

move to using a probabilistic function both of trail accumulated on edges and of a

heuristic value, which was chosen here to be a function of the edges length. Artificial

ants probabilistically prefer cities that are connected by edges with a lot of pheromone

trail and which are close-by. Initially, numbers of artificial ants are placed on randomly

selected cities. At each time step they move to new cities and modify the pheromone

trail on the edges used –this is termed local trail updating. When all the ants have

completed a tour the ant that made the shortest tour modifies the edges belonging to its

tour termed global trail updating by adding an amount of pheromone trail that is

inversely proportional to the tour length.

There are three ideas from natural ant behavior that we have transferred to our artificial

ant colony:

(ii) The higher rate of growth of the amount of pheromone on shorter paths, and

(iii) The trail mediated communication among ants.

Artificial ants were also given a few capabilities which do not have a natural

counterpart, but which have been observed to be well suited to the TSP application:

artificial ants can determine how far away cities are, and they are endowed with a

working memory used to memorize cities already visited (the working memory is

emptied at the beginning of each new tour, and is updated after each time step by adding

the new visited city). [11]

24

3.1.2 General technique

Tours are constructed by applying the following simple constructive procedure toeach

ant:

Choose, according to some criterion, a start city at which the ant is positioned;

Use pheromone and heuristic values to probabilistically construct a tour by

iteratively adding cities that the ant has not visited yet, until all cities have been

visited;

Go back to the initial city.

After all ants have completed their tour, they may deposit pheromone on the tours they

have followed.

Initially, each ant is put on some randomly chosen city. At each construction step, ant

k applies a probabilistic action choice rule. In particular, the probability with which ant

k, currently at city i, chooses to go to city j at the tth iteration of the algorithm is:

𝛼 𝛽

[𝜏𝑖𝑗 ] [𝜂𝑖𝑗 ]

𝑘

𝑝𝑖𝑗 ={ 𝛼

∑𝑢𝜖𝑗 [𝜏𝑖𝑗 ] [𝜂𝑖𝑗 ]

𝛽

𝑖𝑓 𝑗𝜖𝑗𝑘 (𝑖) …………. (3.1)

𝑘

0 𝑜𝑡ℎ𝑒𝑟𝑤𝑖𝑠𝑒

Where 𝜏𝑖𝑗 is the pheromone, j is the current city and 𝑗𝑘 is the set of unvisited city and

𝜂𝑖𝑗 =1/𝑑𝑖𝑗 is an a priori available heuristic value, 𝛼 and 𝛽are two parameters which

determine the relative influence of the pheromone trail and the heuristic information,

and 𝑁𝑖𝑘 is the feasible neighborhood of ant k, that is, the set of cities which ant k has

not yet visited.

25

3.1.3.1 Role of α and β

If 𝛼 = 0, the closest cities are more likely to be selected: this corresponds to a classical

stochastic greedy algorithm with multiple starting points since ants are initially

randomly distributed on the cities. If 𝛽 = 0, only pheromone amplification is at work:

this method will lead to the rapid emergence of a stagnation situation with the

corresponding generation of tours which, in general, are strongly suboptimal.

performance value of α should be 1 and β should be between 2 to 5.[2]

The pheromone trail is changed both locally and globally. Global updating is intended

to reward edges belonging to shorter tours. Once artificial ants have completed their

tours, the best ant deposits pheromone on visited edges; that is, on those edges that

belong to its tour (the other edges remain unchanged). The amount of pheromone ∆𝜏(i,

j) deposited on each visited edge (i, j) by the best ant is inversely proportional to the

length of the tour: the shorter the tour the greater the amount of pheromone deposited

on edges. This manner of depositing pheromone is intended to emulate the property of

differential pheromone trail accumulation, which in the case of real ants was due to the

interplay between the length of the path and continuity of time. The global trail

updating formula is

Global trail updating is similar to are enforcement learning scheme in which better

solutions get a higher reinforcement.

26

Local updating is intended to avoid a very strong edge being chosen by all the ants:

every time an edge is chosen by an ant its amount of pheromone is changed by applying

the local trail updating formula:

Local trail updating is also motivated by trail evaporation in real ants. In fact, the above

equation (3.2) and (3.3) dictate that an ant can either, with probability q0, exploit the

experience accumulated by the ant colony in the form of pheromone trail (pheromone

trail will tend to grow on those edges which belong to short tours, making them more

desirable) or, with probability (1-𝑞0 ), apply a biased exploration (exploration is biased

towards short and high trail edges) of new paths by choosing the city to move to

randomly, with a probability distribution that is a function of both the accumulated

pheromone trail, the heuristic function and the working memory.[12] With the update

process simultaneously the pheromone intensity will evaporate with increase in time in

both types of pheromone update process.

3.1.5 Constants

Four constants are used in ACO which are given below with their respective values:

27

For effective implementation these values should be used, but small changes can be

done for α, β and ρ.

3.2 Design

In order to carry out effective implementation, different data structures are required,

like arrays, which are used to represent the problem and data representation like TSP

instance and the pheromone trails, and representing artificial ants.

a) City Representation

As the points or cities are selected by the user, those selected points are identified by

their pixel value which are stored in x_cord[] and y_cord[] for x-coordinate and y-

coordinate respectively. For each selected city a unique string is given to it through

city[] array. There are two 2-dimensional arrays cityVisited[,], used for storing cities

visited by each ant in a round and cityUnvisited[,], for storing remaining cities to be

visited by each ant in a round.

For each connection between cities (i, j), a number τij corresponding to the pheromone

trail associated between city i and j has to be adjusted. This pheromone is stored in the

array pheromone[,]. For symmetric TSPs this requires storing n(n-1)/2 distinct

pheromone values, because we assume that τij = τji, for all i and j excluding i=j, for which

its value is set to 0.

28

3.2.1.2 Ant representation

Ant in ACO is represented by the artificial ant. Artificial ant holds the foraging

behavior of the real ant. Here also in this program, artificial ants are the agent that visits

around the graph. While visiting initially numbers of the ants are localized in different

city and are allowed to visit around the graph. It also deposits an amount of pheromone

Δτ on the arcs it has traversed. For this, an ant must be able to:

Store the partial solution it has constructed so far, which is done with cityVisited[,]

array where each ant stores its visited city information.

Determine the feasible neighborhood at each city, which is done through scanning

cityUnvisited[,] array from each current city, which is updated while the ant builds

the solutions.

Compute and store the objective function value of the solutions an ant generates,

by storing the length of tour traversed by ant in the array tourLength[,].

From this array of ant, a single ant travels round all the cities completing the Hamilton

circuit. Likewise, the entire ants travel and complete a Hamilton circuit in each round.

The travelling speed of every ant is uniform only the distance they are travelling

through these cities varies the time to complete one circuit. While travelling those ants

spread the pheromone as according to the pheromone update rule and simultaneously

through this pheromone the best and optimal circuit is determined.

29

public const int AntNumber //number of ants

CityNumber]; //pheromone matrix

String[AntNumber, CityNumber]; //matrix representing city already

visited by respective ants

String[AntNumber, CityNumber]; //matrix representing city that are

going to be visited by respective ants

CityNumber]; //matrix of probability of any ant going to any cities

CityNumber]; //distance matrix

//length of tour of each ant

specific round

String[CityNumber]; //best tour cities

String[CityNumber]; //overall best tour cities

coordinate matrix

30

public static int[] y_cord = new int[200]; //Y-

coordinate matrix

time for total execution

During implementation of ACO, the major task that are to be done are data structure

and parameter initialization, solution construction, management of pheromone trails

and maintenance of execution of code like termination of program etc.

Step 3: on accordance to number of ant assigned to the cities, ant from those initialize

visiting all around calculating the distance of those cities from one to another.

Step 4: after calculating the distance the best one will be choosen and pheromone is

updated in all edges of that route.

Step 5: if condition approval of visiting maximum round then draw the best path and

print their length and time taken otherwise go to step 6.

Step 6: check whether all ants had tour or not. If yes then goto step 7 else goto step 11.

31

Step 10: pheromone update is carried out on the best path and goto step 5.

Step 12: if all cities are visited i.e. unvisited cities= NULL then goto step 5 else

Step 14: city is removed from unvisited list and goto step 12.

32

The flowchart for the algorithm is given below:

33

The high level view of ACO Algorithm for solving TSP is given below:

Procedure ACOforTSP

InitializeData

while(not terminate)do

ConstructSolutions and UpdateStatistics

UpdatePheromoneTrails

End-while

End-procedure

Each task from above algorithm are described below.

The instance, provided by the user has to be read and cities are initialized.

the distance matrix between each points has to be computed; whose pseudo

code is given below:

Calculate distance between two points (x1, y1) and

Return distance

End of the function

the pheromone matrix have to be initialized for each city edges with a value of

0.01 for each city(i, j) for all i and j except i = j;

the ants have to be initialized;

the algorithm’s parameters like cityUnvisited[,] must be initialized;

34

Some variables that keep track of statistical information, such as the used CPU

time, the number of iterations, or the best solution found so far, have to be

initialized.

The data initialization is proceeded with instantiation of a new object of class start

ACO, through the use of constructor. A possible organization of the tasks into several

data initialization procedures is indicated in given pseudo code.

1 Calculate distance between each coordinates by calling

function distance_calc

2 Initialize the pheromone for each city edges

3 Initialize the cities unvisited

4 Call the mainproc function

End of the function

For each ant, a tour is accomplished in a round. Among all the tour created by ants, an

optimal tour is selected which is compared with best tour length of all previous rounds.

This optimal tour is assigned to best tour if it is better than previous best tour. For the

best tour, pheromone is updated by calling its function. The tour construction is

accomplished by the function mainproc, whose pseudo code is shown below.

1 Start stopwatch

2 for k = 0 to rounddo

3 Update the progress bar in MapForm

4 Get a new_index as random number

5 Obtain initial city from new_index

6 for antindex = 0 to AntNumberdo

35

7 Initialize the unvisited cities

8 Initialize m as 0

9 Store initial city in cityVisited matrix as

cityVisited[antIndex, m] = initial

10 for j = 0 to countdo

11 Calculate index = Array.IndexOf(city,

initial)

12 Increase value of m by 1

13 Remove the current city from

cityUnvisited matrix as cityUnvisited[antIndex,

index] = "\0"

14 for i = 0 to countdo

15 Initialize probability as

probs[antIndex, i] = 0.0

16 End of for loop

17 Call CalcProbability function with

parameters initial and ants[antIndex] and store the

returned value in selectedCity

18 Store the selectedCity in cityVisited

matrix as cityVisited[antIndex, m] = selectedCity

19 Initalize the initial city as

selectedCity

20 End of for loop

21 Call CalcLength to calculate the tour length

of corresponding ant as CalcLength(ants[antIndex])

22 Get a new_index from random number

23 Obtain initial city from new_index

24 Initialize optimalTourLength = tourLength[0]

25 if bestTourInitialize = 1

26 Assign bestTourLength =

optimalTourLength

36

27 for i = 0 to countdo

28 Assign bestTourCity[i] = cityVisited[0,

i]

29 End of for loop

30 Assign bestTourInitialize = 0

31 End of for loop

32 Initialize sum as 0.0

33 for i = 0 to AntNumberdo

34 Calculate sum = sum +1 / tourLength[i]

35 if optimalTourLength > tourLength[i]

36 Assign optimalTourLength = tourLength[i]

37 Initialize flag as corresponding ant

index i

38 End if

39 End of for loop

40 if optimalTourLength <= bestTourLength

41 Assign bestTourLength = optimalTourLength;

42 for i = 0 to countdo

43 Assign bestTourCity[i] =

cityVisited[flag, i]

44 Call function UpdatePheromone(ants[flag],

sum);

45 End of for loop

46 End if

47 End of for loop

48 Stop stopwatch

49 Assign total time taken to elapsedTime

End of the function

37

The solution construction requires the following phases.

1. First, in line 1, the stopwatch is started in order to measure the time taken for

calculation.

2. For each round, progress bar is updated and a new random index is obtained.

3. The ants’ memory must be emptied. This is done in lines 6 and 7 of above

function by placing all cities into cityUnvisited[,], marking all cities to be

visited by each ant.

4. Remove the current city i.e. city with obtained index from cityUnvisited[,] and

place it into cityVisited[,] matrix which is accomplished in line 13.

5. Initialize the probability matrix as a value of 0.0 as in line 14 and 15.

6. Call calcProbability function by passing the index of current city, from which

city with higher probability is returned. Store this city in cityVisited[,] matrix

and make this an initial one, as in line 17 to 19.

7. After ant construct the path by completing tour, obtain tour length of

corresponding ant by calling function calcLength, as in line 21.

8. Assign optimalTourLength as tour length of first ant and compare it with all

other remaining ants’ tour and obtain the optimal tour length in the current

round. If this optimalTourLength is better than bestTourLength, assign

optimalTourLength to bestTourLength and update pheromone in the path

having bestTourLength, which is implemented in line 24 to 45.

9. At last stop stopwatch and assign its value to elapsedTime.

In each tour of an ant, the probability of selecting an unvisited city from a current city

is calculated. The city having higher probability is selected as a city to be visited next,

which is calculated using the given pseudo code.

38

Function CalcProbability (String initial, int ant)

1 Initialize sum = 0.0;

2 cityIndex = Array.IndexOf(city, initial);

3 antIndex = Array.IndexOf(ants, ant);

4 for i = 0 to countdo

5 if (city[i] == initial)

6 for j = 0 to countdo

7 if (city[j] == cityUnvisited[antIndex,

j] && city[j] != initial)

8 Calculate sum = sum +

(Math.Pow(pheromone[cityIndex, j], alpha) * Math.Pow((1.0

/ distance[cityIndex, j]), beta));

9 End of for loop

10 End of for loop

11 For i = 0 to countdo

12 if (city[i] == cityUnvisited[antIndex, i])

13 Calculate probability as probs[antIndex, i] =

(Math.Pow(pheromone[cityIndex, i], alpha) * Math.Pow((1.0

/ distance[cityIndex, i]), beta));

14 Else probs[antIndex, i] = 0.0;

15 End of for loop

16 Calculate temporary probability prob as prob =

p_r.NextDouble() * sum;

17 Initialize j_counter as 0

18 Iniitalize p as probability of ant as p = probs[antIndex,

j_counter];

19 While p < probdo

20 Increase j_counter by 1

21 Calculate p as p = p + probs[antIndex, j_counter]

22 End of while loop

39

23 Initialize randomDecision as j_counter, maxHeuristic as -

1 and maxHeuristicIdx as -1

24 For j = 0 to countdo

25 Initialize temp as probs[antIndex, j]

26 If maxHeuristic < temp and city[j] ==

cityUnvisited[antIndex, j]

27 Assign maxHeuristic as temp

28 Assign maxHeuristicIdx as j

29 End if

30 End of for loop

31 If p_r.NextDouble() < Q0

32 Assign selectedcity as cityUnvisited[antIndex,

maxHeuristicIdx];

33 Assign cityUnvisited[antIndex, maxHeuristicIdx] =

"\0";

34 End if

35 Else

36 Assign selectedcity as cityUnvisited[antIndex,

randomDecision];

37 Assign cityUnvisited[antIndex, randomDecision] =

"\0";

38 End if

39 Return Selectedcity

End of the function

40

3.2.2.4 Tour Length Calculation

For each ant after their complete tour traversal, length of their tour is calculated. This

is done by using a function calcLength, whose pseudo code is given below:

1 Initialize antIndex = Array.IndexOf(ants, ant);

2 Initialize tourLength[antIndex] = 0.0;

3 For a = 0 to countdo

4 Assign

index1=Array.IndexOf(city,cityVisited[antIndex,a]);

5 Assign index2 = Array.IndexOf(city,

cityVisited[antIndex, (a + 1) % count]);

6 Calculate tourLength[antIndex] =

tourLength[antIndex] + distance[index1,index2];

7 End of for loop

End of the function

As the algorithm we choose to implement is ACS, global best ant is allowed to add the

pheromone after each iteration. The equation used to update the pheromone is given

below in equation (3.4).

It is important to note that the trail update only applies to the arcs of the global-best

tour, not to all the arcs. The parameter 𝜌 again represents the pheromone evaporation.

Here only the global best solution receives feedback. Initially, also using the iteration

best solution was considered for the pheromone update. Although for smaller TSP

instances the difference in solution quality between using the global-best solution or

41

the iteration-best solution is minimal, for larger instances the use of the global-best tour

gives by far better results.

pheromone update procedures: pheromone evaporation and pheromone deposit. The

first one, Evaporate, decreases the value of the pheromone trails on all the arcs (i, j) by

a constant factor ρ. The second one, pheromonedeposit, adds pheromone to the arcs

belonging to the tours constructed by the ants. Note that in both procedures are taken

to guarantee that the pheromone trail matrix is kept symmetric, because of the

symmetric TSP instances.

1 initialize antIndex = Array.IndexOf(ants, ant);

2 Calculate temp = 1 / bestTourLength;

3 for i = 0 to countdo

4 Calculate index1 =

Array.IndexOf(city,cityVisited[antIndex,i]);

5 Calculate index2 = Array.IndexOf(city,

cityVisited[antIndex, (i + 1) % count]);

6 Calculate pheromone[index1, index2] = (1-rho) *

pheromone[index1, index2] + Q * sum;

7 Assign pheromone[index2, index1] =

pheromone[index1, index2];

8 End of for loop

End of the function

42

3.2.2.6 Program Termination

The program stops when a maximum number of tour constructions or a maximum

number of algorithm iterations has been reached. After its termination, it shows final

graph showing the result of optimal path along with its length and time of execution.

43

3.3 Development

3.3.1 Program Structure

The program being developed consists of a class ‘ClassACO’ and three different

windows forms: FormMap, FormDisplay and FormViewMap. ClassACO defines

different functions like mainproc for creating solution and updating statistics,

calcProbability for calculating probability, calcLength for calculating length of tour of

each ant and UpdatePheromone for global updating pheromone for pheromone deposit

and evaporation.

FormMap is a startup from for city initialization, which intakes points as a reference of

the cities through user either by clicking on the map browsed by user or making random

points on the white picture box. FormViewMap displays the selected points along with

all the edges connecting those points. The parameters for the program like rounds to

perform, number of ants, value of alpha, beta and rho can also be provided through the

form. If those values are not changed, then default values are provided. After a round

of operations, the graph with final result showing optimal path is displayed in

FormDisplay form. This graph can be saved as a picture format in the directory of

computer.

44

The flow diagram of the program is displayed below:

45

3.3.2 Interface of program

The snapshots of our program is given below:

a. This is the startup form, where user can enter points in the white picture box

randomly or can browse a map of formats like JPEG, BMP etc. from a directory

and select desired cities from that map. Values of round, ants, alpha, beta and

rho can be entered.

46

b. This snapshot shows when user has selected a set of cities. User can also change

the value of rounds, ants, alpha, beta and rho.

47

c. After calculation, result id shown in the graph, displaying the optimal path with

dark red color, along with time taken and length.

3.4 Testing

During the designing process, this project has so many bugs which were debugged one

by one analyzing the problem occurred on each steps. This project has gone through

following testing procedure.

Separately each and every functional module is tested and analyzed the result of that

module.

48

3.4.2 Integration testing

While integrating all separate modules as one, errors that were detected were analyzed

and debugged.

After all the system has been prepared this system has been tested to identify the

optimal path of the outcome where we tested the system with known distance valued

graph and finally got the outcome as expected.

49

3.5 Validation

In order to validate our ACO and to know the optimal path assurance, we provided a

graph of a pentagon and pass it to the program by selecting five nodes. As our program

displayed result showing the pentagon, so we can validate that our program is executing

correctly, which is shown below:

As our final result was a pentagon, so we are conform that our system is right.For the

other complex graph, the only way to know whether the path is optimal or not is by

taking the input from the map with distance by this way finally we can calculate the

optimal path doing manual calculation too. This project has been analyzed by this way

too so the result is assured as optimal one. That means this project can solve TSP

problem without any doubt.

50

Chapter 4: Epilogue

4.1 Result

After the program is started, user can either enter the points randomly at white picture

box or can browse a map and select cities, for which shortest path has to be found. As

given in figure below, user can browse a map and select cities and adjust values of

rounds, ants, alpha, beta and rho.

51

After clicking calculate button, the final output is displayed, which shows the optimal

path highlighted in red color along with path, length and time taken for total round

execution, which as shown in figure below.

The red line indicates the optimal TSP path completing the Hamilton circuit. The

information part has optimal path and length with time taken to complete the round in

second.

This is the result of this project which gives the optimal path with length calculation

and time taken to visit around the graph.

52

4.2 Result Analysis

The result of our program was executed and analyzed for a number of times with

varying inputs. We performed test for computational capability of our program by

giving different number of points and calculating and observing the time taken to run.

We provided 5 to 50 cities, with 1000 rounds, 10 ants and value of alpha was 1, beta

was 2 and rho was 0.5. For each set of cities, this calculation was done for ten times

and the time taken to solve the problem was averaged. The averaged computational

time for solving and finding shortest path for different cities is given below in table:

5 0.18084432

10 0.45567678

15 0.84175982

20 1.3452476

25 1.9872501

30 2.6476588

35 3.49762444

40 4.46278875

45 5.4586210

50 6.63181736

Table 3: Result showing computational time

processor of Intel core i5-2410M CPU of 2.30GHz, physical memory of 4GB and

graphical memory of 512MB. The experiments were performed for 10 times for each

city sets, whose computational time were then averaged.

53

This result is depicted in graph as below in figure 4-3. This graph shows that the

computational time of the algorithm increases with the increase in number of cities.

Time

7

5

Time (seconds)

0

0 10 20 30 40 50 60

Number of cities

54

4.3 Critical Analysis

We have seen that in real ant colonies the emergence of high-level patterns like shortest

paths is only possible through the interaction of a large number of individuals. It is

interesting that experimental results show that the same is true to a large extent for

ACO: the use of a colony of ants is important to exploit the differential path length

effect and to increase the robustness of the algorithm and reduce its dependence on

parameter settings. As we have seen, a colony size larger than one is necessary to solve

even simple problems like the double bridge.

In general, we noticed that as problems become more complex, the parameter settings

of ACO become increasingly important to obtain convergence to the optimal solution.

In particular, the experimental results presented above support the following

conclusions:

(1) The differential path length effect, although important, is not enough to allow the

effective solution of large optimization problems;

(2) Pheromone updates based on solution quality are important for fast convergence

(3) Large values for parameter a lead to a strong emphasis of initial, random

fluctuations and to bad algorithm behavior;

(4) The larger the number of ants, the better the convergence behavior of the algorithm,

although this comes at the cost of longer simulation times;

(5) Pheromone evaporation is important when trying to solve more complex problems.

decisions will be made both to define the ACO metaheuristic and to apply it to a

multitude of different discrete optimization problems.

Artificial ants iteratively sample tours through a loop that includes a tour construction

biased by the artificial pheromone trails and the heuristic information. The main

55

mechanism at work in ACO algorithms that triggers the discovery of good tours is the

positive feedback given through the pheromone update by the ants: the shorter the ant’s

tour, the higher the amount of pheromone the ant deposits on the arcs of its tour. This

in turn leads to the fact that these arcs have a higher probability of being selected in the

subsequent iterations of the algorithm. The emergence of arcs with high pheromone

values is further reinforced by the pheromone trail evaporation that avoids an unlimited

accumulation of pheromones and quickly decreases the pheromone level on arcs that

only very rarely, or never, receive additional pheromone.

The first theoretical aspect of ACO that we consider is the convergence problem: Does

the algorithm considered eventually find the optimal solution? This is an interesting

question, because ACO algorithms are stochastic search procedures in which the bias

due to the pheromone trails could prevent them from ever reaching the optimum. It is

important to note that, when considering a stochastic optimization algorithm, there are

at least two possible types of convergence: convergence in value and convergence in

solution. Informally, and making the hypothesis that in case of problems with more

than one optimal solution we are interested in convergence toward any of them, when

studying convergence in value we are interested in evaluating the probability that the

algorithm will generate an optimal solution at least once. On the contrary, when

studying convergence in solution we are interested in evaluating the probability that

the algorithm reaches a state which keeps generating the same optimal solution. Note,

however, that although in general convergence in solution is a stronger and more

desirable result to prove than convergence in value, in optimization we are interested

in finding the optimal solution once (after it has been found the problem is solved and

the algorithm can be stopped), so that convergence in value is all that we need.

ACO performs better against other global optimization techniques, retains memory of

entire colony instead of previous generation only, less affected by poor initial solutions

and can be used in dynamic applications and has been applied to a wide variety of

applications. It is also a good choice for constrained discrete problems. Theoretical

56

analysis is difficult; due to sequence of random decision, research is experimental

rather than theoretical, convergence is guaranteed, but time to convergence is uncertain.

In NP-hard problems, need high-quality solutions quickly focus on quality of solutions

and in dynamic network routing problems, need solutions for changing conditions.

We are more interested in finding an optimal solution at least once than in generating

it over and over again, let us have a closer look at the role played by τmin (minimum

pheromone value) and τmax (maximum pheromone value). We need to consider the

worst-case situation in which the bias in the solution construction introduced by the

pheromone trails is counterproductive and leads to suboptimal solutions; that is, we

have to assume that the pheromone trail level associated with the connection an ant

needs to pass for constructing an optimal solution is τmin, while on the other connections

it is much higher—in the worst case corresponding to τmax. In practice, however, as

shown by the results of many published experimental works (Dorigo & Di Caro,1999b;

Dorigo et al., 1999; Dorigo & Stu¨ tzle, 2002), normally this does not happen, and the

bias introduced by the pheromone trails does indeed help to speed up convergence to

an optimal solution.

As with other project, this project also has some drawbacks like stagnation and pre-

convergence problem. To reduce such drawbacks further research and optimization in

coding requires. In spite of those problems also, this application can give optimal tour

by which we can generalize our other real world problems. Beside those this project

lacks some modern technology like dynamic optimization modification on ACS

algorithm, parallel optimization algorithms. Such optimization’s abstract concept can

be implement in future to make this project works more optimizing the paths. In aspect

of hardware too CPU and GPU can be enhance together to make the calculation more

efficient. Regarding the development of this project till now, this project is more useful

in generalizing the problem in vehicle routing, road construction, network routing, etc.

that has limit number of cities and nodes. Its working mechanism for limited cities is

best part of this project. This project can gives optimal path for the limit number of

57

cities. Using the more number of ants, traveling the path also can help in generating the

more optimal path.

Moreover, this project only works for straight path in between two nodes like:

So the construction on the path also can be taken as its drawback regarding the real

world scenario. In real word it may be impossible to have straight path in between the

cities so our project also require to work on curve path. Beside those, analyzing the

above figure, the red path gives the optimal path. So while network routing this

representation can give the optimal path for routing purpose and for water distribution

purpose without leaving any cities, water can be flowed through optimal path as

represented in above graph. As similar to, while vehicle routing the optimal path can

save both time and cost.

58

4.4 Limitation

It still has some drawbacks such as stagnation behavior, and premature convergence

problem of the basic ACO algorithm on TSP. Those problems will be more obvious

when the considered problems size increases. The system is likely to fall into the local

optimal solution and becomes stagnation when it has large scale.

Our future plan is to overlap CPU and GPU computation by running suitable operations

on both processors in order to maximize the use of the computational power of the

system on which it is running. And another goal for us to work toward in the future is

to add more implementations of ACO to give the user more flexibility.

4.6 Conclusion

The key to the application of ACO to a new problem is to identify an appropriate

representation for the problem that is to be represented as a graph searched by many

artificial ants, and an appropriate heuristic that defines the distance between any two

nodes of the graph. Then the probabilistic interaction among the artificial ants mediated

by the pheromone trail deposited on the graph edges will generate good, and often

optimal, problem solutions. The ACO is an optimization algorithm based on self-

organization effects of individual agents and it was particularly suited for Travelling

Salesman Problem, since one of the optimization constraints depends on how the

solution is constructed.

59

References

Traveling Salesman Problems,Siemens AG, Corporate Technology Information and

Communications, CT IC 481730 Munich - Germany

MIT Press, Cambridge, Massachusetts, London, England, 2004, pp. i-ii.

[3]Zar Chi Su SuHlaing, May Aye Khine, An Ant Colony Optimization Algorithm for

Solving Traveling Salesman Problem,University of Computer Studies, Yangon

[4] Grace Murray Hopper and Shimon Peres, NP-Hard Problems, 2009, pp. 2

[5] Ivan Brezina Jr. ZuzanaČičková, Solving the Travelling Salesman Problem Using

the Ant Colony Optimization, University of Economics in Bratislava, 2011, pp. intro.

New York University, May 20, 2013.

[7] Peter Ahrens, Dustin Tauxe, ExcellAnts, Los Alamos High School, April 4, 2012,

pp. 4

Optimization, Springer-Verlag, Berlin Heidelberg, 2004, pp.21

KuangYeowPhang, HsinYeowSeah and Chan Lim Tan, Ant Colony Optimization for

Design of Water Distribution Systems, Univ. of Adelaide, Adelaide, S.A. 5005,

Australia, May/June 2003, pp. 200-201

60

[10] P. Larrañaga, C.M.H. Kuijpers, R.H. Murga, I. Inza, S. Dizdarevic, Genetic

Algorithms for the Travelling Salesman Problem: A Review of Representations and

Operators, Kluwer Academic Publishers, 1999-04-01

3Université Libre de Bruxelles Belgium

[12] Marco Dorigo a,*, Luca Maria Gambardella, Ant colonies for the travelling

salesman problem, a IRIDIA, Uni6ersite´ Libre de Bruxelles, A6enue Franklin

Roose6elt 50, CP 194 :6, 1050 Bruxelles, Belgiumb IDSIA, Corso El6ezia 36, 6900

Lugano, Switzerland accepted 24 October 1996

61

Bibliography

IRIDIAUniversit´e Libre de Bruxelles, 50 Avenue F. Roosevelt, B-1050 Brussels,

Belgium, 1999

[2] S. Lin and B. W. Kernighan, An Effective Heuristic Algorithm for the Traveling-

Salesman Problem,

[3] Peter Ahrens,Dustin Tauxe, ExcellAnts, Los Alamos High School, New Mexico,

April 4, 2012

[4] Peter Ahrens, Dustin Tauxe, Stephanie Djidjev, BrilliAnts, Los Alamos High

School, New Mexico, April 6, 2012

IRIDIAUniversit´e Libre de Bruxelles, 50 Avenue F. Roosevelt, B-1050 Brussels,

Belgium, mdorigo@ulb.ac.be, 2001

[6] Ozgur Baskan *, Soner Haldenbilen, Huseyin Ceylan, Halim Ceylan, A new

solution algorithm for improving performance of ant colony optimization,Department

of Civil Engineering, Engineering Faculty, Pamukkale University, Denizli 20017,

Turkey, 2009

[7] Wang Cuiru, Li Yang, The Application of the Ant Colony Pheromones in Intelligent

Learning, Department of Computer Science, Southwestern North China Electric Power

University, Baoding Hebei 071003, liyang20032006@126.com, 2009

Ant Colony Optimization algorithmfor shortest paths in directed acyclic graphs,

62

Department of Computer Engineering, Kasetsart University, Bangkok 10900,

Thailand, 2007

[9] Marco Dorigo, Luca Maria Gambardella, Solving Symmetric and Asymmetric TSPs

by Ant Colonies, IRIDIAUniversit´e Libre de Bruxelles, 50 Avenue F. Roosevelt, B-

1050 Brussels, Belgium, 1996

DiscreteOptimization, Massachusetts Institute of Technology, 1999

[11] Marco Dorigoa, Christian Blum, Ant colony optimization theory: A survey,

Theoretical Computer Science, 2005

Overview, Scienze dell’Informazione, University of Bologna, Italy

[13] Vittorio Maniezzo, Luca Maria Gambardella, Fabio de Luigi, Ant Colony

Optimization

[14] Marco Dorigo, Mauro Birattari and Thomas Stutzle, Ant Colony Optimization:

Artificial ants as a computational Intelligent Technique, IEEE Computational

Intelligence Magazine, November 2006

[15] Mark Zlochin, Mauro Birattari, Nicolas Meuleau, Marco Dorigo, Model-Based

Search for Combinatorial Optimization: A Critical Survey, Annals of Operations

Research, Kluwer Academic Publishers, 2004

63

Appendices

A. Time Schedule

TASK NUMBER

Planned Actual

Planned Date Actual Date

OBJECTIVE

LINK TO

Duration Duration

TASK

HOURS

HOURS

DAYS

DAYS

START DATE FINISH DATE START DATE FINISH DATE

Ant Colony Optimization for Traveling Salesman Problem 5/8/2013 9/14/2013 5/8/2013 10/4/2013 111 467 130 497

1 Preliminary Work 5/8/2013 5/29/2013 5/8/2013 5/28/2013 18 64 18 64

1.1 1 Planning for the project 5/8/2013 5/9/2013 5/8/2013 5/9/2013 2 6 2 6

1.2 1 Analysis on the topics 5/10/2013 5/13/2013 5/10/2013 5/13/2013 2 6 2 6

1.3 Discussion with the supervisor 5/12/2013 5/12/2013 5/12/2013 5/12/2013 1 1 1 1

1.4 2,3 Background reading from different research papers 5/13/2013 5/15/2013 5/13/2013 5/15/2013 3 11 3 11

1.5 1 Understanding the overview of the project and analyzing the contents 5/16/2013 5/19/2013 5/16/2013 5/19/2013 3 8 3 8

1.6 7 Preparation of project proposal 5/16/2013 5/26/2013 5/16/2013 5/26/2013 9 13 9 13

1.7 7 Preparing the Gantt Chart and Project Schedule 5/21/2013 5/26/2013 5/21/2013 5/26/2013 5 15 5 15

1.8 7 Collecting and producing initial list of references of the project 5/27/2013 5/27/2013 5/27/2013 5/27/2013 1 2 1 2

1.9 Approval from Supervisor 5/28/2013 5/28/2013 5/28/2013 5/28/2013 1 1 1 1

1.1 7 First Review 5/28/2013 5/28/2013 5/28/2013 5/28/2013 1 1 1 1

1.11 Milestone 5/29/2013 5/29/2013 5/29/2013 5/29/2013

2 Research Work 5/29/2013 6/23/2013 5/29/2013 6/23/2013 21 72 21 72

2.1 2 Research on ant behavior 5/29/2013 5/31/2013 5/29/2013 5/31/2013 3 5 3 5

2.2 2,4 Research on ant colony algorithm and its optimization 6/2/2013 6/5/2013 6/2/2013 6/5/2013 4 14 4 14

2.3 Meeting with the supervisor 6/5/2013 6/5/2013 6/5/2013 6/5/2013 1 1 1 1

2.4 2,4 Research on applications of ant colony optimization algorithm 6/6/2013 6/7/2013 6/6/2013 6/7/2013 2 8 2 8

2.5 3,5 Research on traveling salesman problem and NP hard problems 6/9/2013 6/11/2013 6/9/2013 6/11/2013 3 10 3 10

2.6 3,5 Research on ant colony optimization for traveling salesman problem 6/12/2013 6/20/2013 6/12/2013 6/20/2013 8 32 8 32

2.7 Meeting with the supervisor 6/21/2013 6/21/2013 6/21/2013 6/21/2013 1 1 1 1

2.8 Second Review 6/21/2013 6/21/2013 6/21/2013 6/21/2013 1 1 1 1

2.9 Milestone 6/23/2013 6/23/2013 6/23/2013 6/23/2013

3 Development Phase 6/23/2013 8/21/2013 6/23/2013 8/23/2013 52 190 54 204

3.1 6 Study of Visual Studio and C# 6/23/2013 6/28/2013 6/23/2013 6/28/2013 6 22 6 22

3.2 6 Application Design 6/30/2013 7/4/2013 6/30/2013 7/8/2013 5 20 8 24

3.3 Meeting with Supervisor 7/5/2013 7/5/2013 7/12/2013 7/12/2013 1 1 1 1

3.4 6 Application Development, Unit and Module Test 7/5/2013 8/8/2013 7/7/2013 8/8/2013 29 120 29 120

3.5 Meeting with the Supervisor 7/19/2013 7/19/2013 7/19/2013 7/19/2013 1 1 1 1

3.6 6 Application Testing, validating and verifying 8/9/2013 8/2/2013 8/9/2013 8/22/2013 10 25 12 35

3.7 Meeting with Supervisor 8/21/2013 8/21/2013 8/23/2013 8/23/2013 1 1 1 1

3.8 Milestone 8/21/2013 8/21/2013 8/23/2013 8/23/2013

4 Dissertation 6/10/2013 9/9/2013 6/10/2013 10/1/2013 79 126 100 147

4.1 7 Report Writing 6/10/2013 8/25/2013 6/10/2013 9/9/2013 66 90 79 110

4.2 7 Report evaluation and conclusion 8/26/2013 8/29/2013 9/24/2013 9/26/2013 4 15 3 15

4.3 7 Proof reading 8/30/2013 9/2/2013 9/25/2013 10/1/2013 3 8 6 15

4.4 7 Submission of draft copy Report 9/3/2013 9/3/2013 10/2/2013 10/2/2013 1 1 1 1

4.5 7 Corrections for final draft copy 9/4/2013 9/8/2013 10/3/2013 10/3/2013 4 12 1 6

4.6 Milestone 9/9/2013 9/9/2013 10/3/2013 10/3/2013

5 Final Phase 9/9/2013 9/14/2013 10/4/2013 10/4/2013 5 15 2 10

5.1 7 Final Documentation Printing and Binding 9/9/2013 9/13/2013 10/4/2013 10/6/2013 5 15 2 10

5.2 Milestone 9/15/2013 9/15/2013 10/6/2013 10/6/2013

64

B. Gantt Chart

65

C. Source Code

a. Variables used

city[], ants[], distance[][], CityNumber, AntNumber, Round,

cityVisited[][], cityUnvisited[][], probs[][]

bestTourCity[],

b. Constants Used:

alpha=1, beta=3, rho=0.5, Q=2.0

public double distance_calc(int x1,int y1,int x2,int y2)

{

double dist;

double temporary=Math.Pow((x2 - x1), 2) +

Math.Pow((y2 - y1), 2);

dist = Math.Sqrt(temporary);

return (dist);

}

d. To initialize the distance in array

for (int i = 0, counter = count; i < count; i++, counter

{

for (int k = 0, j = i; k < counter; k++, j++)

{

if (i == j)

{

distance[i, j] = 0.0;

continue;

}

distance[i, j] =

(distance_calc(x_cord[i],y_cord[i],x_cord[j],y_cord[j]));

totaldiatance += distance[i,j];

distance[j, i] = distance[i, j];

}

}

66

e. To initialize the pheromones in array

for (int i = 0; i < count; i++)

{

for (int j = 0; j < count; j++)

{

if (i != j)

pheromone[i, j] = 0.01;

else if (i == j)

pheromone[i, j] = 0.00;

}

}

f. To initialize unvisited cities:

public void unvisit_initialization()

{

for (int ant = 0; ant < AntNumber; ant++)

{

for (int i = 0; i < count; i++)

{

cityUnvisited[ant,i] = city[i];

}

}

}

g. Program Function Code:

public void mainproc(FormMap object_form)

{

stopWatch.Reset();

elapsedTime=stopwatch.elapsed;

stopWatch.Start();

for (int k = 1; k <= Round; k++) //how many round

{

Random rand = new Random();

int new_index = rand.Next();

new_index = new_index % count;

String initial = city[new_index];

for (int antIndex = 0; antIndex < AntNumber; antIndex++)

//ant loop

{

unvisit_initialization(); //initialize the

unvisited cities.

int m = 0;

cityVisited[antIndex, m] = initial; //store initial

city as first visited city for ant.

67

for (int j = 0; j < count - 1; j++)

{

int index = Array.IndexOf(city, initial);

m++;

cityUnvisited[antIndex, index] = "\0";

for (int i = 0; i < count; i++)

{

probs[antIndex, i] = 0.0;

}

String selectedCity = CalcProbability(initial,

ants[antIndex]);

cityVisited[antIndex, m] = selectedCity;

initial = selectedCity;

}

CalcLength(ants[antIndex]);

initial = city[new_index];

}

tourlength of ant 0

length and best tour city for 1 time only.

{

bestTourLength = optimalTourLength;

for (int i = 0; i < count; i++)

{

bestTourCity[i] = cityVisited[0, i];

//initialize visited city of ant 0 as best tour city

}

bestTourInitialize = 0;

}

int flag = 0;

double sum = 0.0;

for (int i = 0; i < AntNumber; i++) //Calculate

optimal tour.

{

sum += 1 / tourLength[i];

if (optimalTourLength > tourLength[i])

{

optimalTourLength = tourLength[i];

flag = i;

}

68

}

{

bestTourLength = optimalTourLength;

for (int i = 0; i < count; i++)

{

bestTourCity[i] = cityVisited[flag, i];

//initialize optimal city as best tour city

}

UpdatePheromone(ants[flag], sum);

}

}

stopWatch.Stop();

elapsedTime = stopWatch.Elapsed;

}

public String CalcProbability(String initial, int ant)

{

double sum = 0.0;

int cityIndex = Array.IndexOf(city, initial);

int antIndex = Array.IndexOf(ants, ant);

for (int i = 0; i < count; i++)

{

if (city[i] == initial)

{

for (int j = 0; j < count; j++)

{

if (city[j] == cityUnvisited[antIndex, j] &&

city[j] != initial)

{

sum += (Math.Pow(pheromone[cityIndex, j], alpha)

* Math.Pow((1.0 / distance[cityIndex, j]), beta));

}

}

}

}

{

if (city[i] == cityUnvisited[antIndex, i])

69

probs[antIndex, i] = (Math.Pow(pheromone[cityIndex,

i], alpha) * Math.Pow((1.0 / distance[cityIndex, i]), beta));

else

probs[antIndex, i] = 0.0;

}

double prob = p_r.NextDouble() * sum;

int j_counter = 0;

double p = probs[antIndex, j_counter];

{

j_counter++;

p += probs[antIndex, j_counter];

}

int randomDecision = j_counter;

double maxHeuristic = -1;

int maxHeuristicIdx = -1;

for (int j = 0; j < count; j++)

{

double temp = probs[antIndex, j];

if (maxHeuristic < temp && city[j] ==

cityUnvisited[antIndex, j])

{

maxHeuristic = temp;

maxHeuristicIdx = j;

}

}

String selectedcity;

if (p_r.NextDouble() < Q0)

{

selectedcity = cityUnvisited[antIndex, maxHeuristicIdx];

cityUnvisited[antIndex, maxHeuristicIdx] = "\0";

}

else

{

selectedcity = cityUnvisited[antIndex, randomDecision];

cityUnvisited[antIndex, randomDecision] = "\0";

}

return (selectedcity);

}

70

i. To calculate distance travelled by each ant

public void CalcLength(int ant)

{

int antIndex = Array.IndexOf(ants, ant);

tourLength[antIndex] = 0.0;

int index1,index2;

for (int a = 0; a < count; a++)

{

index1=Array.IndexOf(city,cityVisited[antIndex,a]);

index2 = Array.IndexOf(city, cityVisited[antIndex, (a + 1) %

count]);

tourLength[antIndex] += distance[index1,index2];

}

}

j. To update pheromones

public void UpdatePheromone(int ant, double sum)

{

int antIndex = Array.IndexOf(ants, ant);

double temp = 1 / bestTourLength;

int index1, index2;

for (int i = 0; i < count; i++)

{

index1=Array.IndexOf(city,cityVisited[antIndex,i]);

index2 = Array.IndexOf(city, cityVisited[antIndex, (i + 1)

% count]);

pheromone[index1, index2] = (1-rho) * pheromone[index1,

index2] + Q * sum;

pheromone[index2, index1] = pheromone[index1, index2];

}

}

71

## Much more than documents.

Discover everything Scribd has to offer, including books and audiobooks from major publishers.

Cancel anytime.