├── tsp-ga
    ├── tsp-ga-cpu
    ├── tsp-ga-gpu
    ├── ga_cpu.h
    ├── common.h
    ├── Makefile
    ├── common.cpp
    ├── main_cpu.cpp
    ├── world.h
    ├── main.cpp
    ├── ga_gpu.h
    ├── world.cpp
    ├── ga_cpu.cpp
    └── ga_gpu.cu
├── tsp-ant
    ├── tsp-ant-cpu
    ├── tsp-ant-gpu
    ├── Makefile
    ├── map_generator.rb
    ├── ants.c
    ├── parallel_ants.cu
    ├── map25.txt
    └── map50.txt
├── GPU Report - TSP - rm4149 .pdf
└── ReadMe.md


/tsp-ga/tsp-ga-cpu:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rachitmehrotra1/TSP-GPU/HEAD/tsp-ga/tsp-ga-cpu


--------------------------------------------------------------------------------
/tsp-ga/tsp-ga-gpu:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rachitmehrotra1/TSP-GPU/HEAD/tsp-ga/tsp-ga-gpu


--------------------------------------------------------------------------------
/tsp-ant/tsp-ant-cpu:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rachitmehrotra1/TSP-GPU/HEAD/tsp-ant/tsp-ant-cpu


--------------------------------------------------------------------------------
/tsp-ant/tsp-ant-gpu:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rachitmehrotra1/TSP-GPU/HEAD/tsp-ant/tsp-ant-gpu


--------------------------------------------------------------------------------
/GPU Report - TSP - rm4149 .pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/rachitmehrotra1/TSP-GPU/HEAD/GPU Report - TSP - rm4149 .pdf


--------------------------------------------------------------------------------
/tsp-ga/ga_cpu.h:
--------------------------------------------------------------------------------
 1 | #ifndef __GA_CPU_H__
 2 | #define __GA_CPU_H__
 3 | 
 4 | // Program includes
 5 | #include "world.h"
 6 | 
 7 | 
 8 | void selection(World* pop, int pop_size, City** parents, float* rand_nums);
 9 | void crossover(City** parents, City* child, int num_cities, int cross_over);
10 | void mutate(City* child, int* rand_nums);
11 | void execute(float prob_mutation, float prob_crossover, int pop_size,
12 | 	int max_gen, World* world, int seed);
13 | 
14 | #endif


--------------------------------------------------------------------------------
/tsp-ga/common.h:
--------------------------------------------------------------------------------
 1 | #ifndef __COMMON_H__
 2 | #define __COMMON_H__
 3 | 
 4 | #include <ctime>
 5 | #include <random>
 6 | #include "world.h"
 7 | 
 8 |  
 9 | // Check for a CUDA error
10 | bool checkForError(cudaError_t error);
11 | // Initialize the population in host memory
12 | void initialize(World* world, World* pop, int pop_size, int seed);
13 | // Updates the generation and global best leaders	
14 | int select_leader(World* pop, int pop_size, World* generation_leader,
15 | 	World* best_leader);
16 | void print_status(World* generation_leader, World* best_leader, \
17 | 	int generation);
18 | 
19 | #endif


--------------------------------------------------------------------------------
/tsp-ant/Makefile:
--------------------------------------------------------------------------------
 1 | CC = gcc
 2 | NVCC = nvcc
 3 | CUDA_PATH = /usr/local/cuda
 4 | CFLAGS = -L$(CUDA_PATH)/lib64 -lcudart -lcuda -lcurand -lm  
 5 | NVCCFLAGS= -D_FORCE_INLINES -Xcompiler -fPIC  -I$(CUDA_SDK_PATH)/C/common/inc
 6 | COPTFLAGS = -O3 -g -std=c++11 
 7 | LDFLAGS =
 8 | 
 9 | all:  ants.o ant_gpu.o tsp-ant-gpu tsp-ant-cpu
10 | 
11 | tsp-ant-gpu: ant_gpu.o
12 | 	$(NVCC)   $(CFLAGS) $(COPTFLAGS) parallel_ants.cu  -o tsp-ant-gpu
13 | tsp-ant-cpu: ants.o
14 | 	$(CC) $(CFLAGS) ants.c -o tsp-ant-cpu
15 | 
16 | ant_gpu.o: parallel_ants.cu
17 | 	$(NVCC) -c parallel_ants.cu $(CFLAGS) $(COPTFLAGS) $(NVCCFLAGS)
18 | ant_cpu.o: ants.c
19 | 	$(CC) -c ants.c $(CFLAGS) $(COPTFLAGS) $(NVCCFLAGS)


--------------------------------------------------------------------------------
/tsp-ga/Makefile:
--------------------------------------------------------------------------------
 1 | CC = g++
 2 | NVCC = nvcc
 3 | CUDA_PATH = /usr/local/cuda
 4 | CFLAGS = -L$(CUDA_PATH)/lib64 -lcudart -lcuda -lcurand -lm  
 5 | NVCCFLAGS= -D_FORCE_INLINES -Xcompiler -fPIC  -I$(CUDA_SDK_PATH)/C/common/inc
 6 | COPTFLAGS = -O3 -g -std=c++11 
 7 | LDFLAGS =
 8 | 
 9 | all: 	main.o main_cpu.o world.o common.o ga_cpu.o ga_gpu.o tsp-ga-gpu tsp-ga-cpu
10 | 
11 | tsp-ga-gpu: main.o 
12 | 	$(CC) main.o world.o ga_gpu.o common.o  $(CFLAGS) $(COPTFLAGS) -o tsp-ga-gpu
13 | tsp-ga-cpu: main_cpu.o 
14 | 	$(CC) main_cpu.o world.o ga_cpu.o common.o  $(CFLAGS) $(COPTFLAGS) -o tsp-ga-cpu
15 | 
16 | ga_gpu.o: ga_gpu.cu  world.h
17 | 	$(NVCC) -c ga_gpu.cu $(CFLAGS) $(COPTFLAGS) $(NVCCFLAGS)
18 | 
19 | 
20 | ga_cpu.o: ga_cpu.cpp  world.h common.h
21 | 	$(NVCC) -c ga_cpu.cpp $(CFLAGS) $(COPTFLAGS)
22 | 
23 | common.o: common.cpp common.h  world.h
24 | 	$(NVCC) -c common.cpp $(CFLAGS) $(COPTFLAGS)
25 | 
26 | world.o: world.cpp world.h
27 | 	$(NVCC) -c world.cpp $(CFLAGS) $(COPTFLAGS) $(NVCCFLAGS)
28 | main.o: main.cpp  common.h ga_gpu.h  world.h
29 | 	$(NVCC) -c main.cpp $(CFLAGS) $(COPTFLAGS) $(NVCCFLAGS)
30 | main_cpu.o: main_cpu.cpp  common.h ga_cpu.h  world.h
31 | 	$(NVCC) -c main_cpu.cpp $(CFLAGS) $(COPTFLAGS) 
32 | 


--------------------------------------------------------------------------------
/tsp-ga/common.cpp:
--------------------------------------------------------------------------------
 1 | // Native includes
 2 | #include <iostream>
 3 | #include <ctime>
 4 | #include <cstdlib>
 5 | #include <algorithm>
 6 | 
 7 | // Program includes
 8 | #include "common.h"
 9 | 
10 | using namespace std;
11 | 
12 | bool checkForError(cudaError_t error)
13 | {
14 | 	if (error != cudaSuccess)
15 | 	{
16 | 		cout << cudaGetErrorString(error) << endl;
17 | 		return true;
18 | 	}
19 | 	else
20 | 	{
21 | 		return false;
22 | 	}
23 | }
24 | void initialize(World* world, World* pop, int pop_size, int seed)
25 | {
26 | 	// Set the seed for random number generation
27 | 	srand(seed);
28 | 
29 | 	for (int i=0; i<pop_size; i++)
30 | 	{
31 | 		// Clone world
32 | 		pop[i].cities = new City[world->num_cities * sizeof(City)];
33 | 		clone_world(world, &pop[i]);
34 | 
35 | 		// Randomly adjust the path between cities
36 | 		random_shuffle(&pop[i].cities[0], &pop[i].cities[world->num_cities]);
37 | 	}
38 | }
39 | 
40 | int select_leader(World* pop, int pop_size, World* generation_leader,
41 | 	World* best_leader)
42 | {
43 | 	// Find element with the largest fitness function
44 | 	int ix = 0;
45 | 	for (int i=1; i<pop_size; i++)
46 | 	{
47 | 		if (pop[i].fitness > pop[ix].fitness)
48 | 			ix = i;
49 | 	}
50 | 
51 | 	// Store generation leader
52 | 	clone_world(&pop[ix], generation_leader);
53 | 
54 | 	// Update best leader
55 | 	if (generation_leader->fitness > best_leader->fitness)
56 | 	{
57 | 		clone_world(generation_leader, best_leader);
58 | 		return 1;
59 | 	}
60 | 
61 | 	return 0;
62 | }
63 | 
64 | void print_status(World* generation_leader, World* best_leader, int generation)
65 | {
66 | 	cout << "Generation " << generation << ":" << endl;
67 | 	cout << "  Current Leader's Fitness: "  << generation_leader->fitness << endl;
68 | 	cout << "  Best Leader's Fitness: "  << best_leader->fitness << endl;
69 | }


--------------------------------------------------------------------------------
/tsp-ant/map_generator.rb:
--------------------------------------------------------------------------------
 1 | class City
 2 |   attr_accessor :x,:y;
 3 | 
 4 |   def initialize
 5 |     @x = rand(100)
 6 |     @y = rand(100)
 7 |   end
 8 | 
 9 | end
10 | 
11 | 
12 | class MapGenerator
13 |   require 'matrix'
14 |   #require 'math'
15 |   MaxCity_CONST = ARGV[0].to_i # max number of cities
16 |     
17 |   def main()
18 |       @map = generate_cities(MaxCity_CONST) # Plot Cities 
19 |       @distances = calculate_distances(@map)
20 |       generate_output(@distances)
21 |   end
22 |  
23 |   #Cities -> integer
24 |   def generate_cities(cities)
25 |       map =  Array.new
26 | 
27 |       (0..cities-1).each do 
28 |           map.push(City.new)
29 |       end
30 |       return map
31 |   end
32 | 
33 |   #map -> Array of City
34 |   def calculate_distances(map)
35 |     distances = Array.new(map.size) { Array.new(map.size) }
36 |     (0..map.size-1).each do |i|
37 |       (0..map.size-1).each do |j|
38 |         #distance between two points
39 |         if j == i
40 |           distances[i][j] = 0
41 |           distances[j][i] = 0
42 |         else
43 |           dis = Math.hypot((map[i].x - map[j].x),(map[i].y - map[j].y))
44 |           distances[i][j] = dis
45 |           distances[j][i] = dis
46 |         end
47 |       end       
48 |     end
49 | 
50 |     return distances
51 |   end
52 | 
53 |   #distances -> Matrix of distances
54 |   def generate_output(distances)
55 |       if File.exist?("map.txt")
56 |        puts "The file already exists. Rebuilding it..."
57 |        system("rm map.txt")
58 |       end
59 |         out = File.open("map.txt","w")
60 | 
61 |       (0..distances.size-1).each do |i|
62 |         (0..distances.size-1).each do |j|
63 |             out.puts("#{i} #{j} #{distances[i][j].round(4)}")
64 |         end
65 |       end
66 |   end
67 |   
68 |   def initialize
69 |     main()
70 |   end
71 | 
72 | end
73 | 
74 | 
75 | MapGenerator.new
76 | 


--------------------------------------------------------------------------------
/tsp-ga/main_cpu.cpp:
--------------------------------------------------------------------------------
 1 | #include <ctime>
 2 | #include <iostream>
 3 | #include <string.h>
 4 | #include <sstream>
 5 | #include <cstring>
 6 | #include <string>
 7 | #include <cstdio>
 8 | #include "common.h"
 9 | #include "ga_cpu.h"
10 | 
11 | using namespace std;
12 | 
13 | int main()
14 | {
15 | 	// GA parameters
16 | 	float prob_mutation  = (float)0.15; // The probability of a mutation
17 | 	float prob_crossover = (float)0.8;  // The probability of a crossover
18 | 	int world_seed       = 12438955;    // Seed for initial city selection
19 | 	int ga_seed          = 87651111;    // Seed for all other random numbers
20 | 	
21 | 	// World parameters
22 | 	int world_width  = 10000;
23 | 	int world_height = 10000;
24 | 	
25 | 	// The test cases
26 | 	int iterations          = 1;  // Number of full runs
27 | 	const int num_cases     = 1; // How many trials to test
28 | 	int cases[num_cases][3] =     // num_cities, pop_size, max_gen
29 | 	{
30 | 		// {25, 100,    1000},
31 | 		// {25, 1000,   1000},
32 | 		// {25, 10000,  100},
33 | 		// {25, 100000, 10},
34 | 
35 | 		// {50, 100,    1000},
36 | 		// {50, 1000,   1000},
37 | 		// {50, 10000,  100},
38 | 		// {50, 100000, 10},
39 | 
40 | 		// {100, 100,    1000},
41 | 		// {100, 1000,   1000},
42 | 		// {100, 10000,  100},
43 | 		{100, 100000, 10}
44 | 
45 | 	};
46 | 
47 | 	for (int i=0; i<num_cases; i++)
48 | 	{
49 | 		// GA params
50 | 		int num_cities = cases[i][0];
51 | 		int pop_size   = cases[i][1];
52 | 		int max_gen    = cases[i][2];
53 | 
54 | 		// Make the world
55 | 		World* world = new World[sizeof(World)];
56 | 		make_world(world, world_width, world_height, num_cities, world_seed);
57 | 		cout << "CPU Version - START" << endl;
58 | 		for (int j=0; j<iterations; j++)
59 | 		{
60 | 			execute(prob_mutation, prob_crossover, pop_size, max_gen, world, ga_seed);
61 | 		}
62 | 
63 | 		cout << "CPU - END" << endl;
64 | 
65 | 		free_world(world);
66 | 	}
67 | 	
68 | 	return 0;
69 | }
70 | 


--------------------------------------------------------------------------------
/tsp-ga/world.h:
--------------------------------------------------------------------------------
 1 | #ifndef __WORLD_H__
 2 | #define __WORLD_H__
 3 | 
 4 | // Native Includes
 5 | #include <iostream>
 6 | #include <cmath>
 7 | #include <cuda.h>
 8 | #include <cuda_runtime_api.h>
 9 | #include <cstring>
10 | using namespace std;
11 | struct City
12 | {
13 | //Store location - city
14 | 	int x, y;
15 | };
16 | 
17 | typedef struct World
18 | {
19 | 	// 2D world for the TSP
20 | 	int width, height; 
21 | 	int num_cities;    
22 | 	City* cities;      
23 | 	float fitness;     // The current fitness
24 | 	float fit_prob;    // The fitness probability
25 | 
26 | 	inline __host__ void calc_fitness()
27 | 	{
28 | 		float distance = 0.0;
29 | 		for (int i=0; i<num_cities-1; i++)
30 | 			distance += (cities[i].x - cities[i + 1].x) * (cities[i].x -      \
31 | 				cities[i +1 ].x) + (cities[i].y - cities[i + 1].y)     *      \
32 | 				(cities[i].y - cities[i + 1].y);
33 | 		fitness = (width * height) / distance;
34 | 	}
35 | 
36 | 	inline __host__ float calc_distance()
37 | 	{
38 | 		float distance = 0.0;
39 | 		for (int i=0; i<num_cities-1; i++)
40 | 			distance += (float)sqrt((float)((cities[i].x - cities[i + 1].x) * \
41 | 				(cities[i].x - cities[i + 1].x) + (cities[i].y              - \
42 | 				cities[i +1 ].y) * (cities[i].y - cities[i + 1].y)));
43 | 		return distance;
44 | 	}
45 | } World;
46 | 
47 | 
48 | // Makes a new world struct
49 | void make_world(World* world, int width, int height, int num_cities, int seed);
50 | 
51 | 
52 | //FOR CPU
53 | 
54 | 
55 | void init_world(World* world, int width, int height, int num_cities);
56 | void clone_city(City* src, City* dst, int num_cities);
57 | void clone_world(World* src, World* dst);
58 | void free_world(World* world);
59 | void free_population(World* pop, int pop_size);
60 | 
61 | //FOR GPU 
62 | //d_* means device 
63 | //h_* means host
64 | bool g_init_world(World* d_world, World* h_world);
65 | bool g_soft_clone_world(World* d_world, World* h_world);
66 | 
67 | #endif
68 | 


--------------------------------------------------------------------------------
/tsp-ga/main.cpp:
--------------------------------------------------------------------------------
 1 | #include <ctime>
 2 | #include <iostream>
 3 | #include <string.h>
 4 | #include <sstream>
 5 | #include <cstring>
 6 | #include <string>
 7 | #include <cstdio>
 8 | #include "common.h"
 9 | #include "ga_gpu.h"
10 | 
11 | using namespace std;
12 | 
13 | int main()
14 | {
15 | 	// GA parameters
16 | 	float prob_mutation  = (float)0.15; // The probability of a mutation
17 | 	float prob_crossover = (float)0.8;  // The probability of a crossover
18 | 	int world_seed       = 12438955;    // Seed for initial city selection
19 | 	int ga_seed          = 87651111;    // Seed for all other random numbers
20 | 	
21 | 	// World parameters
22 | 	int world_width  = 10000;
23 | 	int world_height = 10000;
24 | 	
25 | 	// The test cases
26 | 	int iterations          = 1;  // Number of full runs
27 | 	const int num_cases     = 1; // How many trials to test
28 | 	int cases[num_cases][3] =     // num_cities, pop_size, max_gen
29 | 	{
30 | 		// {25, 100,    1000},
31 | 		// {25, 1000,   1000},
32 | 		// {25, 10000,  100},
33 | 		// {25, 100000, 10},
34 | 
35 | 		// {50, 100,    1000},
36 | 		// {50, 1000,   1000},
37 | 		// {50, 10000,  100},
38 | 		// {50, 100000, 10},
39 | 
40 | 		// {100, 100,    1000},
41 | 		// {100, 1000,   1000},
42 | 		// {100, 10000,  100},
43 | 		{100, 100000, 10}
44 | 
45 | 	};
46 | 	for (int i=0; i<num_cases; i++)
47 | 	{
48 | 		int num_cities = cases[i][0];
49 | 		int pop_size   = cases[i][1];
50 | 		int max_gen    = cases[i][2];
51 | 		World* world = new World[sizeof(World)];
52 | 		make_world(world, world_width, world_height, num_cities, world_seed);
53 | 		cout << "GPU Version - START" << endl;
54 | 		for (int j=0; j<iterations; j++)
55 | 		{
56 | 			cudaDeviceReset(); // Clear
57 | 
58 | 			if(g_execute(prob_mutation, prob_crossover, pop_size, max_gen,world, ga_seed))
59 | 				{
60 | 					cout<<"GPU Related error - Could be an issue if GPU is being used by others"<<endl
61 | 						<<"Please try running again when there is memory free + GPU is free"	<<endl;
62 | 				}
63 | 
64 | 		}
65 | 
66 | 		cudaDeviceReset();
67 | 
68 | 		cout << "GPU Version - END" << endl;
69 | 
70 | 		free_world(world);
71 | 	}
72 | 	
73 | 	return 0;
74 | }
75 | 


--------------------------------------------------------------------------------
/tsp-ga/ga_gpu.h:
--------------------------------------------------------------------------------
 1 | #ifndef __GA_GPU_H__
 2 | #define __GA_GPU_H__
 3 | 
 4 | #include <cuda.h>
 5 | #include <cuda_runtime_api.h>
 6 | #include <device_launch_parameters.h>
 7 | #include "world.h"
 8 | 
 9 | 
10 | bool checkForKernelError(const char *err_msg);
11 | __device__ int getGlobalIdx_2D_2D();
12 | 
13 | // Perform crossover on the device
14 | // sel_ix    : The indexes of the parents in the old population
15 | // cross_loc : The crossover locations
16 | __device__ void crossover(World* old_pop, World* new_pop, int* sel_ix,int* cross_loc, int tid);
17 | __device__ void mutate(World* new_pop, int* mutate_loc, int tid);
18 | __global__ void fitness_kernel(World* pop, int pop_size);
19 | __global__ void fit_sum_kernel(World* pop, int pop_size, float* fit_sum);
20 | __global__ void fit_prob_kernel(World* pop, int pop_size, float* fit_sum);
21 | __global__ void max_fit_kernel(World* pop, int pop_size, float* max, int* ix);
22 | __global__ void selection_kernel(World* pop, int pop_size, float* rand_nums, int* sel_ix);
23 | 
24 | 
25 | // Main kernal for creating children of the population
26 | // 	old_pop        : The old population (where the parents are located)
27 | // 	new_pop        : The new population (where the children will be)
28 | // 	pop_size       : The number of elements in the population
29 | // 	sel_ix         : The indexes of the parents in the old population
30 | // 	prob_crossover : The probability of corssover occuring
31 | // 	prob_cross     : The probabilities of crossover occuring
32 | // 	cross_loc      : The crossover locations
33 | // 	prob_mutation  : The probability of mutation occuring
34 | // 	prob_mutate    : The probabilities of mutation occuring
35 | // 	mutate_loc     : The mutation locations
36 | __global__ void child_kernel(World* old_pop, World* new_pop, int pop_size, 
37 | 	int* sel_ix, float prob_crossover, float* prob_cross, int* cross_loc, 
38 | 	float prob_mutation, float* prob_mutate, int* mutate_loc);
39 | 
40 | bool g_initialize(World* world, World* pop, int pop_size, int seed);
41 | 
42 | bool g_evaluate(World *pop, int pop_size, dim3 Block, dim3 Grid);
43 | 
44 | int g_select_leader(World* pop, int pop_size, World* generation_leader,World* best_leader, dim3 Block, dim3 Grid);
45 | 
46 | bool g_execute(float prob_mutation, float prob_crossover, int pop_size,int max_gen, World* world, int seed);
47 | 
48 | #endif


--------------------------------------------------------------------------------
/ReadMe.md:
--------------------------------------------------------------------------------
 1 | ReadMe
 2 | 
 3 | Travel Salesman Problem using Genetic Algorithm & Ant Colony Optimization
 4 | Rachit Mehrotra
 5 | Project for CSCI-GA 3033 - 004
 6 | 
 7 | The code is divided into 2 part - TSP using GA and TSP using ACO
 8 | 
 9 | Instructions for TSP using GA
10 | 
11 | - The makefile consists of all the compilation instructions, thus just running 'make' would build everything necessary.All the code was built and tested on cuda2 and the run times in the report are also observed on cuda2 (sometimes device 0, sometimes device 2)
12 | Note: If someone else is using the GPU , the run times could vary by 10-20%
13 | - The application generates its own city data. Thus to run the code with different cities,population,max generation combination. You can make said changes in the main_cpu.cpp - line 28 (for the sequential code)/ main.cpp - line 29 (for the CUDA code). The files are well commented and it's really easy to make changes to the parameter. Just change those parameters and do 'make'.
14 | - Then the sequential version can be run using ./tsp-ga-cpu and Cuda version using ./tsp-ga-gpu
15 | 
16 | Note, the main file also contains the 'seed' for the random number generator. Thus to make sure the CPU and GPU versions of the code are running on the same data, make sure that the seeds are same in both the main file. I have set them to be same , but in case you want to play around by trying different data.
17 | 
18 | 
19 | Instructions for TSP using ACO
20 | -For ACO , since it's a much smaller and simpler code , I just used 1 file each for parallel and CUDA version. I'm using an open source map_generator (coded in ruby), that takes the number of cities as a parameter and builds a map.txt that contains a random city map with said N cities. 
21 | Command to run the map generator : ruby map_generator.rb Num_of_cities
22 | -I have compiled and saved 3 different variants of maps for the ease of the grader to check my code. map25.txt , map50.txt , and map100.txt contains maps with 25,50,100 cities respectively.
23 | 
24 | -To run the sequential and parallel version of the code. Just do a 'make'
25 | and to run the sequential version using for example to run for 25 cities -> ./tsp-ant-cpu < map25.txt
26 | and to run the parallel version using for example 25 cities -> ./tsp-ant-gpu < map25.txt
27 | This ensures that the input data for parallel and sequential version is same
28 | 
29 | NOTE: Just like GA, even in this, to play around with a number of cities, just open ants.c - line 7 & parallel_ants.cu - line 8and change the #define cities 25 , to whatever value you want ,25,50 or 100 and do a 'make' to compile the code. Since all the memory allocation and some other global variables depend on the 'CITIES' variable, I didn't take it as a parameter and instead defined it as a #define.
30 | 
31 | 
32 | Happy Testing :) 


--------------------------------------------------------------------------------
/tsp-ga/world.cpp:
--------------------------------------------------------------------------------
  1 | // Native Includes
  2 | #include <set>
  3 | #include <tuple>
  4 | #include <random>
  5 | #include <functional>
  6 | 
  7 | // Program Includes
  8 | #include "world.h"
  9 | #include "common.h"
 10 | #include "ga_gpu.h"
 11 | 
 12 | //Functions for both CPU and GPU
 13 | void make_world(World* world, int width, int height, int num_cities, int seed)
 14 | {
 15 | 	// Random number generation
 16 | 	mt19937::result_type rseed = seed;
 17 | 	auto rgen = bind(uniform_real_distribution<>(0, 1), mt19937(rseed));
 18 | 	init_world(world, width, height, num_cities);
 19 | 	
 20 | 	// Create a set to deal with uniqueness
 21 | 	set<tuple<int, int>> coordinates;
 22 | 	set<tuple<int, int>>::iterator it;
 23 | 	pair<set<tuple<int, int>>::iterator,bool> ret;
 24 | 	
 25 | 	// Create some unique random cities
 26 | 	for (int i=0; i<num_cities; i++)
 27 | 	{
 28 | 		while (true)
 29 | 		{
 30 | 			tuple<int,int> coors((int)(rgen() * width), (int)(rgen() * height));
 31 | 			ret = coordinates.insert(coors);
 32 | 			if (ret.second)
 33 | 				break;
 34 | 		}
 35 | 	}
 36 | 	
 37 | 	// Add those cities to the world
 38 | 	{
 39 | 		int i = 0;
 40 | 		for (it=coordinates.begin(); it!=coordinates.end(); it++)
 41 | 		{
 42 | 			world->cities[i].x = get<0>(*it);
 43 | 			world->cities[i].y = get<1>(*it);
 44 | 			i++;
 45 | 		}
 46 | 	}
 47 | }
 48 | 
 49 | //CPU
 50 | 
 51 | void init_world(World* world, int width, int height, int num_cities)
 52 | {
 53 | 	world->width      = width;
 54 | 	world->height     = height;
 55 | 	world->num_cities = num_cities;
 56 | 	world->fitness    = (float)0.0;
 57 | 	world->fit_prob   = (float)0.0;
 58 | 	world->cities     = new City[num_cities * sizeof(City)];
 59 | }
 60 | 
 61 | void clone_city(City* src, City* dst, int num_cities)
 62 | {
 63 | memcpy(dst, src, num_cities * sizeof(City));
 64 | }
 65 | 
 66 | void clone_world(World* src, World* dst)
 67 | {
 68 | 	dst->width      = src->width;
 69 | 	dst->height     = src->height;
 70 | 	dst->num_cities = src->num_cities;
 71 | 	dst->fitness    = src->fitness;
 72 | 	dst->fit_prob   = src->fit_prob;
 73 | 	clone_city(src->cities, dst->cities, src->num_cities);
 74 | }
 75 | 
 76 | void free_world(World* world)
 77 | {
 78 | 	delete[] world->cities;
 79 | 	delete[] world;
 80 | }
 81 | 
 82 | void free_population(World* pop, int pop_size)
 83 | {
 84 | 	for (int i=0; i<pop_size; i++)
 85 | 		delete[] pop[i].cities;
 86 | 	delete[] pop;
 87 | }
 88 | 
 89 | //GPU
 90 | 
 91 | bool g_init_world(World* d_world, World* h_world)
 92 | {
 93 | 	// Error checking
 94 | 	bool error;
 95 | 	
 96 | 	// Soft clone world
 97 | 	error = g_soft_clone_world(d_world, h_world);
 98 | 	if (error)
 99 | 		return true;
100 | 	
101 | 	// Allocate space for cities on device
102 | 	City *d_city;
103 | 	error = checkForError(cudaMalloc((void**)&d_city, h_world->num_cities * sizeof(City)));
104 | 	if (error)
105 | 	return true;
106 | 	
107 | 	// Update pointer on device
108 | 	error = checkForError(cudaMemcpy(&d_world->cities, &d_city, sizeof(City*), cudaMemcpyHostToDevice));
109 | 	if (error)
110 | 	return true;
111 | 	
112 | 	return false;
113 | }
114 | 
115 | bool g_soft_clone_world(World* d_world, World* h_world)
116 | {
117 | 	// Error checking
118 | 	bool error;
119 | 	
120 | 	error = checkForError(cudaMemcpy(&d_world->width, &h_world->width,        \
121 | 		sizeof(int), cudaMemcpyHostToDevice));
122 | 	if (error)
123 | 	return true;
124 | 	error = checkForError(cudaMemcpy(&d_world->height, &h_world->height,      \
125 | 		sizeof(int), cudaMemcpyHostToDevice));
126 | 	if (error)
127 | 	return true;
128 | 	error = checkForError(cudaMemcpy(&d_world->num_cities,                    \
129 | 		&h_world->num_cities, sizeof(int), cudaMemcpyHostToDevice));
130 | 	if (error)
131 | 	return true;
132 | 
133 | 	return false;
134 | }
135 | 


--------------------------------------------------------------------------------
/tsp-ga/ga_cpu.cpp:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | #include <algorithm>
  3 | #include "ga_cpu.h"
  4 | #include "common.h"
  5 | using namespace std;
  6 | 
  7 | void selection(World* pop, int pop_size, City** parents, float* rand_nums)
  8 | {
  9 | 
 10 | 	// Select the parents
 11 | 	for (int i=0; i<2; i++)
 12 | 	{
 13 | 		for (int j=0; j<pop_size; j++)
 14 | 		{
 15 | 			if (rand_nums[i] <= pop[j].fit_prob)
 16 | 			{
 17 | 				clone_city(pop[j].cities, parents[i], pop[0].num_cities *  sizeof(City));
 18 | 				break;
 19 | 			}
 20 | 		}
 21 | 	}
 22 | }
 23 | 
 24 | void crossover(City** parents, City* child, int num_cities, int cross_over)
 25 | {
 26 | 	// Select elements in first parent from start up through crossover point
 27 | 	clone_city(parents[0], child, cross_over + 1);
 28 | 	
 29 | 	// Add remaining elements from second parent to child, preserving order
 30 | 	int remaining = num_cities - cross_over - 1;
 31 | 	int count     = 0; 
 32 | 	for (int i=0; i<num_cities; i++) // Loop parent
 33 | 	{
 34 | 		bool in_child = false;
 35 | 		for (int j=0; j<=cross_over; j++) // Loop child
 36 | 		{
 37 | 			// If the city is in the child, exit this loop
 38 | 			if ((child[j].x == parents[1][i].x) & (child[j].y == parents[1][i].y))
 39 | 			{
 40 | 				in_child = true;
 41 | 				break;
 42 | 			}
 43 | 		}
 44 | 			
 45 | 		// If the city was not found in the child, add it to the child
 46 | 		if (!in_child)
 47 | 		{
 48 | 			count++;
 49 | 			clone_city(&parents[1][i], &child[cross_over + count], 1);
 50 | 		}
 51 | 		if (count == remaining) break;
 52 | 	}
 53 | }
 54 | 
 55 | void mutate(City* child, int* rand_nums)
 56 | {
 57 | 	City temp               = *(child + rand_nums[0]);
 58 | 	*(child + rand_nums[0]) = *(child + rand_nums[1]);
 59 | 	*(child + rand_nums[1]) = temp;
 60 | }
 61 | 
 62 | void execute(float prob_mutation, float prob_crossover, int pop_size,
 63 | 	int max_gen, World* world, int seed)
 64 | {
 65 | 	mt19937::result_type rseed = seed;
 66 | 	auto rgen = bind(uniform_real_distribution<>(0, 1), mt19937(rseed));
 67 | 
 68 | 	int world_size = pop_size * sizeof(World);
 69 | 	World* old_pop = new World[world_size];
 70 | 	World* new_pop = new World[world_size];
 71 | 	int individual_size = world->num_cities * sizeof(City);
 72 | 
 73 | 	// The best individuals
 74 | 	int best_generation      = 0;
 75 | 	World* best_leader       = new World[sizeof(World)];
 76 | 	World* generation_leader = new World[sizeof(World)];
 77 | 	init_world(best_leader, world->width, world->height, world->num_cities);
 78 | 	init_world(generation_leader, world->width, world->height, world->num_cities);
 79 | 	
 80 | 	// Initialize the population
 81 | 	initialize(world, old_pop, pop_size, seed);
 82 | 	for (int i=0; i<pop_size; i++)
 83 | 		init_world(&new_pop[i], world->width, world->height,world->num_cities);
 84 | 	
 85 | 	// Calculate the fitnesses
 86 | 	float fit_sum = (float)0.0;
 87 | 	for (int i=0; i<pop_size; i++)
 88 | 	{
 89 | 		old_pop[i].calc_fitness();
 90 | 		fit_sum        += old_pop[i].fitness;
 91 | 		old_pop[i].fit_prob = fit_sum;
 92 | 	}
 93 | 	// Compute the full probabilities
 94 | 	for (int i=0; i<pop_size; i++)
 95 | 		old_pop[i].fit_prob /= fit_sum;
 96 | 
 97 | 	
 98 | 	// Initialize the best leader
 99 | 	select_leader(old_pop, pop_size, generation_leader, best_leader);
100 | 	print_status(generation_leader, best_leader, 0);
101 | 
102 | 
103 | 	// Continue through all generations
104 | 	for (int i=0; i<max_gen; i++)
105 | 	{
106 | 
107 | 		// Create a new population
108 | 		for (int j=0; j<pop_size; j++)
109 | 		{
110 | 			// Parents and children
111 | 			City** parents = new City* [2];
112 | 			City* child    = new City[individual_size];
113 | 			parents[0]     = new City[individual_size];
114 | 			parents[1]     = new City[individual_size];
115 | 			
116 | 			// Generate all probabilities
117 | 			//Note : Same order as GPU to make sure same random values are generated
118 | 			float prob_select[2] = {(float)rgen(), (float)rgen()};
119 | 			float prob_cross     = (float)rgen();
120 | 			int   cross_loc      = (int)(rgen() * (world->num_cities - 1));
121 | 			float prob_mutate    = (float)rgen();
122 | 			int   mutate_loc[2]  = { (int)(rgen() * world->num_cities),(int)(rgen() * world->num_cities) };
123 | 			while (mutate_loc[1] == mutate_loc[0])
124 | 				mutate_loc[1] = (int)(rgen() * world->num_cities);
125 | 
126 | 			// Select two parents
127 | 			selection(old_pop, pop_size, parents, &prob_select[0]);
128 | 			
129 | 			// Determine how many children are born
130 | 			if (prob_cross <= prob_crossover)
131 | 			{
132 | 				// Perform crossover
133 | 				crossover(parents, child, world->num_cities, cross_loc);
134 | 
135 | 				// Perform mutation
136 | 				if (prob_mutate <= prob_mutation)
137 | 					mutate(child, &mutate_loc[0]);
138 | 
139 | 				//Cild is added to new pop
140 | 				clone_city(child, new_pop[j].cities, individual_size);
141 | 			}
142 | 			else // Select the first parent
143 | 			{
144 | 				// Perform mutation
145 | 				if (prob_mutate <= prob_mutation)
146 | 					mutate(parents[0], &mutate_loc[0]);
147 | 				//Cild is added to new pop
148 | 				clone_city(parents[0], new_pop[j].cities, individual_size);
149 | 			}
150 | 		} 
151 | 
152 | 		// Calculate the fitnesses
153 | 		float fit_sum = (float)0.0;
154 | 		for (int i=0; i<pop_size; i++)
155 | 		{
156 | 			new_pop[i].calc_fitness();
157 | 			fit_sum        += new_pop[i].fitness;
158 | 			new_pop[i].fit_prob = fit_sum;
159 | 		}
160 | 		// Compute the full probabilities
161 | 		for (int i=0; i<pop_size; i++)
162 | 			new_pop[i].fit_prob /= fit_sum;
163 | 
164 | 		// Swap the populations
165 | 		World* temp = old_pop;
166 | 		old_pop     = new_pop;
167 | 		new_pop     = temp;
168 | 
169 | 		// Select the new leaders
170 | 		if (select_leader(old_pop, pop_size, generation_leader, best_leader))
171 | 			best_generation = i + 1;
172 | 		print_status(generation_leader, best_leader, i + 1);
173 | 	}
174 | 	cout << endl << "Best generation found at " << best_generation << " generations" << endl;
175 | 	free_population(old_pop, pop_size);	free_population(new_pop, pop_size);
176 | 	free_world(best_leader); free_world(generation_leader);
177 | }


--------------------------------------------------------------------------------
/tsp-ant/ants.c:
--------------------------------------------------------------------------------
  1 | #include <stdio.h>
  2 | #include <stdlib.h>
  3 | #include <assert.h>
  4 | #include <math.h>
  5 | 
  6 | //Problem parameters
  7 | #define CITIES 100
  8 | #define ANTS 2000
  9 | #define MAX_DIST 100
 10 | #define MAX_TOTAL_DISTANCE (CITIES * MAX_DIST)
 11 | 
 12 | #define ALPHA 1
 13 | #define BETA 5 //This parameter raises the weight of distance over pheromone
 14 | #define RHO 0.5 //Evapouration rate
 15 | #define QVAL 100
 16 | #define MAX_TOURS 50
 17 | #define MAX_TIME (MAX_TOURS * CITIES)
 18 | #define INIT_PHER (1.0/CITIES)
 19 | 
 20 | //Global structures
 21 | struct ant{
 22 | 	
 23 | 	int curCity, nextCity, pathIndex;
 24 | 	int visited[CITIES];
 25 | 	int path[CITIES];
 26 | 	float tourLength;
 27 | };
 28 | 
 29 | float distances[CITIES][CITIES];
 30 | struct ant ants[ANTS];
 31 | double hormone[CITIES][CITIES];
 32 | 
 33 | float bestdistance = (float)MAX_TOTAL_DISTANCE;
 34 | int bestIndex;
 35 | 
 36 | //Methods
 37 | 
 38 | void get_distances_matrix(){
 39 |   int i= 0,j = 0;
 40 |   double k;
 41 | 
 42 |   while(scanf("%i %i %lf",&i,&j,&k) == 3){
 43 |     distances[i][j] = k;
 44 |     hormone[i][j] = INIT_PHER;
 45 |      // printf("i: %i, j: %i, k: %lf \n",i,j,k);
 46 |      // printf("Distance[i][j]: %lf\n", distances[i][j]);
 47 |   }
 48 |  printf("Got distance Matrix -- %i cities\n", CITIES);
 49 | }
 50 | 
 51 | void initialize_ants(){
 52 |    int i,k, init = 0;
 53 |    for( i = 0; i < ANTS; i++){
 54 |      if(init == CITIES)
 55 |        init = 0;
 56 |   
 57 |      for(k = 0; k < CITIES; k++){
 58 |        ants[i].visited[k] = 0;
 59 |        ants[i].path[k] = -1;
 60 |      } 
 61 | 
 62 |      ants[i].curCity = init++;
 63 |      ants[i].pathIndex = 1;
 64 |      ants[i].path[0] = ants[i].curCity;
 65 |      ants[i].nextCity = -1;
 66 |      ants[i].tourLength = 0;
 67 |      ants[i].visited[ants[i].curCity] = 1;
 68 |    }
 69 |   // printf("Ants Initialized - %i ants\n",ANTS);
 70 | }
 71 | 
 72 | //reinitialize all ants and redistribute them
 73 | void restart_ants(){
 74 | 	int ant,i,to=0;
 75 | 
 76 | 	for(ant = 0; ant < ANTS; ant++){
 77 | 	  // printf("ant %i -- tour: %f  -- best: %f\n",ant, ants[ant].tourLength, bestdistance);
 78 | 		if(ants[ant].tourLength < bestdistance){
 79 | 			bestdistance = ants[ant].tourLength;
 80 | 			bestIndex = ant;
 81 | 		}
 82 | 
 83 | 		ants[ant].nextCity = -1;
 84 | 		ants[ant].tourLength = 0.0;
 85 | 
 86 | 		for(i = 0; i < CITIES; i++){
 87 | 			ants[ant].visited[i] = 0;
 88 | 			ants[ant].path[i] = -1;
 89 | 		}
 90 | 		
 91 | 		ants[ant].curCity = rand()%CITIES;
 92 | 
 93 | 		ants[ant].pathIndex = 1;
 94 | 		ants[ant].path[0] = ants[ant].curCity;
 95 | 
 96 | 		ants[ant].visited[ants[ant].curCity] = 1;
 97 | 	}
 98 | }
 99 | 
100 | double antProduct(int from, int to){
101 |   // printf("Ant Product: from: %i to: %i\n", from, to);
102 |   // printf("First: %lf, Second: %lf\n",pow( hormone[from][to], ALPHA), pow( (1.0/ distances[from][to]), BETA));
103 |   // printf("Hormone: %lf, Distance: %lf, BETA: %lf\n", hormone[from][to], distances[from][to], BETA);
104 |    return (double) (( pow( hormone[from][to], ALPHA) * pow( (1.0/ distances[from][to]), BETA)));
105 | }
106 | 
107 | int NextCity( int pos ){
108 | 	int from, to;
109 | 	double denom = 0.0;
110 | 
111 | 	from = ants[pos].curCity;
112 | 
113 |   for(to = 0; to < CITIES; to++){
114 | 		if(ants[pos].visited[to] == 0){
115 | 			denom += antProduct( from, to );
116 |       //printf("%lf -- denom\n", denom);
117 | 		}
118 | 	}
119 |    
120 |   assert(denom != 0.0); 
121 | 
122 |   int count = CITIES;
123 | 
124 | 	do{
125 | 		double p = 0.0;
126 | 		to++;
127 | 
128 | 		if(to >= CITIES)
129 | 			to=0;
130 | 
131 | 		if(ants[pos].visited[to] == 0){
132 | 			p = (double) antProduct(from,to)/denom;
133 | 
134 | 			double x =  ((double)rand()/(double)RAND_MAX); 
135 |       //printf("Denon: %18.50f -- X: %18.50f, p: %18.50f\n",denom, x,p);
136 | 			if(x < p){
137 |         //printf("%lf -- X\n", x);
138 | 				break;
139 | 			}
140 |       count--;
141 |       if(count == 0){
142 |         break;
143 |       }
144 | 		}//sleep(3);
145 | 	}while(1);
146 | 
147 | 	return to;
148 | }
149 | 
150 | int simulate_ants(){
151 |   int k, moving = 0; 
152 |   
153 |   for(k = 0; k < ANTS; k++){ 
154 |     //printf("Formiga (%i)\n", k);
155 | 	if( ants[k].pathIndex < CITIES ){ //check if all cities were visited
156 | 		ants[k].nextCity = NextCity(k);
157 | 		ants[k].visited[ants[k].nextCity] = 1;
158 | 		ants[k].path[ants[k].pathIndex++] = ants[k].nextCity;
159 | 
160 | 		ants[k].tourLength += distances[ants[k].curCity][ants[k].nextCity];
161 | 
162 | 		//handle last case->last city to first
163 | 
164 | 		if(ants[k].pathIndex == CITIES){
165 | 			ants[k].tourLength += distances[ants[k].path[CITIES -1]][ants[k].path[0]];
166 | 		}
167 | 
168 | 		ants[k].curCity = ants[k].nextCity;
169 | 		moving++;
170 | 
171 | 	}
172 |   } 
173 |   return moving;
174 | }
175 | 
176 | 
177 | void move_ants(){
178 |   int curtime = 0;
179 | 
180 |   while(curtime++ < MAX_TIME){ 
181 |     if( simulate_ants() == 0){
182 |       //  Updating the trails of the ants
183 |       int from,to,i,ant;
184 | 
185 | 	//hormone evaporation
186 | 	for(from = 0; from < CITIES; from++)
187 | 		for(to = 0;to < CITIES; to++){
188 | 			if(from!=to){
189 | 				hormone[from][to] *=( 1.0 - RHO);
190 | 
191 | 				if(hormone[from][to] < 0.0){
192 | 					hormone[from][to] = INIT_PHER;
193 | 				}
194 | 			}
195 | 		}
196 | 	
197 | 
198 | 	//add new pheromone to the trails
199 | 	for(ant = 0; ant < ANTS; ant++)
200 | 		for(i = 0; i < CITIES; i++){	
201 | 			if( i < CITIES - 1 ){
202 | 				from = ants[ant].path[i];
203 | 				to = ants[ant].path[i+1];
204 | 			}
205 | 			else{
206 | 				from = ants[ant].path[i];
207 | 				to = ants[ant].path[0];
208 | 			}
209 | 
210 | 			hormone[from][to] += (QVAL/ ants[ant].tourLength);
211 | 			hormone[to][from] = hormone[from][to];
212 | 
213 | 		}
214 | 	
215 | 
216 | 	for (from = 0; from < CITIES; from++)
217 | 		for( to = 0; to < CITIES; to++){
218 | 			hormone[from][to] *= RHO;
219 | 		}
220 | 	
221 | 
222 | 
223 |       if (curtime != MAX_TIME)
224 |           restart_ants();
225 |     }
226 |     if(MAX_TIME%curtime == 0 )
227 |     {
228 |       printf("Best: %lf\n", bestdistance);
229 |   	}
230 |   }
231 | }
232 | 
233 | 
234 | int main()
235 | {
236 |  printf("%i -", MAX_TOTAL_DISTANCE);
237 |   get_distances_matrix();
238 | 
239 |   initialize_ants();
240 |   
241 |   srand(time(NULL));
242 |   printf("End - setting data; Begin -- calculations\n");
243 | 
244 |   move_ants();
245 |   
246 |   
247 |  
248 | 	return 0;
249 | }
250 | 


--------------------------------------------------------------------------------
/tsp-ant/parallel_ants.cu:
--------------------------------------------------------------------------------
  1 | #include <stdio.h>
  2 | #include <stdlib.h>
  3 | #include <assert.h>
  4 | #include <math.h>
  5 | #include <curand_kernel.h>
  6 | 
  7 | //Problem Parameters
  8 | #define CITIES 100
  9 | #define ANTS 2000
 10 | #define MAX_DIST 100
 11 | #define ALPHA 1
 12 | #define BETA 5       //This parameter raises the weight of distance over pheromone
 13 | #define RHO 0.5      //Evapouration rate
 14 | #define QVAL 100     //
 15 | #define MAX_TOURS 50// The number of times an ant will walk trough all the cities
 16 | #define INIT_PHER (1.0/CITIES) //Initial hormone for each path
 17 | #define MAX_TOTAL_DISTANCE (CITIES * MAX_DIST) // MAX possible distance that an ant can walk
 18 | 
 19 | 
 20 | struct ant{
 21 |   int curCity, nextCity, pathIndex;
 22 |   int visited[CITIES];
 23 |   int path[CITIES];
 24 |   float tourLength;
 25 | };
 26 | 
 27 | //CPU
 28 | float        distances[CITIES][CITIES]; // Distance between city i an j
 29 | double       hormone[CITIES][CITIES]; //Hormone between city i and j
 30 | struct ant   ants[ANTS];
 31 | float        bestdistance[ANTS];
 32 | float 		 finalbest = (float)MAX_TOTAL_DISTANCE;
 33 | curandState  state[ANTS];
 34 | const size_t distances_size = sizeof(float) * size_t(CITIES*CITIES);
 35 | const size_t hormone_size = sizeof(double) * size_t(CITIES*CITIES);
 36 | //GPU
 37 | float        *distances_d;
 38 | struct ant   *ants_d;
 39 | double       *hormone_d;
 40 | float        *bestdistance_d;
 41 | curandState  *state_d;
 42 | int BLOCKS,THREADS;
 43 | 
 44 | void get_distances_matrix();
 45 | void deviceAlloc();
 46 | __global__ void initialize_ants(struct ant *ants_d, curandState *state_d, float *bestdistance_d , int THREADS);
 47 | __global__ void setup_curand_states(curandState *state_d, unsigned long t , int THREADS);
 48 | __global__ void restart_ants(struct ant *ants_d,curandState *state_d, float *bestdistance_d , int THREADS);
 49 | void move_ants();
 50 | __global__ void simulate_ants(struct ant *ants_d,curandState *state_d, float *distances_d, double *hormone_d, int THREADS);
 51 | __device__ double antProduct(int from, int to, double *hormone_d, float *distances_d);
 52 | __device__ int NextCity(struct ant *ants_d, int pos, float *distances_d, double *hormone_d, curandState *state_d );
 53 | void updateTrails();
 54 | 
 55 | int main(){
 56 | 
 57 | 		//Set blocks and threads based on number of ants
 58 | 		if(ANTS<=1024)
 59 | 		{
 60 | 			BLOCKS=1;
 61 | 			THREADS=ANTS;
 62 | 		}
 63 | 		else
 64 | 		{
 65 | 			THREADS=1024;
 66 | 			BLOCKS=ceil(ANTS/(float)THREADS);
 67 | 
 68 | 		}
 69 | 		get_distances_matrix(); // Get the distances between cities from the input
 70 | 		deviceAlloc(); // Mallocs and memcpy of the device variables
 71 | 
 72 | 		//Set up an array of curand_states in order to build better random numbers
 73 | 		time_t t; time(&t);
 74 | 		setup_curand_states <<< BLOCKS, THREADS >>> (state_d, (unsigned long) t , THREADS);
 75 | 		cudaThreadSynchronize();
 76 | 
 77 | 		//initialize the ants array
 78 | 		initialize_ants <<< BLOCKS, THREADS >>> (ants_d, state_d, bestdistance_d , THREADS);
 79 | 		cudaThreadSynchronize();
 80 | 
 81 | 		// Start and control the ants tours
 82 | 		move_ants();
 83 | 
 84 | 		//Free Memory
 85 | 		cudaFree(ants_d);
 86 | 		cudaFree(bestdistance_d);
 87 | 		cudaFree(distances_d);
 88 | 		cudaFree(hormone_d);
 89 | 		cudaFree(state_d);
 90 | 		cudaFree(bestdistance_d);
 91 | 
 92 | 		return 0;
 93 | }
 94 | 
 95 | 
 96 | void get_distances_matrix(){
 97 |   int i,j;
 98 |   float k;
 99 | 
100 |   while(scanf("%i %i %f", &i,&j,&k) == 3){
101 |     distances[i][j] = k;
102 |     hormone[i][j] = INIT_PHER;
103 |   }
104 | 
105 | }
106 | 
107 | void deviceAlloc(){
108 | 	cudaMalloc( (void**) &ants_d, sizeof(ants));
109 | 	cudaMalloc( (void**) &state_d, sizeof(state));
110 | 
111 | 	cudaMalloc( (void**) &distances_d, distances_size);
112 | 	cudaMemcpy(distances_d, distances, distances_size, cudaMemcpyHostToDevice);
113 | 
114 | 	cudaMalloc( (void**) &hormone_d, hormone_size);
115 | 	cudaMemcpy(hormone_d, hormone, hormone_size, cudaMemcpyHostToDevice);
116 | 
117 | 	cudaMalloc( (void**) &bestdistance_d, sizeof(bestdistance));
118 | }
119 | 
120 | __global__ void setup_curand_states(curandState *state_d, unsigned long t, int THREADS){
121 | 	int id = threadIdx.x + blockIdx.x*THREADS;
122 | 	curand_init(t, id, 0, &state_d[id]);
123 | }
124 | 
125 | __global__ void initialize_ants(struct ant *ants_d, curandState *state_d, float *bestdistance_d , int THREADS){
126 | 
127 |   int position = threadIdx.x + blockIdx.x*THREADS;
128 |   int k;
129 | 
130 |   // Mark all cities as not visited
131 |   // Mark all path as not traversed
132 |   for(k = 0; k < CITIES; k++){
133 |     ants_d[position].visited[k] = 0;
134 |     ants_d[position].path[k] = -1;
135 |   }
136 | 
137 |   bestdistance_d[position] = (float)MAX_TOTAL_DISTANCE;
138 | 
139 |   //Random City to begin
140 |   ants_d[position].curCity = curand(&state_d[position])% CITIES;
141 |   ants_d[position].pathIndex = 1;
142 |   ants_d[position].path[0] = ants_d[position].curCity;
143 |   ants_d[position].nextCity = -1;
144 |   ants_d[position].tourLength = 0;
145 |   ants_d[position].visited[ants_d[position].curCity] = 1;
146 | }
147 | 
148 | __global__ void restart_ants(struct ant *ants_d,curandState *state_d, float *bestdistance_d , int THREADS){
149 | 
150 | 	int position = threadIdx.x + blockIdx.x*THREADS;
151 | 	int i;
152 | 
153 | 	if(ants_d[position].tourLength < bestdistance_d[position]){
154 | 		bestdistance_d[position] = ants_d[position].tourLength;
155 | 	}
156 | 
157 | 	ants_d[position].nextCity = -1;
158 | 	ants_d[position].tourLength = 0.0;
159 | 
160 | 	for(i = 0; i < CITIES; i++){
161 | 		ants_d[position].visited[i] = 0;
162 | 		ants_d[position].path[i] = -1;
163 | 	}
164 | 
165 | 	ants_d[position].curCity = curand(&state_d[position])% CITIES;
166 | 	ants_d[position].pathIndex = 1;
167 | 	ants_d[position].path[0] = ants_d[position].curCity;
168 | 	ants_d[position].visited[ants_d[position].curCity] = 1;
169 | }
170 | 
171 | void move_ants(){
172 | 	int curtour = 0;
173 | 	while (curtour++ < MAX_TOURS){
174 | 		simulate_ants <<< BLOCKS, THREADS >>> (ants_d, state_d, distances_d, hormone_d, THREADS);
175 | 		cudaThreadSynchronize();
176 | 
177 | 		cudaMemcpy(ants, ants_d, sizeof(ants), cudaMemcpyDeviceToHost);
178 | 		
179 | 		//update the trails of the ants
180 | 					int from,to,i,ant;
181 | 
182 | 				//hormone evaporation
183 | 				for(from = 0; from < CITIES; from++)
184 | 					for(to = 0;to < CITIES; to++){
185 | 						if(from!=to){
186 | 							hormone[from][to] *=( 1.0 - RHO);
187 | 
188 | 							if(hormone[from][to] < 0.0){
189 | 								hormone[from][to] = INIT_PHER;
190 | 							}
191 | 						}
192 | 					}
193 | 
194 | 				//add new pheromone to the trails
195 | 				for(ant = 0; ant < ANTS; ant++)
196 | 					for(i = 0; i < CITIES; i++){
197 | 						if( i < CITIES - 1 ){
198 | 							from = ants[ant].path[i];
199 | 							to = ants[ant].path[i+1];
200 | 						}
201 | 						else{
202 | 							from = ants[ant].path[i];
203 | 							to = ants[ant].path[0];
204 | 						}
205 | 
206 | 						hormone[from][to] += (QVAL/ ants[ant].tourLength);
207 | 						hormone[to][from] = hormone[from][to];
208 | 
209 | 					}
210 | 
211 | 
212 | 				for (from = 0; from < CITIES; from++)
213 | 					for( to = 0; to < CITIES; to++){
214 | 						hormone[from][to] *= RHO;
215 | 					}
216 | 
217 | 		cudaMemcpy(hormone_d, hormone, hormone_size, cudaMemcpyHostToDevice);
218 | 		cudaMemcpy(bestdistance, bestdistance_d, sizeof(bestdistance), cudaMemcpyDeviceToHost);
219 | 				for(i =0; i < ANTS; i++)
220 | 				  if(bestdistance[i] < finalbest){
221 | 					  finalbest = bestdistance[i];
222 | 				  }
223 | 				printf("Best distance %f \n", finalbest);
224 | 
225 | 		restart_ants <<< BLOCKS, THREADS >>> (ants_d, state_d, bestdistance_d, THREADS);
226 | 		cudaThreadSynchronize();
227 | 
228 | 	}
229 | }
230 | 
231 | __global__ void simulate_ants(struct ant *ants_d,curandState *state_d, float *distances_d, 
232 | 								double *hormone_d , int THREADS ){
233 | 
234 | 	int position = threadIdx.x + blockIdx.x*THREADS;
235 | 	int curtime = 0;
236 | 
237 | 	while(curtime++ < CITIES){
238 | 		//check if all cities were visited
239 | 		if( ants_d[position].pathIndex < CITIES ){ 
240 | 
241 | 			ants_d[position].nextCity = NextCity(ants_d, position, distances_d, hormone_d, state_d);
242 | 			ants_d[position].visited[ants_d[position].nextCity] = 1;
243 | 			ants_d[position].path[ants_d[position].pathIndex++] = ants_d[position].nextCity;
244 | 			ants_d[position].tourLength += distances_d[ants_d[position].curCity + (ants_d[position].nextCity * CITIES)];
245 | 			if(ants_d[position].pathIndex == CITIES){
246 | 				ants_d[position].tourLength += distances_d[ants_d[position].path[CITIES -1] + (ants_d[position].path[0]*CITIES)];
247 | 			}
248 | 			ants_d[position].curCity = ants_d[position].nextCity;
249 | 		}
250 | 	}
251 | 
252 | }
253 | 
254 | __device__ double antProduct(int from, int to, double *hormone_d, float *distances_d){
255 |   return (double) (( pow( hormone_d[from + to*CITIES], ALPHA) * pow( (1.0/ distances_d[from + to*CITIES]), BETA)));
256 | }
257 | 
258 | 
259 | __device__ int NextCity(struct ant *ants_d, int pos, float *distances_d, double *hormone_d, curandState *state_d ){
260 | 	int to, from;
261 | 	double denom = 0.0;
262 | 	from =  ants_d[pos].curCity;
263 | 
264 | 	for(to = 0; to < CITIES; to++){
265 | 	  if(ants_d[pos].visited[to] == 0){
266 | 		denom += antProduct(from, to, hormone_d, distances_d);
267 | 	  }
268 | 	}
269 | 
270 | 	assert(denom != 0.0);
271 | 
272 | 	to++;
273 | 	int count = CITIES - ants_d[pos].pathIndex;
274 | 
275 | 	do{
276 | 		double p;
277 | 		to++;
278 | 
279 | 		if(to >= CITIES)
280 | 			to = 0;
281 | 
282 | 		if(ants_d[pos].visited[to] == 0){
283 | 			p = (double) antProduct(from, to, hormone_d, distances_d)/denom;
284 | 			double x = (double)(curand(&state_d[pos]) % 1000000000)/1000000000.0;
285 | 			if(x < p){
286 | 				break;
287 | 			}
288 | 			count--;
289 | 			if(count == 0){
290 | 				break;
291 | 			}
292 | 		}
293 | 	}while(1);
294 | 
295 | 	return to;
296 | }
297 | 
298 | 


--------------------------------------------------------------------------------
/tsp-ant/map25.txt:
--------------------------------------------------------------------------------
  1 | 0 0 0.0
  2 | 0 1 20.3961
  3 | 0 2 40.1123
  4 | 0 3 12.53
  5 | 0 4 18.0278
  6 | 0 5 25.4951
  7 | 0 6 92.1141
  8 | 0 7 54.7083
  9 | 0 8 81.2158
 10 | 0 9 50.8035
 11 | 0 10 39.2938
 12 | 0 11 15.2315
 13 | 0 12 51.0784
 14 | 0 13 6.7082
 15 | 0 14 33.7343
 16 | 0 15 25.4951
 17 | 0 16 55.9017
 18 | 0 17 52.0
 19 | 0 18 57.0088
 20 | 0 19 53.2353
 21 | 0 20 19.2354
 22 | 0 21 50.1199
 23 | 0 22 62.2896
 24 | 0 23 60.8276
 25 | 0 24 78.7718
 26 | 1 0 20.3961
 27 | 1 1 0.0
 28 | 1 2 21.1896
 29 | 1 3 15.6525
 30 | 1 4 3.6056
 31 | 1 5 13.0384
 32 | 1 6 79.4796
 33 | 1 7 64.4438
 34 | 1 8 83.2586
 35 | 1 9 38.3275
 36 | 1 10 18.9737
 37 | 1 11 6.3246
 38 | 1 12 31.3847
 39 | 1 13 23.0868
 40 | 1 14 13.3417
 41 | 1 15 15.2971
 42 | 1 16 73.0821
 43 | 1 17 44.0
 44 | 1 18 68.6003
 45 | 1 19 70.214
 46 | 1 20 17.0294
 47 | 1 21 67.0522
 48 | 1 22 63.561
 49 | 1 23 74.4312
 50 | 1 24 88.3912
 51 | 2 0 40.1123
 52 | 2 1 21.1896
 53 | 2 2 0.0
 54 | 2 3 36.7696
 55 | 2 4 24.6982
 56 | 2 5 29.0
 57 | 2 6 81.4985
 58 | 2 7 84.4038
 59 | 2 8 99.0202
 60 | 2 9 45.1221
 61 | 2 10 13.1529
 62 | 2 11 27.5136
 63 | 2 12 24.0416
 64 | 2 13 43.9318
 65 | 2 14 12.2066
 66 | 2 15 31.8277
 67 | 2 16 94.255
 68 | 2 17 54.7814
 69 | 2 18 89.0449
 70 | 2 19 91.3947
 71 | 2 20 36.8917
 72 | 2 21 88.2326
 73 | 2 22 79.6304
 74 | 2 23 95.2943
 75 | 2 24 107.9352
 76 | 3 0 12.53
 77 | 3 1 15.6525
 78 | 3 2 36.7696
 79 | 3 3 0.0
 80 | 3 4 12.083
 81 | 3 5 14.3178
 82 | 3 6 79.6116
 83 | 3 7 49.5177
 84 | 3 8 71.8401
 85 | 3 9 38.4187
 86 | 3 10 32.0156
 87 | 3 11 9.434
 88 | 3 12 41.9762
 89 | 3 13 10.2956
 90 | 3 14 27.2947
 91 | 3 15 13.6015
 92 | 3 16 57.7235
 93 | 3 17 39.5601
 94 | 3 18 53.2635
 95 | 3 19 54.8179
 96 | 3 20 6.7082
 97 | 3 21 51.6624
 98 | 3 22 52.3927
 99 | 3 23 58.8303
100 | 3 24 73.6614
101 | 4 0 18.0278
102 | 4 1 3.6056
103 | 4 2 24.6982
104 | 4 3 12.083
105 | 4 4 0.0
106 | 4 5 11.1803
107 | 4 6 78.7909
108 | 4 7 60.8769
109 | 4 8 80.2309
110 | 4 9 37.3363
111 | 4 10 21.3776
112 | 4 11 3.0
113 | 4 12 33.1059
114 | 4 13 20.0
115 | 4 14 16.0312
116 | 4 15 13.0
117 | 4 16 69.6419
118 | 4 17 42.107
119 | 4 18 65.0
120 | 4 19 66.7608
121 | 4 20 13.6015
122 | 4 21 63.6003
123 | 4 22 60.5392
124 | 4 23 70.8308
125 | 4 24 84.8528
126 | 5 0 25.4951
127 | 5 1 13.0384
128 | 5 2 29.0
129 | 5 3 14.3178
130 | 5 4 11.1803
131 | 5 5 0.0
132 | 5 6 67.9779
133 | 5 7 55.7584
134 | 5 8 71.1196
135 | 5 9 26.4008
136 | 5 10 20.2485
137 | 5 11 12.083
138 | 5 12 28.1603
139 | 5 13 24.5967
140 | 5 14 17.2047
141 | 5 15 2.8284
142 | 5 16 69.4622
143 | 5 17 31.0161
144 | 5 18 60.8276
145 | 5 19 66.4831
146 | 5 20 10.0
147 | 5 21 63.3877
148 | 5 22 51.4782
149 | 5 23 67.7791
150 | 5 24 79.0253
151 | 6 0 92.1141
152 | 6 1 79.4796
153 | 6 2 81.4985
154 | 6 3 79.6116
155 | 6 4 78.7909
156 | 6 5 67.9779
157 | 6 6 0.0
158 | 6 7 83.006
159 | 6 8 63.0317
160 | 6 9 41.5933
161 | 6 10 68.884
162 | 6 11 80.0562
163 | 6 12 58.0345
164 | 6 13 88.8144
165 | 6 14 72.7805
166 | 6 15 67.1193
167 | 6 16 112.2943
168 | 6 17 41.7253
169 | 6 18 90.2497
170 | 6 19 109.6586
171 | 6 20 72.9452
172 | 6 21 107.5407
173 | 6 22 57.28
174 | 6 23 99.7246
175 | 6 24 92.7793
176 | 7 0 54.7083
177 | 7 1 64.4438
178 | 7 2 84.4038
179 | 7 3 49.5177
180 | 7 4 60.8769
181 | 7 5 55.7584
182 | 7 6 83.006
183 | 7 7 0.0
184 | 7 8 35.8469
185 | 7 9 58.3095
186 | 7 10 75.6637
187 | 7 11 58.6941
188 | 7 12 79.712
189 | 7 13 48.0208
190 | 7 14 72.9452
191 | 7 15 53.0
192 | 7 16 31.1127
193 | 7 17 48.0104
194 | 7 18 7.2801
195 | 7 19 29.0689
196 | 7 20 47.634
197 | 7 21 28.0179
198 | 7 22 26.6271
199 | 7 23 16.7631
200 | 7 24 24.2074
201 | 8 0 81.2158
202 | 8 1 83.2586
203 | 8 2 99.0202
204 | 8 3 71.8401
205 | 8 4 80.2309
206 | 8 5 71.1196
207 | 8 6 63.0317
208 | 8 7 35.8469
209 | 8 8 0.0
210 | 8 9 58.7963
211 | 8 10 87.2009
212 | 8 11 79.1202
213 | 8 12 85.5628
214 | 8 13 74.8131
215 | 8 14 86.8217
216 | 8 15 68.4251
217 | 8 16 65.7343
218 | 8 17 46.6905
219 | 8 18 40.8167
220 | 8 19 64.1405
221 | 8 20 67.0671
222 | 8 21 63.5295
223 | 8 22 19.6977
224 | 8 23 48.4149
225 | 8 24 32.2025
226 | 9 0 50.8035
227 | 9 1 38.3275
228 | 9 2 45.1221
229 | 9 3 38.4187
230 | 9 4 37.3363
231 | 9 5 26.4008
232 | 9 6 41.5933
233 | 9 7 58.3095
234 | 9 8 58.7963
235 | 9 9 0.0
236 | 9 10 32.0156
237 | 9 11 38.4838
238 | 9 12 27.0185
239 | 9 13 48.1041
240 | 9 14 34.1321
241 | 9 15 25.5539
242 | 9 16 81.5843
243 | 9 17 12.2066
244 | 9 18 65.123
245 | 9 19 78.6448
246 | 9 20 31.8904
247 | 9 21 75.9276
248 | 9 22 41.6773
249 | 9 23 74.0068
250 | 9 24 77.1622
251 | 10 0 39.2938
252 | 10 1 18.9737
253 | 10 2 13.1529
254 | 10 3 32.0156
255 | 10 4 21.3776
256 | 10 5 20.2485
257 | 10 6 68.884
258 | 10 7 75.6637
259 | 10 8 87.2009
260 | 10 9 32.0156
261 | 10 10 0.0
262 | 10 11 24.3311
263 | 10 12 13.4536
264 | 10 13 41.1947
265 | 10 14 5.831
266 | 10 15 22.8473
267 | 10 16 89.2693
268 | 10 17 42.0476
269 | 10 18 80.9568
270 | 10 19 86.3134
271 | 10 20 29.8329
272 | 10 21 83.1865
273 | 10 22 68.1175
274 | 10 23 88.0227
275 | 10 24 98.4733
276 | 11 0 15.2315
277 | 11 1 6.3246
278 | 11 2 27.5136
279 | 11 3 9.434
280 | 11 4 3.0
281 | 11 5 12.083
282 | 11 6 80.0562
283 | 11 7 58.6941
284 | 11 8 79.1202
285 | 11 9 38.4838
286 | 11 10 24.3311
287 | 11 11 0.0
288 | 11 12 35.8469
289 | 11 13 17.0
290 | 11 14 19.0263
291 | 11 15 13.3417
292 | 11 16 66.7608
293 | 11 17 42.4264
294 | 11 18 62.6259
295 | 11 19 63.8905
296 | 11 20 12.083
297 | 11 21 60.7289
298 | 11 22 59.4643
299 | 11 23 68.2642
300 | 11 24 82.7587
301 | 12 0 51.0784
302 | 12 1 31.3847
303 | 12 2 24.0416
304 | 12 3 41.9762
305 | 12 4 33.1059
306 | 12 5 28.1603
307 | 12 6 58.0345
308 | 12 7 79.712
309 | 12 8 85.5628
310 | 12 9 27.0185
311 | 12 10 13.4536
312 | 12 11 35.8469
313 | 12 12 0.0
314 | 12 13 51.923
315 | 12 14 19.105
316 | 12 15 30.0167
317 | 12 16 97.1288
318 | 12 17 38.8973
319 | 12 18 85.7263
320 | 12 19 94.1329
321 | 12 20 38.1182
322 | 12 21 91.0879
323 | 12 22 67.624
324 | 12 23 93.6216
325 | 12 24 101.0742
326 | 13 0 6.7082
327 | 13 1 23.0868
328 | 13 2 43.9318
329 | 13 3 10.2956
330 | 13 4 20.0
331 | 13 5 24.5967
332 | 13 6 88.8144
333 | 13 7 48.0208
334 | 13 8 74.8131
335 | 13 9 48.1041
336 | 13 10 41.1947
337 | 13 11 17.0
338 | 13 12 51.923
339 | 13 13 0.0
340 | 13 14 36.0139
341 | 13 15 23.8537
342 | 13 16 50.6952
343 | 13 17 47.8853
344 | 13 18 50.448
345 | 13 19 47.927
346 | 13 20 16.2788
347 | 13 21 44.7772
348 | 13 22 56.0803
349 | 13 23 54.5619
350 | 13 24 72.111
351 | 14 0 33.7343
352 | 14 1 13.3417
353 | 14 2 12.2066
354 | 14 3 27.2947
355 | 14 4 16.0312
356 | 14 5 17.2047
357 | 14 6 72.7805
358 | 14 7 72.9452
359 | 14 8 86.8217
360 | 14 9 34.1321
361 | 14 10 5.831
362 | 14 11 19.0263
363 | 14 12 19.105
364 | 14 13 36.0139
365 | 14 14 0.0
366 | 14 15 20.0
367 | 14 16 84.9294
368 | 14 17 43.0116
369 | 14 18 77.8974
370 | 14 19 82.0
371 | 14 20 26.0
372 | 14 21 78.8543
373 | 14 22 67.424
374 | 14 23 84.5813
375 | 14 24 96.2133
376 | 15 0 25.4951
377 | 15 1 15.2971
378 | 15 2 31.8277
379 | 15 3 13.6015
380 | 15 4 13.0
381 | 15 5 2.8284
382 | 15 6 67.1193
383 | 15 7 53.0
384 | 15 8 68.4251
385 | 15 9 25.5539
386 | 15 10 22.8473
387 | 15 11 13.3417
388 | 15 12 30.0167
389 | 15 13 23.8537
390 | 15 14 20.0
391 | 15 15 0.0
392 | 15 16 67.2681
393 | 15 17 29.1548
394 | 15 18 58.1378
395 | 15 19 64.2806
396 | 15 20 8.2462
397 | 15 21 61.2046
398 | 15 22 48.7647
399 | 15 23 65.192
400 | 15 24 76.2168
401 | 16 0 55.9017
402 | 16 1 73.0821
403 | 16 2 94.255
404 | 16 3 57.7235
405 | 16 4 69.6419
406 | 16 5 69.4622
407 | 16 6 112.2943
408 | 16 7 31.1127
409 | 16 8 65.7343
410 | 16 9 81.5843
411 | 16 10 89.2693
412 | 16 11 66.7608
413 | 16 12 97.1288
414 | 16 13 50.6952
415 | 16 14 84.9294
416 | 16 15 67.2681
417 | 16 16 0.0
418 | 16 17 73.6817
419 | 16 18 25.0
420 | 16 19 3.0
421 | 16 20 59.5399
422 | 16 21 6.0828
423 | 16 22 57.4891
424 | 16 23 18.0278
425 | 16 24 41.5933
426 | 17 0 52.0
427 | 17 1 44.0
428 | 17 2 54.7814
429 | 17 3 39.5601
430 | 17 4 42.107
431 | 17 5 31.0161
432 | 17 6 41.7253
433 | 17 7 48.0104
434 | 17 8 46.6905
435 | 17 9 12.2066
436 | 17 10 42.0476
437 | 17 11 42.4264
438 | 17 12 38.8973
439 | 17 13 47.8853
440 | 17 14 43.0116
441 | 17 15 29.1548
442 | 17 16 73.6817
443 | 17 17 0.0
444 | 17 18 55.0818
445 | 17 19 70.8378
446 | 17 20 32.8938
447 | 17 21 68.352
448 | 17 22 29.5296
449 | 17 23 64.2806
450 | 17 24 65.521
451 | 18 0 57.0088
452 | 18 1 68.6003
453 | 18 2 89.0449
454 | 18 3 53.2635
455 | 18 4 65.0
456 | 18 5 60.8276
457 | 18 6 90.2497
458 | 18 7 7.2801
459 | 18 8 40.8167
460 | 18 9 65.123
461 | 18 10 80.9568
462 | 18 11 62.6259
463 | 18 12 85.7263
464 | 18 13 50.448
465 | 18 14 77.8974
466 | 18 15 58.1378
467 | 18 16 25.0
468 | 18 17 55.0818
469 | 18 18 0.0
470 | 18 19 23.3238
471 | 18 20 52.1536
472 | 18 21 22.8473
473 | 18 22 33.6155
474 | 18 23 9.4868
475 | 18 24 22.4722
476 | 19 0 53.2353
477 | 19 1 70.214
478 | 19 2 91.3947
479 | 19 3 54.8179
480 | 19 4 66.7608
481 | 19 5 66.4831
482 | 19 6 109.6586
483 | 19 7 29.0689
484 | 19 8 64.1405
485 | 19 9 78.6448
486 | 19 10 86.3134
487 | 19 11 63.8905
488 | 19 12 94.1329
489 | 19 13 47.927
490 | 19 14 82.0
491 | 19 15 64.2806
492 | 19 16 3.0
493 | 19 17 70.8378
494 | 19 18 23.3238
495 | 19 19 0.0
496 | 19 20 56.5685
497 | 19 21 3.1623
498 | 19 22 55.2268
499 | 19 23 17.2627
500 | 19 24 41.1947
501 | 20 0 19.2354
502 | 20 1 17.0294
503 | 20 2 36.8917
504 | 20 3 6.7082
505 | 20 4 13.6015
506 | 20 5 10.0
507 | 20 6 72.9452
508 | 20 7 47.634
509 | 20 8 67.0671
510 | 20 9 31.8904
511 | 20 10 29.8329
512 | 20 11 12.083
513 | 20 12 38.1182
514 | 20 13 16.2788
515 | 20 14 26.0
516 | 20 15 8.2462
517 | 20 16 59.5399
518 | 20 17 32.8938
519 | 20 18 52.1536
520 | 20 19 56.5685
521 | 20 20 0.0
522 | 20 21 53.4603
523 | 20 22 47.4342
524 | 20 23 58.6003
525 | 20 24 71.4493
526 | 21 0 50.1199
527 | 21 1 67.0522
528 | 21 2 88.2326
529 | 21 3 51.6624
530 | 21 4 63.6003
531 | 21 5 63.3877
532 | 21 6 107.5407
533 | 21 7 28.0179
534 | 21 8 63.5295
535 | 21 9 75.9276
536 | 21 10 83.1865
537 | 21 11 60.7289
538 | 21 12 91.0879
539 | 21 13 44.7772
540 | 21 14 78.8543
541 | 21 15 61.2046
542 | 21 16 6.0828
543 | 21 17 68.352
544 | 21 18 22.8473
545 | 21 19 3.1623
546 | 21 20 53.4603
547 | 21 21 0.0
548 | 21 22 53.7401
549 | 21 23 18.0
550 | 21 24 42.0119
551 | 22 0 62.2896
552 | 22 1 63.561
553 | 22 2 79.6304
554 | 22 3 52.3927
555 | 22 4 60.5392
556 | 22 5 51.4782
557 | 22 6 57.28
558 | 22 7 26.6271
559 | 22 8 19.6977
560 | 22 9 41.6773
561 | 22 10 68.1175
562 | 22 11 59.4643
563 | 22 12 67.624
564 | 22 13 56.0803
565 | 22 14 67.424
566 | 22 15 48.7647
567 | 22 16 57.4891
568 | 22 17 29.5296
569 | 22 18 33.6155
570 | 22 19 55.2268
571 | 22 20 47.4342
572 | 22 21 53.7401
573 | 22 22 0.0
574 | 22 23 42.9418
575 | 22 24 37.2156
576 | 23 0 60.8276
577 | 23 1 74.4312
578 | 23 2 95.2943
579 | 23 3 58.8303
580 | 23 4 70.8308
581 | 23 5 67.7791
582 | 23 6 99.7246
583 | 23 7 16.7631
584 | 23 8 48.4149
585 | 23 9 74.0068
586 | 23 10 88.0227
587 | 23 11 68.2642
588 | 23 12 93.6216
589 | 23 13 54.5619
590 | 23 14 84.5813
591 | 23 15 65.192
592 | 23 16 18.0278
593 | 23 17 64.2806
594 | 23 18 9.4868
595 | 23 19 17.2627
596 | 23 20 58.6003
597 | 23 21 18.0
598 | 23 22 42.9418
599 | 23 23 0.0
600 | 23 24 24.0208
601 | 24 0 78.7718
602 | 24 1 88.3912
603 | 24 2 107.9352
604 | 24 3 73.6614
605 | 24 4 84.8528
606 | 24 5 79.0253
607 | 24 6 92.7793
608 | 24 7 24.2074
609 | 24 8 32.2025
610 | 24 9 77.1622
611 | 24 10 98.4733
612 | 24 11 82.7587
613 | 24 12 101.0742
614 | 24 13 72.111
615 | 24 14 96.2133
616 | 24 15 76.2168
617 | 24 16 41.5933
618 | 24 17 65.521
619 | 24 18 22.4722
620 | 24 19 41.1947
621 | 24 20 71.4493
622 | 24 21 42.0119
623 | 24 22 37.2156
624 | 24 23 24.0208
625 | 24 24 0.0
626 | 


--------------------------------------------------------------------------------
/tsp-ga/ga_gpu.cu:
--------------------------------------------------------------------------------
  1 | #include <iostream>
  2 | #include <algorithm>
  3 | 
  4 | // Program includes
  5 | #include "ga_gpu.h"
  6 | #include "common.h"
  7 | 
  8 | using namespace std;
  9 | 
 10 | bool checkForKernelError(const char *err_msg)
 11 | {
 12 | 	cudaError_t status = cudaGetLastError();
 13 | 	if (status != cudaSuccess)
 14 | 	{
 15 | 		cout << err_msg << cudaGetErrorString(status) << endl;
 16 | 		return true;
 17 | 	}
 18 | 	else
 19 | 	{
 20 | 		return false;
 21 | 	}
 22 | }
 23 | 
 24 | __device__ int getGlobalIdx_2D_1D()
 25 | {
 26 | 	int blockId  = blockIdx.y * gridDim.x + blockIdx.x;			 	
 27 | 	int threadId = blockId * blockDim.x + threadIdx.x; 
 28 | 	return threadId;
 29 | }
 30 | 
 31 | __device__ void crossover(World* old_pop, World* new_pop, int* sel_ix,  int* cross_loc, int tid)
 32 | {
 33 | 
 34 | 	// Copy elements from first parent up through crossover point
 35 | 	memcpy(new_pop[tid].cities, old_pop[sel_ix[2*tid]].cities,(cross_loc[tid] + 1) * sizeof(City));
 36 | 
 37 | 	// Add remaining elements from second parent to child, in order
 38 | 	int remaining = old_pop[tid].num_cities - cross_loc[tid] - 1;
 39 | 	int count     = 0;
 40 | 	for (int i=0; i<old_pop[tid].num_cities; i++)
 41 | 	{
 42 | 		bool in_child = false;
 43 | 		for (int j=0; j<=cross_loc[tid]; j++)     
 44 | 		{
 45 | 			// If the city is in the child, exit
 46 | 			if ((new_pop[tid].cities[j].x == old_pop[sel_ix[2 * tid + 1]].cities[i].x) &               
 47 | 				(new_pop[tid].cities[j].y == old_pop[sel_ix[2 * tid + 1]].cities[i].y))
 48 | 			{
 49 | 				in_child = true;
 50 | 				break;
 51 | 			}
 52 | 		}
 53 | 		if (!in_child)
 54 | 		{
 55 | 			count++;
 56 | 			memcpy(&new_pop[tid].cities[cross_loc[tid] + count],&old_pop[sel_ix[2 * tid + 1]].cities[i], sizeof(City));
 57 | 		}
 58 | 	
 59 | 		// Stop once all of the cities have been added
 60 | 		if (count == remaining) break;
 61 | 	}
 62 | }
 63 | 
 64 | __device__ void mutate(World* new_pop, int* mutate_loc, int tid)
 65 | {
 66 | 	// Swap the elements
 67 | 	City temp = *(new_pop[tid].cities + mutate_loc[2*tid]);
 68 | 	*(new_pop[tid].cities + mutate_loc[2*tid])   = *(new_pop[tid].cities + mutate_loc[2*tid+1]);
 69 | 	*(new_pop[tid].cities + mutate_loc[2*tid+1]) = temp;
 70 | }
 71 | 
 72 | __global__ void fitness_kernel(World* pop, int pop_size)
 73 | {
 74 | 	// Get the thread id
 75 | 	int tid = getGlobalIdx_2D_1D();
 76 | 	
 77 | 	// Evaluate if the thread is valid
 78 | 	if (tid < pop_size)
 79 | 	{
 80 | 		float distance = (float)0.0; // Total "normalized" "distance"
 81 | 		
 82 | 		// Calculate fitnesses using the fitness formula that will be explained in the reports
 83 | 		for (int i=0; i<pop[tid].num_cities-1; i++)
 84 | 			distance += (pop[tid].cities[i].x - pop[tid].cities[i + 1].x) * (pop[tid].cities[i].x - pop[tid].cities[i + 1].x)         
 85 | 				+ (pop[tid].cities[i].y - pop[tid].cities[i + 1].y)*(pop[tid].cities[i].y - pop[tid].cities[i + 1].y);
 86 | 		pop[tid].fitness = (pop[tid].width * pop[tid].height) / distance;
 87 | 	}
 88 | }
 89 | 
 90 | __global__ void fit_sum_kernel(World* pop, int pop_size, float* fit_sum)
 91 | {
 92 | 	int tid = getGlobalIdx_2D_1D();
 93 | 	
 94 | 	// Evaluate if the thread is valid
 95 | 	if (tid < pop_size)
 96 | 	{
 97 | 		// Sum of all fitness
 98 | 		float sum = (float)0.0;
 99 | 		
100 | 		// Calculate the partial sum
101 | 		for (int i=0; i<=tid; i++)
102 | 			sum += pop[i].fitness;
103 | 		pop[tid].fit_prob = sum;
104 | 
105 | 		if (tid == (pop_size - 1))	*fit_sum = sum;
106 | 	}
107 | }
108 | 
109 | __global__ void fit_prob_kernel(World* pop, int pop_size, float* fit_sum)
110 | {
111 | 	// Get the thread id
112 | 	int tid = getGlobalIdx_2D_1D();
113 | 
114 | 	// Evaluate if the thread is valid
115 | 	if (tid < pop_size)
116 | 		pop[tid].fit_prob /= *fit_sum;
117 | }
118 | 
119 | __global__ void max_fit_kernel(World* pop, int pop_size, World* gen_leader)
120 | {
121 | 	// Get the thread id
122 | 	int tid = getGlobalIdx_2D_1D();
123 | 
124 | 	// Evaluate if the thread is valid
125 | 	if (tid < pop_size)
126 | 	{
127 | 		if (tid == 0)
128 | 		{
129 | 			float max = (float)0.0;
130 | 			int ix  = 0;
131 | 			for (int i=1; i<pop_size; i++)
132 | 			{
133 | 				if (pop[i].fitness > max)
134 | 				{
135 | 					max = pop[i].fitness;
136 | 					ix  = i;
137 | 				}
138 | 			}
139 | 			gen_leader->cities  = pop[ix].cities;
140 | 			gen_leader->fitness = max;
141 | 		}
142 | 		else if (tid == 1)
143 | 		{
144 | 			gen_leader->height     = pop[0].height;
145 | 			gen_leader->width      = pop[0].width;
146 | 			gen_leader->num_cities = pop[0].num_cities;
147 | 		}
148 | 	}
149 | }
150 | 
151 | __global__ void selection_kernel(World* pop, int pop_size, float* rand_nums,  \
152 | 	int* sel_ix)
153 | {
154 | 	// Get the thread id
155 | 	int tid = getGlobalIdx_2D_1D();
156 | 
157 | 	// Evaluate if the thread is valid
158 | 	if (tid < (2 * pop_size))
159 | 	{
160 | 		// Select the parents
161 | 		for (int j=0; j<pop_size; j++)
162 | 		{
163 | 			if (rand_nums[tid] <= pop[j].fit_prob)
164 | 			{
165 | 				sel_ix[tid] = j;
166 | 				break;
167 | 			}
168 | 		}
169 | 	}
170 | }
171 | 
172 | __global__ void child_kernel(World* old_pop, World* new_pop, int pop_size,    \
173 | 	int* sel_ix, float prob_crossover, float* prob_cross, int* cross_loc,     \
174 | 	float prob_mutation, float* prob_mutate, int* mutate_loc)
175 | {
176 | 	// Get the thread id
177 | 	int tid = getGlobalIdx_2D_1D();
178 | 
179 | 	// Evaluate if the thread is valid
180 | 	if (tid < pop_size)
181 | 	{
182 | 		// Determine how many children are born
183 | 		if (prob_cross[tid] <= prob_crossover)
184 | 		{
185 | 			crossover(old_pop, new_pop, sel_ix, cross_loc, tid);
186 | 			if(prob_mutate[tid] <= prob_mutation)
187 | 				mutate(new_pop, mutate_loc, tid);
188 | 			
189 | 		}
190 | 		else // Select the first parent
191 | 		{
192 | 			// Add child to new population
193 | 			memcpy(new_pop[tid].cities, old_pop[sel_ix[2*tid]].cities, old_pop[tid].num_cities * sizeof(City));
194 | 			if(prob_mutate[tid] <= prob_mutation)
195 | 				mutate(new_pop, mutate_loc, tid);
196 | 		}
197 | 	}
198 | }
199 | 
200 | bool g_initialize(World* world, World* pop, int pop_size, int seed)
201 | {
202 | 	bool error;
203 | 	World h_world;
204 | 	h_world.cities = new City[world->num_cities * sizeof(City)];
205 | 	srand(seed);
206 | 	for (int i=0; i<pop_size; i++)
207 | 	{
208 | 		clone_world(world, &h_world);
209 | 		// Randomly adjust the path between cities
210 | 		random_shuffle(&h_world.cities[0], &h_world.cities[world->num_cities]);
211 | 		// Copy world to device
212 | 		error = g_soft_clone_world(&pop[i], &h_world);
213 | 		if (error)
214 | 		return true;
215 | 
216 | 		// Allocate space for cities on device
217 | 		City *d_city;
218 | 		error = checkForError(cudaMalloc((void**)&d_city, world->num_cities * sizeof(City)));
219 | 		if (error)
220 | 		return true;
221 | 
222 | 		// Copy cities to device
223 | 		error = checkForError(cudaMemcpy(d_city, h_world.cities,world->num_cities * sizeof(City), cudaMemcpyHostToDevice));
224 | 		if (error)
225 | 		return true;
226 | 
227 | 		// Update pointer on device
228 | 		error = checkForError(cudaMemcpy(&pop[i].cities, &d_city, sizeof(City*), cudaMemcpyHostToDevice));
229 | 		if (error)
230 | 		return true;
231 | 	}
232 | 
233 | 	// Success
234 | 	delete[] h_world.cities; return false;
235 | }
236 | 
237 | bool g_evaluate(World *pop, int pop_size, dim3 Block, dim3 Grid)
238 | {
239 | 	bool error;
240 | 	
241 | 	// Allocate fitness sum on the GPU
242 | 	float *fit_sum_d;
243 | 	error = checkForError(cudaMalloc((void**)&fit_sum_d, sizeof(float)));
244 | 	if (error)
245 | 	return true;
246 | 	
247 | 	// Calculate the fitnesses
248 | 	fitness_kernel <<< Grid, Block >>> (pop, pop_size);
249 | 	cudaDeviceSynchronize();
250 | 	if (checkForKernelError("fitness_kernel is failing "))
251 | 		return true;
252 | 	// Calculate the total sum and compute the partial probabilities
253 | 	fit_sum_kernel <<< Grid, Block >>> (pop, pop_size, fit_sum_d);
254 | 	cudaDeviceSynchronize();
255 | 	if (checkForKernelError("fit_sum_kernel failing "))
256 | 		return true;
257 | 
258 | 	// Compute the full probabilities
259 | 	fit_prob_kernel <<< Grid, Block >>> (pop, pop_size, fit_sum_d);
260 | 	cudaDeviceSynchronize();
261 | 	if (checkForKernelError("fit_prob_kernel failing "))
262 | 		return true;
263 | 
264 | 	cudaFree(fit_sum_d); 
265 | 	return false;
266 | }
267 | 
268 | int g_select_leader(World* pop, int pop_size, World* generation_leader,
269 | 	World* best_leader, dim3 Block, dim3 Grid)
270 | {
271 | 	// Error handling
272 | 	bool error;
273 | 
274 | 	// Initialize world for device generation leader
275 | 	World *gen_leader_d;
276 | 	error = checkForError(cudaMalloc((void**)&gen_leader_d, sizeof(World)));
277 | 	if (error)
278 | 	return -1;
279 | 	// Purposely don't allocate space for the cities, simply use a pointer.
280 | 	// Since we only need to copy data to cpu 
281 | 	error = g_soft_clone_world(gen_leader_d, generation_leader);
282 | 	if (error)
283 | 	return -1;
284 | 
285 | 	// Calculate the max fitness
286 | 	max_fit_kernel <<< Grid, Block >>> (pop, pop_size, gen_leader_d);
287 | 	cudaDeviceSynchronize();
288 | 	if (checkForKernelError("*** Max fitness kernel failed: "))
289 | 	return -1;
290 | 
291 | 	// Copy results from device
292 | 	City *h_ptr = generation_leader->cities;
293 | 	City *d_ptr;
294 | 	error = checkForError(cudaMemcpy(generation_leader, gen_leader_d, sizeof(World), cudaMemcpyDeviceToHost));
295 | 	if (error)
296 | 	return -1;
297 | 	d_ptr = generation_leader->cities;
298 | 	generation_leader->cities = h_ptr;
299 | 	error = checkForError(cudaMemcpy(generation_leader->cities,  d_ptr, generation_leader->num_cities * sizeof(City), cudaMemcpyDeviceToHost));
300 | 	if (error)
301 | 	return -1;
302 | 
303 | 	// Update best leader
304 | 	if (generation_leader->fitness > best_leader->fitness)
305 | 	{
306 | 		clone_world(generation_leader, best_leader);
307 | 		cudaFree(gen_leader_d); return 1;
308 | 	}
309 | 
310 | 	// Success
311 | 	cudaFree(gen_leader_d);	return 0;
312 | }
313 | 
314 | bool g_execute(float prob_mutation, float prob_crossover, int pop_size,
315 | 	int max_gen, World* world, int seed)
316 | {
317 | 	cudaSetDevice(2);
318 | 	// Error checking variables
319 | 	bool error;
320 | 	
321 | 	// Random number generation
322 | 	mt19937::result_type rseed = seed;
323 | 	auto rgen = bind(uniform_real_distribution<>(0, 1), mt19937(rseed));
324 | 	
325 | 	// Tile and grid variables
326 | 	int tile_size  = 1024;
327 | 	int grid_size  = (int)ceil((float)pop_size / tile_size);
328 | 	int grid_size2 = (int)ceil((float)(2 * pop_size) / tile_size);
329 | 	dim3 Block(tile_size);
330 | 	dim3 Grid(grid_size, grid_size);
331 | 	dim3 Grid2(grid_size2, grid_size2);
332 | 	
333 | 	int pop_bytes  = pop_size * sizeof(World);
334 | 	World *old_pop_d, *new_pop_d;
335 | 
336 | 	// Random numbers
337 | 	float *prob_select = new float[2 * pop_size * sizeof(float)];
338 | 	float *prob_cross  = new float[pop_size * sizeof(float)];
339 | 	float *prob_mutate = new float[pop_size * sizeof(float)];
340 | 	int   *cross_loc   = new int[pop_size * sizeof(int)];
341 | 	int   *mutate_loc  = new int[2 * pop_size * sizeof(int)];
342 | 	float *prob_select_d, *prob_cross_d, *prob_mutate_d;
343 | 	int   *cross_loc_d, *mutate_loc_d;
344 | 	
345 | 	int   sel;
346 | 	int   best_generation    = 0;
347 | 	World *best_leader       = new World[sizeof(World)];
348 | 	World *generation_leader = new World[sizeof(World)];
349 | 
350 | 	// Other "temporary" parameters
351 | 	int *sel_ix_d;
352 | 
353 | 	//Initializations
354 | 	init_world(best_leader, world->width, world->height, world->num_cities);
355 | 	init_world(generation_leader, world->width, world->height, world->num_cities);
356 | 	if (checkForError(cudaMalloc((void**) &old_pop_d, pop_bytes)))
357 | 	return true;
358 | 	if (checkForError(cudaMalloc((void**) &new_pop_d, pop_bytes)))
359 | 	return true;
360 | 	if (checkForError(cudaMalloc((void**) &prob_select_d, sizeof(float)* 2 * pop_size)))
361 | 	return true;
362 | 	if (checkForError(cudaMalloc((void**) &prob_cross_d, sizeof(float) * pop_size)))
363 | 	return true;
364 | 	if (checkForError(cudaMalloc((void**) &prob_mutate_d, sizeof(float) * pop_size)))
365 | 	return true;
366 | 	if (checkForError(cudaMalloc((void**) &cross_loc_d, sizeof(int) * pop_size)))
367 | 	return true;
368 | 	if (checkForError(cudaMalloc((void**) &mutate_loc_d, sizeof(int) * 2 * pop_size)))
369 | 	return true;
370 | 	// Other parameters
371 | 	if (checkForError(cudaMalloc((void**) &sel_ix_d, sizeof(int) * 2 * pop_size)))
372 | 	return true;
373 | 
374 | 	///////// GPU Initializations
375 | 	// Populations
376 | 	error = g_initialize(world, old_pop_d, pop_size, seed);
377 | 	if (error)
378 | 	return true;
379 | 	for (int i=0; i<pop_size; i++)
380 | 	{
381 | 		error = g_init_world(&new_pop_d[i], world);
382 | 		if (error)
383 | 		return true;
384 | 	}
385 | 
386 | 	// Calculate the fitnesses
387 | 	error = g_evaluate(old_pop_d, pop_size, Block, Grid);
388 | 	if (error)
389 | 	return true;
390 | 	
391 | 	// Initialize the best leader
392 | 	sel = g_select_leader(old_pop_d, pop_size, generation_leader,             \
393 | 		best_leader, Block, Grid);	
394 | 	if (-1 == sel)
395 | 	return true;	
396 | 	print_status(generation_leader, best_leader, 0);
397 | 		
398 | 	// Continue through all generations
399 | 	for (int i=0; i<max_gen; i++)
400 | 	{
401 | 
402 | 		// Generate all probabilities for each step
403 | 		// Note : The order the random numbers are generated must be consistent to
404 | 		// ensure the results will match the CPU.
405 | 		for (int j=0; j<pop_size; j++)
406 | 		{
407 | 			prob_select[2*j]     = (float)rgen();
408 | 			prob_select[2*j + 1] = (float)rgen();
409 | 			prob_cross[j]        = (float)rgen();
410 | 			cross_loc[j]         = (int)(rgen() * (world->num_cities - 1));
411 | 			prob_mutate[j]       = (float)rgen();
412 | 			mutate_loc[2*j]      = (int)(rgen() * (world->num_cities));
413 | 			mutate_loc[2*j + 1]  = (int)(rgen() * (world->num_cities));
414 | 			while (mutate_loc[2*j + 1] == mutate_loc[2*j])
415 | 			{
416 | 				mutate_loc[2*j + 1] = (int)(rgen() * world->num_cities);
417 | 			}
418 | 		}
419 | 		
420 | 		// Copy random numbers to device
421 | 		if (checkForError(cudaMemcpy(prob_select_d, prob_select, 2 * pop_size * sizeof(float), cudaMemcpyHostToDevice)))
422 | 		return true;
423 | 		if (checkForError(cudaMemcpy(prob_cross_d, prob_cross, pop_size * sizeof(float), cudaMemcpyHostToDevice)))
424 | 		return true;
425 | 		if (checkForError(cudaMemcpy(prob_mutate_d, prob_mutate,pop_size * sizeof(float), cudaMemcpyHostToDevice)))
426 | 		return true;
427 | 		if (checkForError(cudaMemcpy(cross_loc_d, cross_loc,pop_size * sizeof(int), cudaMemcpyHostToDevice)))
428 | 		return true;
429 | 		if (checkForError(cudaMemcpy(mutate_loc_d, mutate_loc, 2 * pop_size * sizeof(int), cudaMemcpyHostToDevice)))
430 | 		return true;
431 | 
432 | 		// Select the parents
433 | 		selection_kernel <<< Grid2, Block >>> (old_pop_d, pop_size, prob_select_d, sel_ix_d);
434 | 		cudaDeviceSynchronize();
435 | 		if (checkForKernelError("slection_kernel is failing "))
436 | 		return true;
437 | 		
438 | 		// Create the children (form the new population entirely on the GPU!)
439 | 		child_kernel <<< Grid, Block >>> (old_pop_d, new_pop_d, pop_size, sel_ix_d, prob_crossover, prob_cross_d, cross_loc_d, prob_mutation, prob_mutate_d, mutate_loc_d);
440 | 		cudaDeviceSynchronize();
441 | 		if (checkForKernelError("child_kernel is failing"))
442 | 		return true;
443 | 		
444 | 		// Calculate the fitnesses on the new population
445 | 		error = g_evaluate(new_pop_d, pop_size, Block, Grid);
446 | 		if (error)
447 | 		return true;	
448 | 
449 | 		// Swap the populations
450 | 		World* temp_d = old_pop_d;
451 | 		old_pop_d     = new_pop_d;
452 | 		new_pop_d     = temp_d;
453 | 
454 | 		// Select the new leaders
455 | 		sel = g_select_leader(old_pop_d, pop_size, generation_leader,best_leader, Block, Grid);
456 | 		if (-1 == sel)
457 | 		return true;
458 | 		else if (1 == sel) best_generation = i + 1;
459 | 		print_status(generation_leader, best_leader, i + 1);
460 | 	} 
461 | 	
462 | 	cout << endl << "Best generation found at " << best_generation << " generations" << endl;
463 | 
464 | 	//freeing memory
465 | 	delete[] prob_select; delete[] prob_cross; delete[] prob_mutate;
466 | 	delete[] cross_loc; delete[] mutate_loc; free_world(best_leader);
467 | 	free_world(generation_leader); cudaFree(old_pop_d); cudaFree(cross_loc_d); 
468 | 	cudaFree(new_pop_d); cudaFree(prob_select_d); cudaFree(prob_cross_d);
469 | 	cudaFree(prob_mutate_d); cudaFree(mutate_loc_d); cudaFree(sel_ix_d);	
470 | 	return false;
471 | }


--------------------------------------------------------------------------------
/tsp-ant/map50.txt:
--------------------------------------------------------------------------------
   1 | 0 0 0.0
   2 | 0 1 64.1405
   3 | 0 2 28.6007
   4 | 0 3 66.7083
   5 | 0 4 48.6621
   6 | 0 5 36.2215
   7 | 0 6 79.1202
   8 | 0 7 18.3576
   9 | 0 8 6.0828
  10 | 0 9 41.5933
  11 | 0 10 36.6879
  12 | 0 11 20.2485
  13 | 0 12 83.006
  14 | 0 13 61.0983
  15 | 0 14 78.4092
  16 | 0 15 53.8516
  17 | 0 16 37.1618
  18 | 0 17 63.561
  19 | 0 18 79.0569
  20 | 0 19 27.4591
  21 | 0 20 30.8058
  22 | 0 21 23.3238
  23 | 0 22 43.4166
  24 | 0 23 38.4708
  25 | 0 24 75.0267
  26 | 0 25 38.0132
  27 | 0 26 29.8329
  28 | 0 27 94.0319
  29 | 0 28 20.3961
  30 | 0 29 76.2955
  31 | 0 30 82.6378
  32 | 0 31 28.3196
  33 | 0 32 51.5461
  34 | 0 33 37.1214
  35 | 0 34 85.4225
  36 | 0 35 18.9737
  37 | 0 36 32.8938
  38 | 0 37 22.8254
  39 | 0 38 89.6939
  40 | 0 39 67.0522
  41 | 0 40 37.6431
  42 | 0 41 10.198
  43 | 0 42 52.6972
  44 | 0 43 47.5395
  45 | 0 44 44.9444
  46 | 0 45 32.0156
  47 | 0 46 28.6356
  48 | 0 47 24.0416
  49 | 0 48 34.3657
  50 | 0 49 18.1108
  51 | 1 0 64.1405
  52 | 1 1 0.0
  53 | 1 2 91.214
  54 | 1 3 76.1052
  55 | 1 4 64.7611
  56 | 1 5 34.6699
  57 | 1 6 19.6469
  58 | 1 7 74.9466
  59 | 1 8 68.884
  60 | 1 9 78.7147
  61 | 1 10 66.0303
  62 | 1 11 84.119
  63 | 1 12 22.0907
  64 | 1 13 55.0364
  65 | 1 14 33.9706
  66 | 1 15 45.1885
  67 | 1 16 52.3927
  68 | 1 17 47.5184
  69 | 1 18 15.6205
  70 | 1 19 41.2311
  71 | 1 20 37.855
  72 | 1 21 68.2495
  73 | 1 22 66.6108
  74 | 1 23 93.6056
  75 | 1 24 36.8917
  76 | 1 25 38.0132
  77 | 1 26 62.1289
  78 | 1 27 30.0
  79 | 1 28 73.5527
  80 | 1 29 27.5862
  81 | 1 30 22.2036
  82 | 1 31 64.8999
  83 | 1 32 42.1545
  84 | 1 33 34.9857
  85 | 1 34 75.0
  86 | 1 35 79.511
  87 | 1 36 66.0303
  88 | 1 37 45.8803
  89 | 1 38 25.5539
  90 | 1 39 15.8114
  91 | 1 40 44.1022
  92 | 1 41 57.0088
  93 | 1 42 81.2712
  94 | 1 43 38.6005
  95 | 1 44 59.4811
  96 | 1 45 34.6554
  97 | 1 46 49.2544
  98 | 1 47 83.5464
  99 | 1 48 35.0
 100 | 1 49 73.5527
 101 | 2 0 28.6007
 102 | 2 1 91.214
 103 | 2 2 0.0
 104 | 2 3 70.8802
 105 | 2 4 71.5681
 106 | 2 5 59.4811
 107 | 2 6 104.3168
 108 | 2 7 32.0156
 109 | 2 8 26.4008
 110 | 2 9 38.6264
 111 | 2 10 58.3095
 112 | 2 11 16.1245
 113 | 2 12 108.4066
 114 | 2 13 74.0068
 115 | 2 14 99.93
 116 | 2 15 81.1542
 117 | 2 16 51.6236
 118 | 2 17 79.511
 119 | 2 18 106.527
 120 | 2 19 56.0357
 121 | 2 20 59.4054
 122 | 2 21 29.1548
 123 | 2 22 65.2763
 124 | 2 23 18.6011
 125 | 2 24 95.3362
 126 | 2 25 59.2368
 127 | 2 26 52.9528
 128 | 2 27 121.2106
 129 | 2 28 21.2132
 130 | 2 29 99.1615
 131 | 2 30 107.912
 132 | 2 31 36.0555
 133 | 2 32 79.2023
 134 | 2 33 59.9333
 135 | 2 34 94.3663
 136 | 2 35 12.083
 137 | 2 36 54.3323
 138 | 2 37 51.3128
 139 | 2 38 116.6062
 140 | 2 39 91.7061
 141 | 2 40 65.307
 142 | 2 41 34.2053
 143 | 2 42 50.5668
 144 | 2 43 75.591
 145 | 2 44 55.0091
 146 | 2 45 57.1402
 147 | 2 46 55.9464
 148 | 2 47 10.0
 149 | 2 48 58.1808
 150 | 2 49 19.6469
 151 | 3 0 66.7083
 152 | 3 1 76.1052
 153 | 3 2 70.8802
 154 | 3 3 0.0
 155 | 3 4 108.4528
 156 | 3 5 49.3356
 157 | 3 6 74.6324
 158 | 3 7 84.8116
 159 | 3 8 72.0069
 160 | 3 9 32.5576
 161 | 3 10 99.6393
 162 | 3 11 78.7147
 163 | 3 12 78.4347
 164 | 3 13 21.8403
 165 | 3 14 57.7062
 166 | 3 15 101.951
 167 | 3 16 32.7567
 168 | 3 17 31.0161
 169 | 3 18 89.1067
 170 | 3 19 75.1798
 171 | 3 20 75.5844
 172 | 3 21 45.2769
 173 | 3 22 105.2093
 174 | 3 23 57.2189
 175 | 3 24 51.0
 176 | 3 25 43.9659
 177 | 3 26 92.4554
 178 | 3 27 98.0816
 179 | 3 28 52.3259
 180 | 3 29 61.8466
 181 | 3 30 77.4919
 182 | 3 31 38.833
 183 | 3 32 98.4327
 184 | 3 33 48.0833
 185 | 3 34 25.318
 186 | 3 35 62.2415
 187 | 3 36 96.5401
 188 | 3 37 74.6257
 189 | 3 38 92.72
 190 | 3 39 64.3273
 191 | 3 40 88.5494
 192 | 3 41 57.9828
 193 | 3 42 22.0227
 194 | 3 43 93.0484
 195 | 3 44 23.0217
 196 | 3 45 54.7814
 197 | 3 46 84.0595
 198 | 3 47 61.3514
 199 | 3 48 50.9215
 200 | 3 49 55.0091
 201 | 4 0 48.6621
 202 | 4 1 64.7611
 203 | 4 2 71.5681
 204 | 4 3 108.4528
 205 | 4 4 0.0
 206 | 4 5 62.2254
 207 | 4 6 84.4038
 208 | 4 7 39.8121
 209 | 4 8 47.0425
 210 | 4 9 89.1852
 211 | 4 10 13.3417
 212 | 4 11 56.0892
 213 | 4 12 86.6833
 214 | 4 13 95.5249
 215 | 4 14 94.8472
 216 | 4 15 22.3607
 217 | 4 16 75.7166
 218 | 4 17 93.5094
 219 | 4 18 73.0616
 220 | 4 19 33.9706
 221 | 4 20 34.7131
 222 | 4 21 70.8802
 223 | 4 22 6.7082
 224 | 4 23 86.0233
 225 | 4 24 94.8947
 226 | 4 25 67.2086
 227 | 4 26 19.0263
 228 | 4 27 87.0517
 229 | 4 28 69.0507
 230 | 4 29 89.6939
 231 | 4 30 86.885
 232 | 4 31 74.0945
 233 | 4 32 24.0208
 234 | 4 33 63.6396
 235 | 4 34 120.9339
 236 | 4 35 66.0303
 237 | 4 36 17.2627
 238 | 4 37 33.8378
 239 | 4 38 85.0235
 240 | 4 39 77.2528
 241 | 4 40 22.4722
 242 | 4 41 53.1413
 243 | 4 42 99.1615
 244 | 4 43 26.3059
 245 | 4 44 85.44
 246 | 4 45 55.8659
 247 | 4 46 24.4131
 248 | 4 47 71.007
 249 | 4 48 60.1082
 250 | 4 49 66.7533
 251 | 5 0 36.2215
 252 | 5 1 34.6699
 253 | 5 2 59.4811
 254 | 5 3 49.3356
 255 | 5 4 62.2254
 256 | 5 5 0.0
 257 | 5 6 44.9444
 258 | 5 7 52.2398
 259 | 5 8 42.107
 260 | 5 9 44.3847
 261 | 5 10 56.3028
 262 | 5 11 56.0892
 263 | 5 12 49.0918
 264 | 5 13 33.4215
 265 | 5 14 42.19
 266 | 5 15 52.8015
 267 | 5 16 19.105
 268 | 5 17 31.6228
 269 | 5 18 50.2195
 270 | 5 19 28.3196
 271 | 5 20 27.6586
 272 | 5 21 33.9411
 273 | 5 22 60.4401
 274 | 5 23 59.397
 275 | 5 24 39.0512
 276 | 5 25 5.3852
 277 | 5 26 49.7393
 278 | 5 27 63.7024
 279 | 5 28 40.0
 280 | 5 29 40.2616
 281 | 5 30 48.5489
 282 | 5 31 30.2324
 283 | 5 32 49.2443
 284 | 5 33 1.4142
 285 | 5 34 58.7282
 286 | 5 35 47.4131
 287 | 5 36 54.2033
 288 | 5 37 29.6816
 289 | 5 38 58.6941
 290 | 5 39 32.249
 291 | 5 40 40.6079
 292 | 5 41 26.6833
 293 | 5 42 48.5077
 294 | 5 43 43.8634
 295 | 5 44 28.0713
 296 | 5 45 6.4031
 297 | 5 46 38.4187
 298 | 5 47 50.774
 299 | 5 48 2.2361
 300 | 5 49 40.4969
 301 | 6 0 79.1202
 302 | 6 1 19.6469
 303 | 6 2 104.3168
 304 | 6 3 74.6324
 305 | 6 4 84.4038
 306 | 6 5 44.9444
 307 | 6 6 0.0
 308 | 6 7 91.9837
 309 | 6 8 84.4334
 310 | 6 9 85.1469
 311 | 6 10 85.2877
 312 | 6 11 99.368
 313 | 6 12 4.2426
 314 | 6 13 52.811
 315 | 6 14 20.3961
 316 | 6 15 64.622
 317 | 6 16 58.7282
 318 | 6 17 43.6807
 319 | 6 18 19.2354
 320 | 6 19 59.2115
 321 | 6 20 56.0803
 322 | 6 21 78.4092
 323 | 6 22 86.1452
 324 | 6 23 103.7111
 325 | 6 24 26.0192
 326 | 6 25 46.2277
 327 | 6 26 81.0062
 328 | 6 27 23.5372
 329 | 6 28 84.8764
 330 | 6 29 14.0357
 331 | 6 30 3.6056
 332 | 6 31 73.6614
 333 | 6 32 61.6847
 334 | 6 33 44.6542
 335 | 6 34 67.0298
 336 | 6 35 92.2822
 337 | 6 36 85.0529
 338 | 6 37 63.5059
 339 | 6 38 18.2483
 340 | 6 39 12.8062
 341 | 6 40 63.5059
 342 | 6 41 70.6824
 343 | 6 42 84.9058
 344 | 6 43 58.2409
 345 | 6 44 63.2456
 346 | 6 45 47.4236
 347 | 6 46 68.0
 348 | 6 47 95.7183
 349 | 6 48 46.1411
 350 | 6 49 85.44
 351 | 7 0 18.3576
 352 | 7 1 74.9466
 353 | 7 2 32.0156
 354 | 7 3 84.8116
 355 | 7 4 39.8121
 356 | 7 5 52.2398
 357 | 7 6 91.9837
 358 | 7 7 0.0
 359 | 7 8 12.8062
 360 | 7 9 57.8014
 361 | 7 10 26.4764
 362 | 7 11 16.2788
 363 | 7 12 95.5667
 364 | 7 13 79.3095
 365 | 7 14 94.0053
 366 | 7 15 52.4309
 367 | 7 16 55.4617
 368 | 7 17 81.3204
 369 | 7 18 88.6397
 370 | 7 19 34.0147
 371 | 7 20 37.5766
 372 | 7 21 40.3113
 373 | 7 22 33.3766
 374 | 7 23 48.0521
 375 | 7 24 91.2688
 376 | 7 25 54.9181
 377 | 7 26 21.9317
 378 | 7 27 103.8701
 379 | 7 28 35.2278
 380 | 7 29 91.1373
 381 | 7 30 95.3415
 382 | 7 31 46.0977
 383 | 7 32 51.225
 384 | 7 33 53.3385
 385 | 7 34 103.769
 386 | 7 35 28.7924
 387 | 7 36 22.561
 388 | 7 37 29.1548
 389 | 7 38 100.09
 390 | 7 39 80.7527
 391 | 7 40 38.1838
 392 | 7 41 28.2312
 393 | 7 42 69.527
 394 | 7 43 48.7955
 395 | 7 44 63.2851
 396 | 7 45 47.0106
 397 | 7 46 29.0689
 398 | 7 47 33.2415
 399 | 7 48 50.1597
 400 | 7 49 32.45
 401 | 8 0 6.0828
 402 | 8 1 68.884
 403 | 8 2 26.4008
 404 | 8 3 72.0069
 405 | 8 4 47.0425
 406 | 8 5 42.107
 407 | 8 6 84.4334
 408 | 8 7 12.8062
 409 | 8 8 0.0
 410 | 8 9 45.4863
 411 | 8 10 34.3657
 412 | 8 11 15.2643
 413 | 8 12 88.2553
 414 | 8 13 67.0671
 415 | 8 14 84.2912
 416 | 8 15 54.7814
 417 | 8 16 43.0813
 418 | 8 17 69.6348
 419 | 8 18 83.5284
 420 | 8 19 30.4138
 421 | 8 20 33.9411
 422 | 8 21 27.6586
 423 | 8 22 41.3038
 424 | 8 23 39.0
 425 | 8 24 81.0062
 426 | 8 25 44.0454
 427 | 8 26 28.0179
 428 | 8 27 98.6154
 429 | 8 28 23.2594
 430 | 8 29 82.0366
 431 | 8 30 87.9204
 432 | 8 31 33.3017
 433 | 8 32 52.8015
 434 | 8 33 43.0465
 435 | 8 34 91.236
 436 | 8 35 19.0
 437 | 8 36 30.4138
 438 | 8 37 25.4951
 439 | 8 38 94.414
 440 | 8 39 72.5328
 441 | 8 40 38.9102
 442 | 8 41 16.2788
 443 | 8 42 57.0088
 444 | 8 43 49.2443
 445 | 8 44 50.6063
 446 | 8 45 37.6563
 447 | 8 46 29.5466
 448 | 8 47 24.0208
 449 | 8 48 40.1995
 450 | 8 49 20.6155
 451 | 9 0 41.5933
 452 | 9 1 78.7147
 453 | 9 2 38.6264
 454 | 9 3 32.5576
 455 | 9 4 89.1852
 456 | 9 5 44.3847
 457 | 9 6 85.1469
 458 | 9 7 57.8014
 459 | 9 8 45.4863
 460 | 9 9 0.0
 461 | 9 10 78.0
 462 | 9 11 48.4149
 463 | 9 12 89.3756
 464 | 9 13 40.8534
 465 | 9 14 74.2024
 466 | 9 15 89.1403
 467 | 9 16 26.6271
 468 | 9 17 48.7647
 469 | 9 18 94.0213
 470 | 9 19 60.1332
 471 | 9 20 62.0081
 472 | 9 21 18.3848
 473 | 9 22 84.5044
 474 | 9 23 25.02
 475 | 9 24 68.2422
 476 | 9 25 40.7063
 477 | 9 26 70.9366
 478 | 9 27 106.5082
 479 | 9 28 22.6716
 480 | 9 29 75.743
 481 | 9 30 88.6172
 482 | 9 31 16.0
 483 | 9 32 86.0523
 484 | 9 33 43.8634
 485 | 9 34 57.0351
 486 | 9 35 31.4006
 487 | 9 36 74.3236
 488 | 9 37 57.5587
 489 | 9 38 101.2571
 490 | 9 39 72.6223
 491 | 9 40 73.437
 492 | 9 41 36.1386
 493 | 9 42 12.2066
 494 | 9 43 81.0062
 495 | 9 44 23.0217
 496 | 9 45 46.5725
 497 | 9 46 66.2873
 498 | 9 47 29.5296
 499 | 9 48 44.5982
 500 | 9 49 25.4951
 501 | 10 0 36.6879
 502 | 10 1 66.0303
 503 | 10 2 58.3095
 504 | 10 3 99.6393
 505 | 10 4 13.3417
 506 | 10 5 56.3028
 507 | 10 6 85.2877
 508 | 10 7 26.4764
 509 | 10 8 34.3657
 510 | 10 9 78.0
 511 | 10 10 0.0
 512 | 10 11 42.7551
 513 | 10 12 88.0909
 514 | 10 13 88.7299
 515 | 10 14 93.0054
 516 | 10 15 30.2324
 517 | 10 16 67.2681
 518 | 10 17 87.9204
 519 | 10 18 76.6551
 520 | 10 19 28.6356
 521 | 10 20 30.6757
 522 | 10 21 59.6154
 523 | 10 22 7.0
 524 | 10 23 73.171
 525 | 10 24 92.1141
 526 | 10 25 60.803
 527 | 10 26 7.2111
 528 | 10 27 91.4112
 529 | 10 28 57.0088
 530 | 10 29 88.5268
 531 | 10 30 88.1419
 532 | 10 31 63.5295
 533 | 10 32 30.4138
 534 | 10 33 57.6888
 535 | 10 34 114.2147
 536 | 10 35 53.2353
 537 | 10 36 4.0
 538 | 10 37 26.6271
 539 | 10 38 88.6848
 540 | 10 39 76.4853
 541 | 10 40 22.0227
 542 | 10 41 42.5441
 543 | 10 42 88.5494
 544 | 10 43 30.3645
 545 | 10 44 76.6942
 546 | 10 45 49.93
 547 | 10 46 18.3848
 548 | 10 47 58.1378
 549 | 10 48 54.0833
 550 | 10 49 54.5711
 551 | 11 0 20.2485
 552 | 11 1 84.119
 553 | 11 2 16.1245
 554 | 11 3 78.7147
 555 | 11 4 56.0892
 556 | 11 5 56.0892
 557 | 11 6 99.368
 558 | 11 7 16.2788
 559 | 11 8 15.2643
 560 | 11 9 48.4149
 561 | 11 10 42.7551
 562 | 11 11 0.0
 563 | 11 12 103.2473
 564 | 11 13 77.4661
 565 | 11 14 98.1529
 566 | 11 15 67.6018
 567 | 11 16 53.6004
 568 | 11 17 81.3019
 569 | 11 18 98.7927
 570 | 11 19 45.3431
 571 | 11 20 48.9183
 572 | 11 21 33.6155
 573 | 11 22 49.6488
 574 | 11 23 33.6155
 575 | 11 24 94.4299
 576 | 11 25 57.3149
 577 | 11 26 37.9473
 578 | 11 27 113.8771
 579 | 11 28 26.4197
 580 | 11 29 96.3172
 581 | 11 30 102.8834
 582 | 11 31 40.4969
 583 | 11 32 66.0379
 584 | 11 33 56.8859
 585 | 11 34 100.2447
 586 | 11 35 17.0294
 587 | 11 36 38.833
 588 | 11 37 40.3609
 589 | 11 38 109.6586
 590 | 11 39 87.2812
 591 | 11 40 52.4309
 592 | 11 41 29.4279
 593 | 11 42 60.6053
 594 | 11 43 63.0079
 595 | 11 44 59.4811
 596 | 11 45 52.2015
 597 | 11 46 43.0116
 598 | 11 47 20.0
 599 | 11 48 54.3415
 600 | 11 49 23.7065
 601 | 12 0 83.006
 602 | 12 1 22.0907
 603 | 12 2 108.4066
 604 | 12 3 78.4347
 605 | 12 4 86.6833
 606 | 12 5 49.0918
 607 | 12 6 4.2426
 608 | 12 7 95.5667
 609 | 12 8 88.2553
 610 | 12 9 89.3756
 611 | 12 10 88.0909
 612 | 12 11 103.2473
 613 | 12 12 0.0
 614 | 12 13 56.648
 615 | 12 14 23.0217
 616 | 12 15 66.4078
 617 | 12 16 62.9682
 618 | 12 17 47.4342
 619 | 12 18 18.4391
 620 | 12 19 62.514
 621 | 12 20 59.3043
 622 | 12 21 82.6196
 623 | 12 22 88.6848
 624 | 12 23 107.9352
 625 | 12 24 29.0689
 626 | 12 25 50.448
 627 | 12 26 84.0238
 628 | 12 27 20.0998
 629 | 12 28 89.0505
 630 | 12 29 17.1172
 631 | 12 30 1.0
 632 | 12 31 77.8974
 633 | 12 32 63.6003
 634 | 12 33 48.8262
 635 | 12 34 70.0071
 636 | 12 35 96.3846
 637 | 12 36 88.0
 638 | 12 37 66.9104
 639 | 12 38 15.0
 640 | 12 39 17.0294
 641 | 12 40 66.1891
 642 | 12 41 74.686
 643 | 12 42 89.0449
 644 | 12 43 60.4152
 645 | 12 44 67.424
 646 | 12 45 51.4296
 647 | 12 46 71.0634
 648 | 12 47 99.8599
 649 | 12 48 50.2494
 650 | 12 49 89.5879
 651 | 13 0 61.0983
 652 | 13 1 55.0364
 653 | 13 2 74.0068
 654 | 13 3 21.8403
 655 | 13 4 95.5249
 656 | 13 5 33.4215
 657 | 13 6 52.811
 658 | 13 7 79.3095
 659 | 13 8 67.0671
 660 | 13 9 40.8534
 661 | 13 10 88.7299
 662 | 13 11 77.4661
 663 | 13 12 56.648
 664 | 13 13 0.0
 665 | 13 14 36.6197
 666 | 13 15 85.5862
 667 | 13 16 24.0416
 668 | 13 17 9.434
 669 | 13 18 67.4759
 670 | 13 19 61.5549
 671 | 13 20 61.0737
 672 | 13 21 45.0444
 673 | 13 22 93.3809
 674 | 13 23 65.0
 675 | 13 24 30.0
 676 | 13 25 28.3196
 677 | 13 26 81.8352
 678 | 13 27 76.243
 679 | 13 28 53.0377
 680 | 13 29 40.2492
 681 | 13 30 55.7136
 682 | 13 31 38.0132
 683 | 13 32 81.9878
 684 | 13 33 32.0156
 685 | 13 34 25.4951
 686 | 13 35 63.1269
 687 | 13 36 86.2148
 688 | 13 37 62.2896
 689 | 13 38 70.8802
 690 | 13 39 42.5793
 691 | 13 40 74.027
 692 | 13 41 51.0784
 693 | 13 42 35.609
 694 | 13 43 76.6616
 695 | 13 44 19.105
 696 | 13 45 39.6989
 697 | 13 46 71.4213
 698 | 13 47 64.0078
 699 | 13 48 35.4683
 700 | 13 49 55.1453
 701 | 14 0 78.4092
 702 | 14 1 33.9706
 703 | 14 2 99.93
 704 | 14 3 57.7062
 705 | 14 4 94.8472
 706 | 14 5 42.19
 707 | 14 6 20.3961
 708 | 14 7 94.0053
 709 | 14 8 84.2912
 710 | 14 9 74.2024
 711 | 14 10 93.0054
 712 | 14 11 98.1529
 713 | 14 12 23.0217
 714 | 14 13 36.6197
 715 | 14 14 0.0
 716 | 14 15 77.666
 717 | 14 16 49.6488
 718 | 14 17 27.2029
 719 | 14 18 39.2173
 720 | 14 19 64.7611
 721 | 14 20 62.3618
 722 | 14 21 71.6938
 723 | 14 22 95.2733
 724 | 14 23 95.7706
 725 | 14 24 6.7082
 726 | 14 25 41.0
 727 | 14 26 87.5557
 728 | 14 27 43.0116
 729 | 14 28 79.1202
 730 | 14 29 6.7082
 731 | 14 30 22.0227
 732 | 14 31 65.7419
 733 | 14 32 74.3303
 734 | 14 33 41.3038
 735 | 14 34 47.0425
 736 | 14 35 87.9318
 737 | 14 36 91.9239
 738 | 14 37 68.0661
 739 | 14 38 38.0132
 740 | 14 39 18.4391
 741 | 14 40 72.6154
 742 | 14 41 68.7314
 743 | 14 42 71.4493
 744 | 14 43 69.9714
 745 | 14 44 51.225
 746 | 14 45 47.0
 747 | 14 46 74.7262
 748 | 14 47 90.4765
 749 | 14 48 44.1022
 750 | 14 49 80.3243
 751 | 15 0 53.8516
 752 | 15 1 45.1885
 753 | 15 2 81.1542
 754 | 15 3 101.951
 755 | 15 4 22.3607
 756 | 15 5 52.8015
 757 | 15 6 64.622
 758 | 15 7 52.4309
 759 | 15 8 54.7814
 760 | 15 9 89.1403
 761 | 15 10 30.2324
 762 | 15 11 67.6018
 763 | 15 12 66.4078
 764 | 15 13 85.5862
 765 | 15 14 77.666
 766 | 15 15 0.0
 767 | 15 16 69.9214
 768 | 15 17 81.6088
 769 | 15 18 51.4782
 770 | 15 19 29.0172
 771 | 15 20 27.2947
 772 | 15 21 72.0278
 773 | 15 22 26.9258
 774 | 15 23 92.1954
 775 | 15 24 78.8733
 776 | 15 25 58.1808
 777 | 15 26 31.1448
 778 | 15 27 65.0077
 779 | 15 28 72.6911
 780 | 15 29 71.8679
 781 | 15 30 66.7308
 782 | 15 31 73.171
 783 | 15 32 3.6056
 784 | 15 33 54.1295
 785 | 15 34 110.1136
 786 | 15 35 72.8011
 787 | 15 36 32.6497
 788 | 15 37 32.1403
 789 | 15 38 63.2851
 790 | 15 39 59.3633
 791 | 15 40 16.2788
 792 | 15 41 54.1479
 793 | 15 42 97.1648
 794 | 15 43 8.9443
 795 | 15 44 79.6994
 796 | 15 45 47.1699
 797 | 15 46 25.2982
 798 | 15 47 77.8845
 799 | 15 48 51.0784
 800 | 15 49 71.0211
 801 | 16 0 37.1618
 802 | 16 1 52.3927
 803 | 16 2 51.6236
 804 | 16 3 32.7567
 805 | 16 4 75.7166
 806 | 16 5 19.105
 807 | 16 6 58.7282
 808 | 16 7 55.4617
 809 | 16 8 43.0813
 810 | 16 9 26.6271
 811 | 16 10 67.2681
 812 | 16 11 53.6004
 813 | 16 12 62.9682
 814 | 16 13 24.0416
 815 | 16 14 49.6488
 816 | 16 15 69.9214
 817 | 16 16 0.0
 818 | 16 17 28.0179
 819 | 16 18 67.5352
 820 | 16 19 42.4853
 821 | 16 20 43.0813
 822 | 16 21 22.561
 823 | 16 22 72.6223
 824 | 16 23 46.1411
 825 | 16 24 44.3847
 826 | 16 25 14.5602
 827 | 16 26 60.1415
 828 | 16 27 79.8812
 829 | 16 28 30.4138
 830 | 16 29 50.2195
 831 | 16 30 62.2415
 832 | 16 31 16.1555
 833 | 16 32 66.4831
 834 | 16 33 18.2483
 835 | 16 34 48.3735
 836 | 16 35 40.1123
 837 | 16 36 64.3506
 838 | 16 37 41.8808
 839 | 16 38 74.6324
 840 | 16 39 46.0977
 841 | 16 40 55.9464
 842 | 16 41 27.2947
 843 | 16 42 29.4279
 844 | 16 43 61.131
 845 | 16 44 9.8489
 846 | 16 45 23.1948
 847 | 16 46 51.3128
 848 | 16 47 41.7732
 849 | 16 48 20.0
 850 | 16 49 32.1403
 851 | 17 0 63.561
 852 | 17 1 47.5184
 853 | 17 2 79.511
 854 | 17 3 31.0161
 855 | 17 4 93.5094
 856 | 17 5 31.6228
 857 | 17 6 43.6807
 858 | 17 7 81.3204
 859 | 17 8 69.6348
 860 | 17 9 48.7647
 861 | 17 10 87.9204
 862 | 17 11 81.3019
 863 | 17 12 47.4342
 864 | 17 13 9.434
 865 | 17 14 27.2029
 866 | 17 15 81.6088
 867 | 17 16 28.0179
 868 | 17 17 0.0
 869 | 17 18 59.0762
 870 | 17 19 59.8164
 871 | 17 20 58.7963
 872 | 17 21 50.3587
 873 | 17 22 92.0054
 874 | 17 23 72.111
 875 | 17 24 20.6155
 876 | 17 25 27.2947
 877 | 17 26 81.3019
 878 | 17 27 67.1863
 879 | 17 28 58.3095
 880 | 17 29 30.8707
 881 | 17 30 46.4866
 882 | 17 31 43.566
 883 | 17 32 78.0064
 884 | 17 33 30.2324
 885 | 17 34 28.6531
 886 | 17 35 68.1175
 887 | 17 36 85.7555
 888 | 17 37 61.2944
 889 | 17 38 61.8466
 890 | 17 39 34.0588
 891 | 17 40 71.4213
 892 | 17 41 53.3667
 893 | 17 42 44.5982
 894 | 17 43 72.8011
 895 | 17 44 26.0
 896 | 17 45 38.0132
 897 | 17 46 70.0
 898 | 17 47 69.5845
 899 | 17 48 33.8378
 900 | 17 49 60.1332
 901 | 18 0 79.0569
 902 | 18 1 15.6205
 903 | 18 2 106.527
 904 | 18 3 89.1067
 905 | 18 4 73.0616
 906 | 18 5 50.2195
 907 | 18 6 19.2354
 908 | 18 7 88.6397
 909 | 18 8 83.5284
 910 | 18 9 94.0213
 911 | 18 10 76.6551
 912 | 18 11 98.7927
 913 | 18 12 18.4391
 914 | 18 13 67.4759
 915 | 18 14 39.2173
 916 | 18 15 51.4782
 917 | 18 16 67.5352
 918 | 18 17 59.0762
 919 | 18 18 0.0
 920 | 18 19 54.626
 921 | 18 20 51.0784
 922 | 18 21 83.8689
 923 | 18 22 76.0592
 924 | 18 23 109.2245
 925 | 18 24 44.1475
 926 | 18 25 53.3385
 927 | 18 26 73.7564
 928 | 18 27 15.2315
 929 | 18 28 89.1403
 930 | 18 29 32.573
 931 | 18 30 19.2094
 932 | 18 31 80.4487
 933 | 18 32 49.163
 934 | 18 33 50.4777
 935 | 18 34 84.7172
 936 | 18 35 94.921
 937 | 18 36 77.2787
 938 | 18 37 59.5063
 939 | 18 38 12.0416
 940 | 18 39 25.02
 941 | 18 40 54.7449
 942 | 18 41 72.3464
 943 | 18 42 96.0052
 944 | 18 43 47.0106
 945 | 18 44 74.0945
 946 | 18 45 50.2494
 947 | 18 46 61.4003
 948 | 18 47 99.0353
 949 | 18 48 50.6063
 950 | 18 49 89.0955
 951 | 19 0 27.4591
 952 | 19 1 41.2311
 953 | 19 2 56.0357
 954 | 19 3 75.1798
 955 | 19 4 33.9706
 956 | 19 5 28.3196
 957 | 19 6 59.2115
 958 | 19 7 34.0147
 959 | 19 8 30.4138
 960 | 19 9 60.1332
 961 | 19 10 28.6356
 962 | 19 11 45.3431
 963 | 19 12 62.514
 964 | 19 13 61.5549
 965 | 19 14 64.7611
 966 | 19 15 29.0172
 967 | 19 16 42.4853
 968 | 19 17 59.8164
 969 | 19 18 54.626
 970 | 19 19 0.0
 971 | 19 20 3.6056
 972 | 19 21 43.1045
 973 | 19 22 32.2025
 974 | 19 23 64.5136
 975 | 19 24 63.5689
 976 | 19 25 33.2415
 977 | 19 26 22.8035
 978 | 19 27 69.857
 979 | 19 28 44.3847
 980 | 19 29 60.6712
 981 | 19 30 62.3939
 982 | 19 31 44.1814
 983 | 19 32 26.0192
 984 | 19 33 29.7321
 985 | 19 34 86.977
 986 | 19 35 46.0652
 987 | 19 36 27.2029
 988 | 19 37 5.0
 989 | 19 38 66.1287
 990 | 19 39 49.0918
 991 | 19 40 13.6015
 992 | 19 41 25.4951
 993 | 19 42 68.4471
 994 | 19 43 21.2132
 995 | 19 44 52.3259
 996 | 19 45 21.9317
 997 | 19 46 10.2956
 998 | 19 47 50.9902
 999 | 19 48 26.1725
1000 | 19 49 43.0116
1001 | 20 0 30.8058
1002 | 20 1 37.855
1003 | 20 2 59.4054
1004 | 20 3 75.5844
1005 | 20 4 34.7131
1006 | 20 5 27.6586
1007 | 20 6 56.0803
1008 | 20 7 37.5766
1009 | 20 8 33.9411
1010 | 20 9 62.0081
1011 | 20 10 30.6757
1012 | 20 11 48.9183
1013 | 20 12 59.3043
1014 | 20 13 61.0737
1015 | 20 14 62.3618
1016 | 20 15 27.2947
1017 | 20 16 43.0813
1018 | 20 17 58.7963
1019 | 20 18 51.0784
1020 | 20 19 3.6056
1021 | 20 20 0.0
1022 | 20 21 45.3982
1023 | 20 22 33.6155
1024 | 20 23 67.4166
1025 | 20 24 61.4654
1026 | 20 25 32.8024
1027 | 20 26 25.318
1028 | 20 27 66.3099
1029 | 20 28 47.1275
1030 | 20 29 58.0517
1031 | 20 30 59.2115
1032 | 20 31 46.0109
1033 | 20 32 24.0832
1034 | 20 33 29.0689
1035 | 20 34 86.3713
1036 | 20 35 49.2443
1037 | 20 36 29.6142
1038 | 20 37 8.6023
1039 | 20 38 62.6259
1040 | 20 39 46.2709
1041 | 20 40 13.0384
1042 | 20 41 28.1603
1043 | 20 42 69.8713
1044 | 20 43 19.0
1045 | 20 44 52.9245
1046 | 20 45 21.4009
1047 | 20 46 12.3693
1048 | 20 47 54.1202
1049 | 20 48 25.6125
1050 | 20 49 45.8803
1051 | 21 0 23.3238
1052 | 21 1 68.2495
1053 | 21 2 29.1548
1054 | 21 3 45.2769
1055 | 21 4 70.8802
1056 | 21 5 33.9411
1057 | 21 6 78.4092
1058 | 21 7 40.3113
1059 | 21 8 27.6586
1060 | 21 9 18.3848
1061 | 21 10 59.6154
1062 | 21 11 33.6155
1063 | 21 12 82.6196
1064 | 21 13 45.0444
1065 | 21 14 71.6938
1066 | 21 15 72.0278
1067 | 21 16 22.561
1068 | 21 17 50.3587
1069 | 21 18 83.8689
1070 | 21 19 43.1045
1071 | 21 20 45.3982
1072 | 21 21 0.0
1073 | 21 22 66.1287
1074 | 21 23 25.4558
1075 | 21 24 66.7308
1076 | 21 25 32.2025
1077 | 21 26 52.5547
1078 | 21 27 97.6217
1079 | 21 28 8.0
1080 | 21 29 71.5891
1081 | 21 30 82.0061
1082 | 21 31 7.0711
1083 | 21 32 69.1158
1084 | 21 33 33.9706
1085 | 21 34 66.7608
1086 | 21 35 18.1108
1087 | 21 36 55.9464
1088 | 21 37 40.0125
1089 | 21 38 92.6337
1090 | 21 39 65.6049
1091 | 21 40 56.0089
1092 | 21 41 18.1108
1093 | 21 42 29.4109
1094 | 21 43 64.2806
1095 | 21 44 26.3059
1096 | 21 45 33.8378
1097 | 21 46 48.3735
1098 | 21 47 19.2354
1099 | 21 48 33.3017
1100 | 21 49 10.198
1101 | 22 0 43.4166
1102 | 22 1 66.6108
1103 | 22 2 65.2763
1104 | 22 3 105.2093
1105 | 22 4 6.7082
1106 | 22 5 60.4401
1107 | 22 6 86.1452
1108 | 22 7 33.3766
1109 | 22 8 41.3038
1110 | 22 9 84.5044
1111 | 22 10 7.0
1112 | 22 11 49.6488
1113 | 22 12 88.6848
1114 | 22 13 93.3809
1115 | 22 14 95.2733
1116 | 22 15 26.9258
1117 | 22 16 72.6223
1118 | 22 17 92.0054
1119 | 22 18 76.0592
1120 | 22 19 32.2025
1121 | 22 20 33.6155
1122 | 22 21 66.1287
1123 | 22 22 0.0
1124 | 22 23 80.1561
1125 | 22 24 94.8472
1126 | 22 25 65.192
1127 | 22 26 13.6015
1128 | 22 27 90.4489
1129 | 22 28 63.7887
1130 | 22 29 90.4434
1131 | 22 30 88.8144
1132 | 22 31 69.7782
1133 | 22 32 27.8927
1134 | 22 33 61.8466
1135 | 22 34 118.8697
1136 | 22 35 60.208
1137 | 22 36 11.0
1138 | 22 37 31.1127
1139 | 22 38 88.0909
1140 | 22 39 78.1601
1141 | 22 40 22.8035
1142 | 22 41 48.7545
1143 | 22 42 94.8472
1144 | 22 43 29.0689
1145 | 22 44 82.201
1146 | 22 45 54.037
1147 | 22 46 22.0227
1148 | 22 47 65.123
1149 | 22 48 58.258
1150 | 22 49 61.3922
1151 | 23 0 38.4708
1152 | 23 1 93.6056
1153 | 23 2 18.6011
1154 | 23 3 57.2189
1155 | 23 4 86.0233
1156 | 23 5 59.397
1157 | 23 6 103.7111
1158 | 23 7 48.0521
1159 | 23 8 39.0
1160 | 23 9 25.02
1161 | 23 10 73.171
1162 | 23 11 33.6155
1163 | 23 12 107.9352
1164 | 23 13 65.0
1165 | 23 14 95.7706
1166 | 23 15 92.1954
1167 | 23 16 46.1411
1168 | 23 17 72.111
1169 | 23 18 109.2245
1170 | 23 19 64.5136
1171 | 23 20 67.4166
1172 | 23 21 25.4558
1173 | 23 22 80.1561
1174 | 23 23 0.0
1175 | 23 24 90.3383
1176 | 23 25 57.4891
1177 | 23 26 67.0075
1178 | 23 27 123.0691
1179 | 23 28 20.5913
1180 | 23 29 96.2549
1181 | 23 30 107.2986
1182 | 23 31 30.2324
1183 | 23 32 89.7385
1184 | 23 33 59.4138
1185 | 23 34 82.0061
1186 | 23 35 20.0
1187 | 23 36 69.1809
1188 | 23 37 60.4401
1189 | 23 38 118.0889
1190 | 23 39 90.9065
1191 | 23 40 75.9276
1192 | 23 41 39.3954
1193 | 23 42 35.5106
1194 | 23 43 85.44
1195 | 23 44 46.1736
1196 | 23 45 59.0339
1197 | 23 46 67.082
1198 | 23 47 15.0333
1199 | 23 48 58.7282
1200 | 23 49 21.5407
1201 | 24 0 75.0267
1202 | 24 1 36.8917
1203 | 24 2 95.3362
1204 | 24 3 51.0
1205 | 24 4 94.8947
1206 | 24 5 39.0512
1207 | 24 6 26.0192
1208 | 24 7 91.2688
1209 | 24 8 81.0062
1210 | 24 9 68.2422
1211 | 24 10 92.1141
1212 | 24 11 94.4299
1213 | 24 12 29.0689
1214 | 24 13 30.0
1215 | 24 14 6.7082
1216 | 24 15 78.8733
1217 | 24 16 44.3847
1218 | 24 17 20.6155
1219 | 24 18 44.1475
1220 | 24 19 63.5689
1221 | 24 20 61.4654
1222 | 24 21 66.7308
1223 | 24 22 94.8472
1224 | 24 23 90.3383
1225 | 24 24 0.0
1226 | 24 25 37.1214
1227 | 24 26 86.3308
1228 | 24 27 49.163
1229 | 24 28 74.3303
1230 | 24 29 12.0
1231 | 24 30 28.0713
1232 | 24 31 60.5392
1233 | 24 32 75.4321
1234 | 24 33 38.0132
1235 | 24 34 41.0122
1236 | 24 35 83.4326
1237 | 24 36 90.7579
1238 | 24 37 66.4831
1239 | 24 38 44.0454
1240 | 24 39 21.095
1241 | 24 40 72.4707
1242 | 24 41 65.123
1243 | 24 42 65.0538
1244 | 24 43 70.8025
1245 | 24 44 45.2217
1246 | 24 45 44.4072
1247 | 24 46 73.736
1248 | 24 47 85.7263
1249 | 24 48 41.1096
1250 | 24 49 75.6902
1251 | 25 0 38.0132
1252 | 25 1 38.0132
1253 | 25 2 59.2368
1254 | 25 3 43.9659
1255 | 25 4 67.2086
1256 | 25 5 5.3852
1257 | 25 6 46.2277
1258 | 25 7 54.9181
1259 | 25 8 44.0454
1260 | 25 9 40.7063
1261 | 25 10 60.803
1262 | 25 11 57.3149
1263 | 25 12 50.448
1264 | 25 13 28.3196
1265 | 25 14 41.0
1266 | 25 15 58.1808
1267 | 25 16 14.5602
1268 | 25 17 27.2947
1269 | 25 18 53.3385
1270 | 25 19 33.2415
1271 | 25 20 32.8024
1272 | 25 21 32.2025
1273 | 25 22 65.192
1274 | 25 23 57.4891
1275 | 25 24 37.1214
1276 | 25 25 0.0
1277 | 25 26 54.0833
1278 | 25 27 66.2193
1279 | 25 28 38.9487
1280 | 25 29 39.9249
1281 | 25 30 49.8197
1282 | 25 31 27.5862
1283 | 25 32 54.626
1284 | 25 33 4.1231
1285 | 25 34 53.7401
1286 | 25 35 47.1699
1287 | 25 36 58.5235
1288 | 25 37 34.2053
1289 | 25 38 61.0737
1290 | 25 39 33.4215
1291 | 25 40 45.8039
1292 | 25 41 28.0179
1293 | 25 42 43.9318
1294 | 25 43 49.2443
1295 | 25 44 23.0
1296 | 25 45 11.4018
1297 | 25 46 43.1856
1298 | 25 47 50.0899
1299 | 25 48 7.2111
1300 | 25 49 39.8121
1301 | 26 0 29.8329
1302 | 26 1 62.1289
1303 | 26 2 52.9528
1304 | 26 3 92.4554
1305 | 26 4 19.0263
1306 | 26 5 49.7393
1307 | 26 6 81.0062
1308 | 26 7 21.9317
1309 | 26 8 28.0179
1310 | 26 9 70.9366
1311 | 26 10 7.2111
1312 | 26 11 37.9473
1313 | 26 12 84.0238
1314 | 26 13 81.8352
1315 | 26 14 87.5557
1316 | 26 15 31.1448
1317 | 26 16 60.1415
1318 | 26 17 81.3019
1319 | 26 18 73.7564
1320 | 26 19 22.8035
1321 | 26 20 25.318
1322 | 26 21 52.5547
1323 | 26 22 13.6015
1324 | 26 23 67.0075
1325 | 26 24 86.3308
1326 | 26 25 54.0833
1327 | 26 26 0.0
1328 | 26 27 88.7694
1329 | 26 28 50.2195
1330 | 26 29 83.3607
1331 | 26 30 84.006
1332 | 26 31 56.356
1333 | 26 32 30.4795
1334 | 26 33 51.1077
1335 | 26 34 107.2986
1336 | 26 35 47.0106
1337 | 26 36 4.4721
1338 | 26 37 20.1246
1339 | 26 38 85.703
1340 | 26 39 71.5681
1341 | 26 40 19.3132
1342 | 26 41 35.3553
1343 | 26 42 81.3941
1344 | 26 43 29.1548
1345 | 26 44 69.527
1346 | 26 45 43.4166
1347 | 26 46 13.0384
1348 | 26 47 52.0
1349 | 26 48 47.5079
1350 | 26 49 47.8539
1351 | 27 0 94.0319
1352 | 27 1 30.0
1353 | 27 2 121.2106
1354 | 27 3 98.0816
1355 | 27 4 87.0517
1356 | 27 5 63.7024
1357 | 27 6 23.5372
1358 | 27 7 103.8701
1359 | 27 8 98.6154
1360 | 27 9 106.5082
1361 | 27 10 91.4112
1362 | 27 11 113.8771
1363 | 27 12 20.0998
1364 | 27 13 76.243
1365 | 27 14 43.0116
1366 | 27 15 65.0077
1367 | 27 16 79.8812
1368 | 27 17 67.1863
1369 | 27 18 15.2315
1370 | 27 19 69.857
1371 | 27 20 66.3099
1372 | 27 21 97.6217
1373 | 27 22 90.4489
1374 | 27 23 123.0691
1375 | 27 24 49.163
1376 | 27 25 66.2193
1377 | 27 26 88.7694
1378 | 27 27 0.0
1379 | 27 28 103.2763
1380 | 27 29 37.2156
1381 | 27 30 21.095
1382 | 27 31 93.723
1383 | 27 32 63.0317
1384 | 27 33 63.7809
1385 | 27 34 90.05
1386 | 27 35 109.4806
1387 | 27 36 92.1954
1388 | 27 37 74.7329
1389 | 27 38 5.3852
1390 | 27 39 34.4384
1391 | 27 40 69.6348
1392 | 27 41 87.0057
1393 | 27 42 107.3546
1394 | 27 43 61.4003
1395 | 27 44 85.4751
1396 | 27 45 64.4438
1397 | 27 46 76.5376
1398 | 27 47 113.4548
1399 | 27 48 64.3506
1400 | 27 49 103.3925
1401 | 28 0 20.3961
1402 | 28 1 73.5527
1403 | 28 2 21.2132
1404 | 28 3 52.3259
1405 | 28 4 69.0507
1406 | 28 5 40.0
1407 | 28 6 84.8764
1408 | 28 7 35.2278
1409 | 28 8 23.2594
1410 | 28 9 22.6716
1411 | 28 10 57.0088
1412 | 28 11 26.4197
1413 | 28 12 89.0505
1414 | 28 13 53.0377
1415 | 28 14 79.1202
1416 | 28 15 72.6911
1417 | 28 16 30.4138
1418 | 28 17 58.3095
1419 | 28 18 89.1403
1420 | 28 19 44.3847
1421 | 28 20 47.1275
1422 | 28 21 8.0
1423 | 28 22 63.7887
1424 | 28 23 20.5913
1425 | 28 24 74.3303
1426 | 28 25 38.9487
1427 | 28 26 50.2195
1428 | 28 27 103.2763
1429 | 28 28 0.0
1430 | 28 29 78.721
1431 | 28 30 88.4816
1432 | 28 31 15.0333
1433 | 28 32 70.0357
1434 | 28 33 40.2244
1435 | 28 34 74.4648
1436 | 28 35 10.198
1437 | 28 36 53.1601
1438 | 28 37 40.6079
1439 | 28 38 98.4124
1440 | 28 39 72.111
1441 | 28 40 56.4358
1442 | 28 41 18.9737
1443 | 28 42 34.6554
1444 | 28 43 65.5134
1445 | 28 44 34.2345
1446 | 28 45 38.8973
1447 | 28 46 48.0416
1448 | 28 47 11.4018
1449 | 28 48 39.0512
1450 | 28 49 2.8284
1451 | 29 0 76.2955
1452 | 29 1 27.5862
1453 | 29 2 99.1615
1454 | 29 3 61.8466
1455 | 29 4 89.6939
1456 | 29 5 40.2616
1457 | 29 6 14.0357
1458 | 29 7 91.1373
1459 | 29 8 82.0366
1460 | 29 9 75.743
1461 | 29 10 88.5268
1462 | 29 11 96.3172
1463 | 29 12 17.1172
1464 | 29 13 40.2492
1465 | 29 14 6.7082
1466 | 29 15 71.8679
1467 | 29 16 50.2195
1468 | 29 17 30.8707
1469 | 29 18 32.573
1470 | 29 19 60.6712
1471 | 29 20 58.0517
1472 | 29 21 71.5891
1473 | 29 22 90.4434
1474 | 29 23 96.2549
1475 | 29 24 12.0
1476 | 29 25 39.9249
1477 | 29 26 83.3607
1478 | 29 27 37.2156
1479 | 29 28 78.721
1480 | 29 29 0.0
1481 | 29 30 16.1245
1482 | 29 31 66.0379
1483 | 29 32 68.6003
1484 | 29 33 39.5601
1485 | 29 34 53.0094
1486 | 29 35 87.0919
1487 | 29 36 87.6641
1488 | 29 37 64.2806
1489 | 29 38 32.0624
1490 | 29 39 12.53
1491 | 29 40 67.6757
1492 | 29 41 66.9403
1493 | 29 42 74.027
1494 | 29 43 64.4127
1495 | 29 44 53.0377
1496 | 29 45 44.4072
1497 | 29 46 70.406
1498 | 29 47 89.9611
1499 | 29 48 41.9762
1500 | 29 49 79.7057
1501 | 30 0 82.6378
1502 | 30 1 22.2036
1503 | 30 2 107.912
1504 | 30 3 77.4919
1505 | 30 4 86.885
1506 | 30 5 48.5489
1507 | 30 6 3.6056
1508 | 30 7 95.3415
1509 | 30 8 87.9204
1510 | 30 9 88.6172
1511 | 30 10 88.1419
1512 | 30 11 102.8834
1513 | 30 12 1.0
1514 | 30 13 55.7136
1515 | 30 14 22.0227
1516 | 30 15 66.7308
1517 | 30 16 62.2415
1518 | 30 17 46.4866
1519 | 30 18 19.2094
1520 | 30 19 62.3939
1521 | 30 20 59.2115
1522 | 30 21 82.0061
1523 | 30 22 88.8144
1524 | 30 23 107.2986
1525 | 30 24 28.0713
1526 | 30 25 49.8197
1527 | 30 26 84.006
1528 | 30 27 21.095
1529 | 30 28 88.4816
1530 | 30 29 16.1245
1531 | 30 30 0.0
1532 | 30 31 77.2334
1533 | 30 32 63.8905
1534 | 30 33 48.2597
1535 | 30 34 69.0072
1536 | 30 35 95.8801
1537 | 30 36 88.0057
1538 | 30 37 66.7533
1539 | 30 38 16.0
1540 | 30 39 16.4012
1541 | 30 40 66.2722
1542 | 30 41 74.2496
1543 | 30 42 88.2043
1544 | 30 43 60.6383
1545 | 30 44 66.6108
1546 | 30 45 50.9902
1547 | 30 46 71.0282
1548 | 30 47 99.3227
1549 | 30 48 49.7393
1550 | 30 49 89.0449
1551 | 31 0 28.3196
1552 | 31 1 64.8999
1553 | 31 2 36.0555
1554 | 31 3 38.833
1555 | 31 4 74.0945
1556 | 31 5 30.2324
1557 | 31 6 73.6614
1558 | 31 7 46.0977
1559 | 31 8 33.3017
1560 | 31 9 16.0
1561 | 31 10 63.5295
1562 | 31 11 40.4969
1563 | 31 12 77.8974
1564 | 31 13 38.0132
1565 | 31 14 65.7419
1566 | 31 15 73.171
1567 | 31 16 16.1555
1568 | 31 17 43.566
1569 | 31 18 80.4487
1570 | 31 19 44.1814
1571 | 31 20 46.0109
1572 | 31 21 7.0711
1573 | 31 22 69.7782
1574 | 31 23 30.2324
1575 | 31 24 60.5392
1576 | 31 25 27.5862
1577 | 31 26 56.356
1578 | 31 27 93.723
1579 | 31 28 15.0333
1580 | 31 29 66.0379
1581 | 31 30 77.2334
1582 | 31 31 0.0
1583 | 31 32 70.0643
1584 | 31 33 30.0
1585 | 31 34 59.7746
1586 | 31 35 25.1794
1587 | 31 36 60.0333
1588 | 31 37 41.7732
1589 | 31 38 88.6172
1590 | 31 39 60.8769
1591 | 31 40 57.5587
1592 | 31 41 21.0238
1593 | 31 42 25.0799
1594 | 31 43 65.0077
1595 | 31 44 19.2354
1596 | 31 45 31.3847
1597 | 31 46 50.6952
1598 | 31 47 26.0768
1599 | 31 48 30.0167
1600 | 31 49 17.2627
1601 | 32 0 51.5461
1602 | 32 1 42.1545
1603 | 32 2 79.2023
1604 | 32 3 98.4327
1605 | 32 4 24.0208
1606 | 32 5 49.2443
1607 | 32 6 61.6847
1608 | 32 7 51.225
1609 | 32 8 52.8015
1610 | 32 9 86.0523
1611 | 32 10 30.4138
1612 | 32 11 66.0379
1613 | 32 12 63.6003
1614 | 32 13 81.9878
1615 | 32 14 74.3303
1616 | 32 15 3.6056
1617 | 32 16 66.4831
1618 | 32 17 78.0064
1619 | 32 18 49.163
1620 | 32 19 26.0192
1621 | 32 20 24.0832
1622 | 32 21 69.1158
1623 | 32 22 27.8927
1624 | 32 23 89.7385
1625 | 32 24 75.4321
1626 | 32 25 54.626
1627 | 32 26 30.4795
1628 | 32 27 63.0317
1629 | 32 28 70.0357
1630 | 32 29 68.6003
1631 | 32 30 63.8905
1632 | 32 31 70.0643
1633 | 32 32 0.0
1634 | 32 33 50.5668
1635 | 32 34 106.5082
1636 | 32 35 70.5195
1637 | 32 36 32.45
1638 | 32 37 29.4279
1639 | 32 38 61.0737
1640 | 32 39 56.0803
1641 | 32 40 13.9284
1642 | 32 41 51.3517
1643 | 32 42 93.9042
1644 | 32 43 5.3852
1645 | 32 44 76.243
1646 | 32 45 43.6578
1647 | 32 46 23.2594
1648 | 32 47 75.5844
1649 | 32 48 47.5395
1650 | 32 49 68.4471
1651 | 33 0 37.1214
1652 | 33 1 34.9857
1653 | 33 2 59.9333
1654 | 33 3 48.0833
1655 | 33 4 63.6396
1656 | 33 5 1.4142
1657 | 33 6 44.6542
1658 | 33 7 53.3385
1659 | 33 8 43.0465
1660 | 33 9 43.8634
1661 | 33 10 57.6888
1662 | 33 11 56.8859
1663 | 33 12 48.8262
1664 | 33 13 32.0156
1665 | 33 14 41.3038
1666 | 33 15 54.1295
1667 | 33 16 18.2483
1668 | 33 17 30.2324
1669 | 33 18 50.4777
1670 | 33 19 29.7321
1671 | 33 20 29.0689
1672 | 33 21 33.9706
1673 | 33 22 61.8466
1674 | 33 23 59.4138
1675 | 33 24 38.0132
1676 | 33 25 4.1231
1677 | 33 26 51.1077
1678 | 33 27 63.7809
1679 | 33 28 40.2244
1680 | 33 29 39.5601
1681 | 33 30 48.2597
1682 | 33 31 30.0
1683 | 33 32 50.5668
1684 | 33 33 0.0
1685 | 33 34 57.3149
1686 | 33 35 47.8539
1687 | 33 36 55.5698
1688 | 33 37 31.0644
1689 | 33 38 58.7282
1690 | 33 39 31.9061
1691 | 33 40 42.0119
1692 | 33 41 27.4591
1693 | 33 42 47.676
1694 | 33 43 45.1885
1695 | 33 44 27.0185
1696 | 33 45 7.8102
1697 | 33 46 39.8246
1698 | 33 47 51.1077
1699 | 33 48 3.6056
1700 | 33 49 40.8167
1701 | 34 0 85.4225
1702 | 34 1 75.0
1703 | 34 2 94.3663
1704 | 34 3 25.318
1705 | 34 4 120.9339
1706 | 34 5 58.7282
1707 | 34 6 67.0298
1708 | 34 7 103.769
1709 | 34 8 91.236
1710 | 34 9 57.0351
1711 | 34 10 114.2147
1712 | 34 11 100.2447
1713 | 34 12 70.0071
1714 | 34 13 25.4951
1715 | 34 14 47.0425
1716 | 34 15 110.1136
1717 | 34 16 48.3735
1718 | 34 17 28.6531
1719 | 34 18 84.7172
1720 | 34 19 86.977
1721 | 34 20 86.3713
1722 | 34 21 66.7608
1723 | 34 22 118.8697
1724 | 34 23 82.0061
1725 | 34 24 41.0122
1726 | 34 25 53.7401
1727 | 34 26 107.2986
1728 | 34 27 90.05
1729 | 34 28 74.4648
1730 | 34 29 53.0094
1731 | 34 30 69.0072
1732 | 34 31 59.7746
1733 | 34 32 106.5082
1734 | 34 33 57.3149
1735 | 34 34 0.0
1736 | 34 35 84.6463
1737 | 34 36 111.6647
1738 | 34 37 87.7838
1739 | 34 38 85.0059
1740 | 34 39 60.208
1741 | 34 40 99.2472
1742 | 34 41 75.6637
1743 | 34 42 47.2652
1744 | 34 43 101.2571
1745 | 34 44 40.8534
1746 | 34 45 65.0692
1747 | 34 46 96.8969
1748 | 34 47 84.5281
1749 | 34 48 60.8276
1750 | 34 49 76.922
1751 | 35 0 18.9737
1752 | 35 1 79.511
1753 | 35 2 12.083
1754 | 35 3 62.2415
1755 | 35 4 66.0303
1756 | 35 5 47.4131
1757 | 35 6 92.2822
1758 | 35 7 28.7924
1759 | 35 8 19.0
1760 | 35 9 31.4006
1761 | 35 10 53.2353
1762 | 35 11 17.0294
1763 | 35 12 96.3846
1764 | 35 13 63.1269
1765 | 35 14 87.9318
1766 | 35 15 72.8011
1767 | 35 16 40.1123
1768 | 35 17 68.1175
1769 | 35 18 94.921
1770 | 35 19 46.0652
1771 | 35 20 49.2443
1772 | 35 21 18.1108
1773 | 35 22 60.208
1774 | 35 23 20.0
1775 | 35 24 83.4326
1776 | 35 25 47.1699
1777 | 35 26 47.0106
1778 | 35 27 109.4806
1779 | 35 28 10.198
1780 | 35 29 87.0919
1781 | 35 30 95.8801
1782 | 35 31 25.1794
1783 | 35 32 70.5195
1784 | 35 33 47.8539
1785 | 35 34 84.6463
1786 | 35 35 0.0
1787 | 35 36 49.2544
1788 | 35 37 41.6293
1789 | 35 38 104.8094
1790 | 35 39 79.6492
1791 | 35 40 56.6127
1792 | 35 41 22.6274
1793 | 35 42 43.6005
1794 | 35 43 66.4831
1795 | 35 44 44.4072
1796 | 35 45 45.2217
1797 | 35 46 47.5395
1798 | 35 47 5.099
1799 | 35 48 46.1411
1800 | 35 49 8.0
1801 | 36 0 32.8938
1802 | 36 1 66.0303
1803 | 36 2 54.3323
1804 | 36 3 96.5401
1805 | 36 4 17.2627
1806 | 36 5 54.2033
1807 | 36 6 85.0529
1808 | 36 7 22.561
1809 | 36 8 30.4138
1810 | 36 9 74.3236
1811 | 36 10 4.0
1812 | 36 11 38.833
1813 | 36 12 88.0
1814 | 36 13 86.2148
1815 | 36 14 91.9239
1816 | 36 15 32.6497
1817 | 36 16 64.3506
1818 | 36 17 85.7555
1819 | 36 18 77.2787
1820 | 36 19 27.2029
1821 | 36 20 29.6142
1822 | 36 21 55.9464
1823 | 36 22 11.0
1824 | 36 23 69.1809
1825 | 36 24 90.7579
1826 | 36 25 58.5235
1827 | 36 26 4.4721
1828 | 36 27 92.1954
1829 | 36 28 53.1601
1830 | 36 29 87.6641
1831 | 36 30 88.0057
1832 | 36 31 60.0333
1833 | 36 32 32.45
1834 | 36 33 55.5698
1835 | 36 34 111.6647
1836 | 36 35 49.2544
1837 | 36 36 0.0
1838 | 36 37 24.5967
1839 | 36 38 89.2693
1840 | 36 39 75.8024
1841 | 36 40 22.561
1842 | 36 41 39.1152
1843 | 36 42 85.0
1844 | 36 43 31.7805
1845 | 36 44 73.6614
1846 | 36 45 47.8853
1847 | 36 46 17.2627
1848 | 36 47 54.1479
1849 | 36 48 51.9711
1850 | 36 49 50.6952
1851 | 37 0 22.8254
1852 | 37 1 45.8803
1853 | 37 2 51.3128
1854 | 37 3 74.6257
1855 | 37 4 33.8378
1856 | 37 5 29.6816
1857 | 37 6 63.5059
1858 | 37 7 29.1548
1859 | 37 8 25.4951
1860 | 37 9 57.5587
1861 | 37 10 26.6271
1862 | 37 11 40.3609
1863 | 37 12 66.9104
1864 | 37 13 62.2896
1865 | 37 14 68.0661
1866 | 37 15 32.1403
1867 | 37 16 41.8808
1868 | 37 17 61.2944
1869 | 37 18 59.5063
1870 | 37 19 5.0
1871 | 37 20 8.6023
1872 | 37 21 40.0125
1873 | 37 22 31.1127
1874 | 37 23 60.4401
1875 | 37 24 66.4831
1876 | 37 25 34.2053
1877 | 37 26 20.1246
1878 | 37 27 74.7329
1879 | 37 28 40.6079
1880 | 37 29 64.2806
1881 | 37 30 66.7533
1882 | 37 31 41.7732
1883 | 37 32 29.4279
1884 | 37 33 31.0644
1885 | 37 34 87.7838
1886 | 37 35 41.6293
1887 | 37 36 24.5967
1888 | 37 37 0.0
1889 | 37 38 70.9366
1890 | 37 39 53.0
1891 | 37 40 16.0
1892 | 37 41 22.0227
1893 | 37 42 66.4831
1894 | 37 43 25.0
1895 | 37 44 51.6236
1896 | 37 45 23.3238
1897 | 37 46 9.434
1898 | 37 47 46.6154
1899 | 37 48 27.4591
1900 | 37 49 39.0512
1901 | 38 0 89.6939
1902 | 38 1 25.5539
1903 | 38 2 116.6062
1904 | 38 3 92.72
1905 | 38 4 85.0235
1906 | 38 5 58.6941
1907 | 38 6 18.2483
1908 | 38 7 100.09
1909 | 38 8 94.414
1910 | 38 9 101.2571
1911 | 38 10 88.6848
1912 | 38 11 109.6586
1913 | 38 12 15.0
1914 | 38 13 70.8802
1915 | 38 14 38.0132
1916 | 38 15 63.2851
1917 | 38 16 74.6324
1918 | 38 17 61.8466
1919 | 38 18 12.0416
1920 | 38 19 66.1287
1921 | 38 20 62.6259
1922 | 38 21 92.6337
1923 | 38 22 88.0909
1924 | 38 23 118.0889
1925 | 38 24 44.0454
1926 | 38 25 61.0737
1927 | 38 26 85.703
1928 | 38 27 5.3852
1929 | 38 28 98.4124
1930 | 38 29 32.0624
1931 | 38 30 16.0
1932 | 38 31 88.6172
1933 | 38 32 61.0737
1934 | 38 33 58.7282
1935 | 38 34 85.0059
1936 | 38 35 104.8094
1937 | 38 36 89.2693
1938 | 38 37 70.9366
1939 | 38 38 0.0
1940 | 38 39 29.0689
1941 | 38 40 66.7533
1942 | 38 41 82.4197
1943 | 38 42 102.0
1944 | 38 43 59.0339
1945 | 38 44 80.1311
1946 | 38 45 59.6657
1947 | 38 46 73.2462
1948 | 38 47 108.706
1949 | 38 48 59.4138
1950 | 38 49 98.5951
1951 | 39 0 67.0522
1952 | 39 1 15.8114
1953 | 39 2 91.7061
1954 | 39 3 64.3273
1955 | 39 4 77.2528
1956 | 39 5 32.249
1957 | 39 6 12.8062
1958 | 39 7 80.7527
1959 | 39 8 72.5328
1960 | 39 9 72.6223
1961 | 39 10 76.4853
1962 | 39 11 87.2812
1963 | 39 12 17.0294
1964 | 39 13 42.5793
1965 | 39 14 18.4391
1966 | 39 15 59.3633
1967 | 39 16 46.0977
1968 | 39 17 34.0588
1969 | 39 18 25.02
1970 | 39 19 49.0918
1971 | 39 20 46.2709
1972 | 39 21 65.6049
1973 | 39 22 78.1601
1974 | 39 23 90.9065
1975 | 39 24 21.095
1976 | 39 25 33.4215
1977 | 39 26 71.5681
1978 | 39 27 34.4384
1979 | 39 28 72.111
1980 | 39 29 12.53
1981 | 39 30 16.4012
1982 | 39 31 60.8769
1983 | 39 32 56.0803
1984 | 39 33 31.9061
1985 | 39 34 60.208
1986 | 39 35 79.6492
1987 | 39 36 75.8024
1988 | 39 37 53.0
1989 | 39 38 29.0689
1990 | 39 39 0.0
1991 | 39 40 55.3624
1992 | 39 41 58.3095
1993 | 39 42 72.9452
1994 | 39 43 51.8845
1995 | 39 44 51.1077
1996 | 39 45 35.1141
1997 | 39 46 58.5491
1998 | 39 47 83.006
1999 | 39 48 33.541
2000 | 39 49 72.7186
2001 | 40 0 37.6431
2002 | 40 1 44.1022
2003 | 40 2 65.307
2004 | 40 3 88.5494
2005 | 40 4 22.4722
2006 | 40 5 40.6079
2007 | 40 6 63.5059
2008 | 40 7 38.1838
2009 | 40 8 38.9102
2010 | 40 9 73.437
2011 | 40 10 22.0227
2012 | 40 11 52.4309
2013 | 40 12 66.1891
2014 | 40 13 74.027
2015 | 40 14 72.6154
2016 | 40 15 16.2788
2017 | 40 16 55.9464
2018 | 40 17 71.4213
2019 | 40 18 54.7449
2020 | 40 19 13.6015
2021 | 40 20 13.0384
2022 | 40 21 56.0089
2023 | 40 22 22.8035
2024 | 40 23 75.9276
2025 | 40 24 72.4707
2026 | 40 25 45.8039
2027 | 40 26 19.3132
2028 | 40 27 69.6348
2029 | 40 28 56.4358
2030 | 40 29 67.6757
2031 | 40 30 66.2722
2032 | 40 31 57.5587
2033 | 40 32 13.9284
2034 | 40 33 42.0119
2035 | 40 34 99.2472
2036 | 40 35 56.6127
2037 | 40 36 22.561
2038 | 40 37 16.0
2039 | 40 38 66.7533
2040 | 40 39 55.3624
2041 | 40 40 0.0
2042 | 40 41 38.0132
2043 | 40 42 82.0
2044 | 40 43 10.6301
2045 | 40 44 65.7951
2046 | 40 45 34.4093
2047 | 40 46 9.434
2048 | 40 47 61.6847
2049 | 40 48 38.6005
2050 | 40 49 54.7449
2051 | 41 0 10.198
2052 | 41 1 57.0088
2053 | 41 2 34.2053
2054 | 41 3 57.9828
2055 | 41 4 53.1413
2056 | 41 5 26.6833
2057 | 41 6 70.6824
2058 | 41 7 28.2312
2059 | 41 8 16.2788
2060 | 41 9 36.1386
2061 | 41 10 42.5441
2062 | 41 11 29.4279
2063 | 41 12 74.686
2064 | 41 13 51.0784
2065 | 41 14 68.7314
2066 | 41 15 54.1479
2067 | 41 16 27.2947
2068 | 41 17 53.3667
2069 | 41 18 72.3464
2070 | 41 19 25.4951
2071 | 41 20 28.1603
2072 | 41 21 18.1108
2073 | 41 22 48.7545
2074 | 41 23 39.3954
2075 | 41 24 65.123
2076 | 41 25 28.0179
2077 | 41 26 35.3553
2078 | 41 27 87.0057
2079 | 41 28 18.9737
2080 | 41 29 66.9403
2081 | 41 30 74.2496
2082 | 41 31 21.0238
2083 | 41 32 51.3517
2084 | 41 33 27.4591
2085 | 41 34 75.6637
2086 | 41 35 22.6274
2087 | 41 36 39.1152
2088 | 41 37 22.0227
2089 | 41 38 82.4197
2090 | 41 39 58.3095
2091 | 41 40 38.0132
2092 | 41 41 0.0
2093 | 41 42 46.0977
2094 | 41 43 46.6905
2095 | 41 44 35.609
2096 | 41 45 23.2594
2097 | 41 46 30.2655
2098 | 41 47 27.0185
2099 | 41 48 25.0
2100 | 41 49 17.8885
2101 | 42 0 52.6972
2102 | 42 1 81.2712
2103 | 42 2 50.5668
2104 | 42 3 22.0227
2105 | 42 4 99.1615
2106 | 42 5 48.5077
2107 | 42 6 84.9058
2108 | 42 7 69.527
2109 | 42 8 57.0088
2110 | 42 9 12.2066
2111 | 42 10 88.5494
2112 | 42 11 60.6053
2113 | 42 12 89.0449
2114 | 42 13 35.609
2115 | 42 14 71.4493
2116 | 42 15 97.1648
2117 | 42 16 29.4279
2118 | 42 17 44.5982
2119 | 42 18 96.0052
2120 | 42 19 68.4471
2121 | 42 20 69.8713
2122 | 42 21 29.4109
2123 | 42 22 94.8472
2124 | 42 23 35.5106
2125 | 42 24 65.0538
2126 | 42 25 43.9318
2127 | 42 26 81.3941
2128 | 42 27 107.3546
2129 | 42 28 34.6554
2130 | 42 29 74.027
2131 | 42 30 88.2043
2132 | 42 31 25.0799
2133 | 42 32 93.9042
2134 | 42 33 47.676
2135 | 42 34 47.2652
2136 | 42 35 43.6005
2137 | 42 36 85.0
2138 | 42 37 66.4831
2139 | 42 38 102.0
2140 | 42 39 72.9452
2141 | 42 40 82.0
2142 | 42 41 46.0977
2143 | 42 42 0.0
2144 | 42 43 88.6848
2145 | 42 44 21.9317
2146 | 42 45 52.0384
2147 | 42 46 75.5844
2148 | 42 47 41.6773
2149 | 42 48 49.2544
2150 | 42 49 37.4833
2151 | 43 0 47.5395
2152 | 43 1 38.6005
2153 | 43 2 75.591
2154 | 43 3 93.0484
2155 | 43 4 26.3059
2156 | 43 5 43.8634
2157 | 43 6 58.2409
2158 | 43 7 48.7955
2159 | 43 8 49.2443
2160 | 43 9 81.0062
2161 | 43 10 30.3645
2162 | 43 11 63.0079
2163 | 43 12 60.4152
2164 | 43 13 76.6616
2165 | 43 14 69.9714
2166 | 43 15 8.9443
2167 | 43 16 61.131
2168 | 43 17 72.8011
2169 | 43 18 47.0106
2170 | 43 19 21.2132
2171 | 43 20 19.0
2172 | 43 21 64.2806
2173 | 43 22 29.0689
2174 | 43 23 85.44
2175 | 43 24 70.8025
2176 | 43 25 49.2443
2177 | 43 26 29.1548
2178 | 43 27 61.4003
2179 | 43 28 65.5134
2180 | 43 29 64.4127
2181 | 43 30 60.6383
2182 | 43 31 65.0077
2183 | 43 32 5.3852
2184 | 43 33 45.1885
2185 | 43 34 101.2571
2186 | 43 35 66.4831
2187 | 43 36 31.7805
2188 | 43 37 25.0
2189 | 43 38 59.0339
2190 | 43 39 51.8845
2191 | 43 40 10.6301
2192 | 43 41 46.6905
2193 | 43 42 88.6848
2194 | 43 43 0.0
2195 | 43 44 70.8802
2196 | 43 45 38.2753
2197 | 43 46 20.0
2198 | 43 47 71.5122
2199 | 43 48 42.1545
2200 | 43 49 64.0312
2201 | 44 0 44.9444
2202 | 44 1 59.4811
2203 | 44 2 55.0091
2204 | 44 3 23.0217
2205 | 44 4 85.44
2206 | 44 5 28.0713
2207 | 44 6 63.2456
2208 | 44 7 63.2851
2209 | 44 8 50.6063
2210 | 44 9 23.0217
2211 | 44 10 76.6942
2212 | 44 11 59.4811
2213 | 44 12 67.424
2214 | 44 13 19.105
2215 | 44 14 51.225
2216 | 44 15 79.6994
2217 | 44 16 9.8489
2218 | 44 17 26.0
2219 | 44 18 74.0945
2220 | 44 19 52.3259
2221 | 44 20 52.9245
2222 | 44 21 26.3059
2223 | 44 22 82.201
2224 | 44 23 46.1736
2225 | 44 24 45.2217
2226 | 44 25 23.0
2227 | 44 26 69.527
2228 | 44 27 85.4751
2229 | 44 28 34.2345
2230 | 44 29 53.0377
2231 | 44 30 66.6108
2232 | 44 31 19.2354
2233 | 44 32 76.243
2234 | 44 33 27.0185
2235 | 44 34 40.8534
2236 | 44 35 44.4072
2237 | 44 36 73.6614
2238 | 44 37 51.6236
2239 | 44 38 80.1311
2240 | 44 39 51.1077
2241 | 44 40 65.7951
2242 | 44 41 35.609
2243 | 44 42 21.9317
2244 | 44 43 70.8802
2245 | 44 44 0.0
2246 | 44 45 32.7567
2247 | 44 46 61.0574
2248 | 44 47 45.0111
2249 | 44 48 29.2746
2250 | 44 49 36.4966
2251 | 45 0 32.0156
2252 | 45 1 34.6554
2253 | 45 2 57.1402
2254 | 45 3 54.7814
2255 | 45 4 55.8659
2256 | 45 5 6.4031
2257 | 45 6 47.4236
2258 | 45 7 47.0106
2259 | 45 8 37.6563
2260 | 45 9 46.5725
2261 | 45 10 49.93
2262 | 45 11 52.2015
2263 | 45 12 51.4296
2264 | 45 13 39.6989
2265 | 45 14 47.0
2266 | 45 15 47.1699
2267 | 45 16 23.1948
2268 | 45 17 38.0132
2269 | 45 18 50.2494
2270 | 45 19 21.9317
2271 | 45 20 21.4009
2272 | 45 21 33.8378
2273 | 45 22 54.037
2274 | 45 23 59.0339
2275 | 45 24 44.4072
2276 | 45 25 11.4018
2277 | 45 26 43.4166
2278 | 45 27 64.4438
2279 | 45 28 38.8973
2280 | 45 29 44.4072
2281 | 45 30 50.9902
2282 | 45 31 31.3847
2283 | 45 32 43.6578
2284 | 45 33 7.8102
2285 | 45 34 65.0692
2286 | 45 35 45.2217
2287 | 45 36 47.8853
2288 | 45 37 23.3238
2289 | 45 38 59.6657
2290 | 45 39 35.1141
2291 | 45 40 34.4093
2292 | 45 41 23.2594
2293 | 45 42 52.0384
2294 | 45 43 38.2753
2295 | 45 44 32.7567
2296 | 45 45 0.0
2297 | 45 46 32.0156
2298 | 45 47 49.0408
2299 | 45 48 4.2426
2300 | 45 49 38.9487
2301 | 46 0 28.6356
2302 | 46 1 49.2544
2303 | 46 2 55.9464
2304 | 46 3 84.0595
2305 | 46 4 24.4131
2306 | 46 5 38.4187
2307 | 46 6 68.0
2308 | 46 7 29.0689
2309 | 46 8 29.5466
2310 | 46 9 66.2873
2311 | 46 10 18.3848
2312 | 46 11 43.0116
2313 | 46 12 71.0634
2314 | 46 13 71.4213
2315 | 46 14 74.7262
2316 | 46 15 25.2982
2317 | 46 16 51.3128
2318 | 46 17 70.0
2319 | 46 18 61.4003
2320 | 46 19 10.2956
2321 | 46 20 12.3693
2322 | 46 21 48.3735
2323 | 46 22 22.0227
2324 | 46 23 67.082
2325 | 46 24 73.736
2326 | 46 25 43.1856
2327 | 46 26 13.0384
2328 | 46 27 76.5376
2329 | 46 28 48.0416
2330 | 46 29 70.406
2331 | 46 30 71.0282
2332 | 46 31 50.6952
2333 | 46 32 23.2594
2334 | 46 33 39.8246
2335 | 46 34 96.8969
2336 | 46 35 47.5395
2337 | 46 36 17.2627
2338 | 46 37 9.434
2339 | 46 38 73.2462
2340 | 46 39 58.5491
2341 | 46 40 9.434
2342 | 46 41 30.2655
2343 | 46 42 75.5844
2344 | 46 43 20.0
2345 | 46 44 61.0574
2346 | 46 45 32.0156
2347 | 46 46 0.0
2348 | 46 47 52.6308
2349 | 46 48 36.2353
2350 | 46 49 46.1736
2351 | 47 0 24.0416
2352 | 47 1 83.5464
2353 | 47 2 10.0
2354 | 47 3 61.3514
2355 | 47 4 71.007
2356 | 47 5 50.774
2357 | 47 6 95.7183
2358 | 47 7 33.2415
2359 | 47 8 24.0208
2360 | 47 9 29.5296
2361 | 47 10 58.1378
2362 | 47 11 20.0
2363 | 47 12 99.8599
2364 | 47 13 64.0078
2365 | 47 14 90.4765
2366 | 47 15 77.8845
2367 | 47 16 41.7732
2368 | 47 17 69.5845
2369 | 47 18 99.0353
2370 | 47 19 50.9902
2371 | 47 20 54.1202
2372 | 47 21 19.2354
2373 | 47 22 65.123
2374 | 47 23 15.0333
2375 | 47 24 85.7263
2376 | 47 25 50.0899
2377 | 47 26 52.0
2378 | 47 27 113.4548
2379 | 47 28 11.4018
2380 | 47 29 89.9611
2381 | 47 30 99.3227
2382 | 47 31 26.0768
2383 | 47 32 75.5844
2384 | 47 33 51.1077
2385 | 47 34 84.5281
2386 | 47 35 5.099
2387 | 47 36 54.1479
2388 | 47 37 46.6154
2389 | 47 38 108.706
2390 | 47 39 83.006
2391 | 47 40 61.6847
2392 | 47 41 27.0185
2393 | 47 42 41.6773
2394 | 47 43 71.5122
2395 | 47 44 45.0111
2396 | 47 45 49.0408
2397 | 47 46 52.6308
2398 | 47 47 0.0
2399 | 47 48 49.6488
2400 | 47 49 10.2956
2401 | 48 0 34.3657
2402 | 48 1 35.0
2403 | 48 2 58.1808
2404 | 48 3 50.9215
2405 | 48 4 60.1082
2406 | 48 5 2.2361
2407 | 48 6 46.1411
2408 | 48 7 50.1597
2409 | 48 8 40.1995
2410 | 48 9 44.5982
2411 | 48 10 54.0833
2412 | 48 11 54.3415
2413 | 48 12 50.2494
2414 | 48 13 35.4683
2415 | 48 14 44.1022
2416 | 48 15 51.0784
2417 | 48 16 20.0
2418 | 48 17 33.8378
2419 | 48 18 50.6063
2420 | 48 19 26.1725
2421 | 48 20 25.6125
2422 | 48 21 33.3017
2423 | 48 22 58.258
2424 | 48 23 58.7282
2425 | 48 24 41.1096
2426 | 48 25 7.2111
2427 | 48 26 47.5079
2428 | 48 27 64.3506
2429 | 48 28 39.0512
2430 | 48 29 41.9762
2431 | 48 30 49.7393
2432 | 48 31 30.0167
2433 | 48 32 47.5395
2434 | 48 33 3.6056
2435 | 48 34 60.8276
2436 | 48 35 46.1411
2437 | 48 36 51.9711
2438 | 48 37 27.4591
2439 | 48 38 59.4138
2440 | 48 39 33.541
2441 | 48 40 38.6005
2442 | 48 41 25.0
2443 | 48 42 49.2544
2444 | 48 43 42.1545
2445 | 48 44 29.2746
2446 | 48 45 4.2426
2447 | 48 46 36.2353
2448 | 48 47 49.6488
2449 | 48 48 0.0
2450 | 48 49 39.4081
2451 | 49 0 18.1108
2452 | 49 1 73.5527
2453 | 49 2 19.6469
2454 | 49 3 55.0091
2455 | 49 4 66.7533
2456 | 49 5 40.4969
2457 | 49 6 85.44
2458 | 49 7 32.45
2459 | 49 8 20.6155
2460 | 49 9 25.4951
2461 | 49 10 54.5711
2462 | 49 11 23.7065
2463 | 49 12 89.5879
2464 | 49 13 55.1453
2465 | 49 14 80.3243
2466 | 49 15 71.0211
2467 | 49 16 32.1403
2468 | 49 17 60.1332
2469 | 49 18 89.0955
2470 | 49 19 43.0116
2471 | 49 20 45.8803
2472 | 49 21 10.198
2473 | 49 22 61.3922
2474 | 49 23 21.5407
2475 | 49 24 75.6902
2476 | 49 25 39.8121
2477 | 49 26 47.8539
2478 | 49 27 103.3925
2479 | 49 28 2.8284
2480 | 49 29 79.7057
2481 | 49 30 89.0449
2482 | 49 31 17.2627
2483 | 49 32 68.4471
2484 | 49 33 40.8167
2485 | 49 34 76.922
2486 | 49 35 8.0
2487 | 49 36 50.6952
2488 | 49 37 39.0512
2489 | 49 38 98.5951
2490 | 49 39 72.7186
2491 | 49 40 54.7449
2492 | 49 41 17.8885
2493 | 49 42 37.4833
2494 | 49 43 64.0312
2495 | 49 44 36.4966
2496 | 49 45 38.9487
2497 | 49 46 46.1736
2498 | 49 47 10.2956
2499 | 49 48 39.4081
2500 | 49 49 0.0
2501 | 


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