SF2311 / travelling-salesman (public) (License: Unspecified) (since 2018-04-18) (hash sha1)
No description available
Clone URLs: https://rocketgit.com/user/SF2311/travelling-salesman ssh://rocketgit@ssh.rocketgit.com/user/SF2311/travelling-salesman git://git.rocketgit.com/user/SF2311/travelling-salesman
dev master
List of commits:
Subject Hash Author Date (UTC)
changed type of Cities-Array to List 32ef3b6c00071c11b0e1cc677f1158325da259a7 SF2311 2018-05-29 14:57:56
started implementing Simulated annealing 0a646cfa5b69d38aaeeefebc5950955c32340ad6 SF2311 2018-05-09 13:24:39
ready for update 9291ca0919c7344123342da1d1bf613b91e8b885 SF2311 2018-05-09 12:02:25
finished 2-Opt-algorithm 77fe988c5101d80ee3362ee69a6c949f32589edf SF2311 2018-05-05 16:24:59
fixed gui problems 0688b215d9601d49a00aebc0732164216fe4a2f4 SF2311 2018-05-03 10:48:19
improved visualization, added thread safety 89adf0d0bfe610fde9199ec8145c5d8a91fae33f SF2311 2018-05-02 08:48:40
implemented first version of visualization a218089ef758c0fd525d3bbe16163d71eb4c6833 SF2311 2018-04-25 20:32:26
implemented first version of 2-opt-change algorithm 376954bfb1e24116e0935d70263c0ec0c2792b92 SF2311 2018-04-25 16:29:06
just to update 2fa820634306068c8a97315ecb29661604bb34dc SF2311 2018-04-25 14:21:33
Merge branch 'dev' of T:\GIPS\Klassen\2017_GIPS_J1\Informatik JB\ts into dev 0fa550b00774b011f7e87ef1ac5b8fbdb9abb0bc ani.moosb 2018-04-25 13:25:48
prepared data structure ad7e293e1679e05d274ebcacf043522c2f3e8f5c SF2311 2018-04-25 13:21:54
new class Algorythm to implement BrutForce algorithm cd2f3565cc145dd9f14290b727f74ea0281ef2c7 ani.moosb 2018-04-25 13:12:14
prepared data structure 0d55315b39e973974793aadfc188dc9e055ef029 SF2311 2018-04-25 13:10:50
added class City for represnetation of data 057841348e42a9bf916d6b5bf8d8f069a8e4f555 SF2311 2018-04-25 12:42:18
new class Algorythm to implement BrutForce algorithm c0ba57e67447133ed5b2fcde4cc9c6a2c61a1036 ani.moosb 2018-04-25 12:29:31
Fixed menu loading problems 9858b4b11fd912d8b40e681b772bf0ef16678ca6 SF2311 2018-04-20 17:07:20
Added Menu loading 428354d568e6bf97e45ec4c416ce9b3db227eea4 SF2311 2018-04-20 16:12:55
designed main window added launching main window added first menu part in form of gridpane 1f4e52733f4aeb9524fb0f40f8cf7604aaf17898 SF2311 2018-04-19 16:15:30
prepared User interface cfad65413554fbd7a1026f2c8e73e73e996df69d SF2311 2018-04-18 18:51:26
initial commit 272ab94837f2e39f77b768df08a25a78466d52d1 SF2311 2018-04-18 18:43:17
Commit 32ef3b6c00071c11b0e1cc677f1158325da259a7 - changed type of Cities-Array to List
Author: SF2311
Author date (UTC): 2018-05-29 14:57
Committer name: SF2311
Committer date (UTC): 2018-05-29 14:57
Parent(s): 0a646cfa5b69d38aaeeefebc5950955c32340ad6
Signer:
Signing key:
Signing status: N
Tree: 6723fefeeb1cb66795346f639822b4437e0d7969
File Lines added Lines deleted
src/salesman/algorithms/AlgorithmBrutForce.java 1 1
src/salesman/algorithms/Opt2.java 4 5
src/salesman/algorithms/SimAnn.java 3 3
src/salesman/data/Data.java 13 12
src/salesman/data/ObservableOrder.java 5 6
src/salesman/data/Order.java 14 16
src/salesman/ui/MainWindowController.java 6 6
File src/salesman/algorithms/AlgorithmBrutForce.java changed (mode: 100644) (index 434de76..fe8ec8a)
... ... import java.util.Random;
8 8 public class AlgorithmBrutForce extends Thread{ public class AlgorithmBrutForce extends Thread{
9 9 private MainWindowController mwc; private MainWindowController mwc;
10 10
11 City[] cities = new City[MainWindowController.data.getCities().length];
11 City[] cities = new City[MainWindowController.data.getCities().size()];
12 12
13 13 @Override @Override
14 14 public void run(){ public void run(){
File src/salesman/algorithms/Opt2.java changed (mode: 100644) (index db68845..5b02c0a)
... ... import salesman.ui.MainWindowController;
12 12 import java.util.Random; import java.util.Random;
13 13
14 14 public class Opt2 extends Thread { public class Opt2 extends Thread {
15 private Order currentOrder;
16 15 private int currentLength; private int currentLength;
17 16 private double[][] distances = MainWindowController.data.getDistances(); private double[][] distances = MainWindowController.data.getDistances();
18 17 private Random r = new Random(); private Random r = new Random();
 
... ... public class Opt2 extends Thread {
23 22 DateTime start = new DateTime(); DateTime start = new DateTime();
24 23 MainWindowController.data.setAlgorithmRunning(true); MainWindowController.data.setAlgorithmRunning(true);
25 24 int count = 0; int count = 0;
26 double cancelCondition= MainWindowController.data.getCities().length*MainWindowController.data.getCities().length-1;
27 currentOrder = Order.getRandomOrder(MainWindowController.data.getCities());
25 double cancelCondition= MainWindowController.data.getCities().size()*MainWindowController.data.getCities().size()-1;
26 Order currentOrder = Order.getRandomOrder(MainWindowController.data.getCities().size());
28 27
29 28
30 29 while (count<cancelCondition) { while (count<cancelCondition) {
 
... ... public class Opt2 extends Thread {
33 32 return; return;
34 33 } }
35 34
36 currentLength = currentOrder.getTotalLength();
35 currentLength = currentOrder.getTotalLength(MainWindowController.data.getCities());
37 36 int index1 = r.nextInt(currentOrder.getSize()), index2 = r.nextInt(currentOrder.getSize()); int index1 = r.nextInt(currentOrder.getSize()), index2 = r.nextInt(currentOrder.getSize());
38 37 currentOrder.swapValues(index1, index2); currentOrder.swapValues(index1, index2);
39 38 MainWindowController.data.getCurrentOrder().setOrder(currentOrder.getOrder()); MainWindowController.data.getCurrentOrder().setOrder(currentOrder.getOrder());
40 39
41 40 System.out.println("change: "+System.currentTimeMillis()); System.out.println("change: "+System.currentTimeMillis());
42 41
43 if (currentOrder.getTotalLength() < currentLength) {
42 if (currentOrder.getTotalLength(MainWindowController.data.getCities()) < currentLength) {
44 43 MainWindowController.data.setBestEver(currentOrder); MainWindowController.data.setBestEver(currentOrder);
45 44 count =0; count =0;
46 45 }else{ }else{
File src/salesman/algorithms/SimAnn.java changed (mode: 100644) (index 0d96966..a69eee1)
... ... import salesman.ui.MainWindowController;
7 7 import java.util.Random; import java.util.Random;
8 8
9 9 public class SimAnn extends Thread { public class SimAnn extends Thread {
10 private Order currentOrder = Order.getRandomOrder(MainWindowController.data.getCities());
10 private Order currentOrder = Order.getRandomOrder(MainWindowController.data.getCities().size());
11 11 private Random r = new Random(); private Random r = new Random();
12 private int bestLength =currentOrder.getTotalLength();
12 private int bestLength =currentOrder.getTotalLength(MainWindowController.data.getCities());
13 13 private double sigma = 1000000; private double sigma = 1000000;
14 14
15 15 @Override @Override
 
... ... public class SimAnn extends Thread {
29 29
30 30 currentOrder.swapValues(a, b); currentOrder.swapValues(a, b);
31 31 MainWindowController.data.getCurrentOrder().setOrder(currentOrder.getOrder()); MainWindowController.data.getCurrentOrder().setOrder(currentOrder.getOrder());
32 if (currentOrder.getTotalLength() < bestLength) {
32 if (currentOrder.getTotalLength(MainWindowController.data.getCities()) < bestLength) {
33 33 MainWindowController.data.setBestEver(currentOrder); MainWindowController.data.setBestEver(currentOrder);
34 34 } else { } else {
35 35 //TODO implement probability decision //TODO implement probability decision
File src/salesman/data/Data.java changed (mode: 100644) (index 129a010..e29ae6a)
... ... import javafx.beans.value.ChangeListener;
4 4 import javafx.beans.value.ObservableValue; import javafx.beans.value.ObservableValue;
5 5 import salesman.ui.MainWindowController; import salesman.ui.MainWindowController;
6 6
7 import java.util.ArrayList;
8 import java.util.List;
7 9 import java.util.Random; import java.util.Random;
8 10 import java.util.concurrent.atomic.AtomicBoolean; import java.util.concurrent.atomic.AtomicBoolean;
9 11 import java.util.concurrent.atomic.AtomicReference; import java.util.concurrent.atomic.AtomicReference;
10 12
11 13 public class Data { public class Data {
12 private City[] cities;
14 private List<City> cities;
13 15 private double[][] distances; private double[][] distances;
14 16 private AtomicReference<Order> bestEver=new AtomicReference<>(); private AtomicReference<Order> bestEver=new AtomicReference<>();
15 17 private AtomicBoolean algorithmRunning=new AtomicBoolean(false),measurement=new AtomicBoolean(false); private AtomicBoolean algorithmRunning=new AtomicBoolean(false),measurement=new AtomicBoolean(false);
 
... ... public class Data {
18 20
19 21
20 22 public Data(int number){ public Data(int number){
21 cities=new City[number];
23 cities=new ArrayList();
22 24 distances=new double[number][ number]; distances=new double[number][ number];
23 currentOrder.set(ObservableOrder.getRandomOrder(cities));
25 currentOrder.set(ObservableOrder.getRandomOrder(number));
24 26 currentOrder.get().addListener(new ArrayListener()); currentOrder.get().addListener(new ArrayListener());
25 27 generateNewCities(number); generateNewCities(number);
26 28 }//constructor int number }//constructor int number
27 29
28 public Data(City[] cities){
30 public Data(List<City> cities){
29 31 this.cities=cities; this.cities=cities;
30 int number=cities.length;
32 int number=cities.size();
31 33
32 34 distances=new double[number][ number]; distances=new double[number][ number];
33 35
 
... ... public class Data {
35 37 for (int j = 0; j < number; j++) { for (int j = 0; j < number; j++) {
36 38 /* int deltaX= cities[j].getX()-cities[i].getX(); /* int deltaX= cities[j].getX()-cities[i].getX();
37 39 int deltaY = cities[j].getY()-cities[i].getY();*/ int deltaY = cities[j].getY()-cities[i].getY();*/
38 distances[i][j] = City.getDistancce(cities[i],cities[j]);//Math.sqrt((deltaX*deltaX)+(deltaY*deltaY));
40 distances[i][j] = City.getDistancce(cities.get(i),cities.get(j));//Math.sqrt((deltaX*deltaX)+(deltaY*deltaY));
39 41 } }
40 42 } }
41 43
 
... ... public class Data {
43 45 //constructor City[] //constructor City[]
44 46 } }
45 47
46 public City[] getCities() {
48 public List<City> getCities() {
47 49 return cities; return cities;
48 50 } }
49 51
 
... ... public class Data {
56 58
57 59 public void generateNewCities(int number){ public void generateNewCities(int number){
58 60 Random r = new Random(); Random r = new Random();
59 cities=new City[number];
61 cities = new ArrayList<>();
60 62 distances=new double[number][number]; distances=new double[number][number];
61 63
62 64 for(int i=0;i<number;i++){ for(int i=0;i<number;i++){
63 cities[i] = new City(r.nextInt(770),r.nextInt(560),i);
65 cities.add(new City(r.nextInt(770),r.nextInt(560),i));
64 66 } }
65 67
66 68 for (int i = 0; i <number; i++) { for (int i = 0; i <number; i++) {
67 69 for (int j = 0; j < number; j++) { for (int j = 0; j < number; j++) {
68 distances[i][j]=City.getDistancce(cities[i],cities[j]);
70 distances[i][j]=City.getDistancce(cities.get(i),cities.get(j));
69 71 } }
70 72 } }
71 currentOrder.get().setCities(cities);
72 currentOrder.get().setOrder(ObservableOrder.getRandomOrder(cities).order);
73 currentOrder.get().setOrder(ObservableOrder.getRandomOrder(cities.size()).order);
73 74 } }
74 75
75 76 public Order getBestEver() { public Order getBestEver() {
File src/salesman/data/ObservableOrder.java changed (mode: 100644) (index 8f868ca..0a5a2c7)
... ... import java.util.Random;
11 11 public class ObservableOrder extends Order implements ObservableObjectValue { public class ObservableOrder extends Order implements ObservableObjectValue {
12 12 private List<ChangeListener> changeListeners = new ArrayList(); private List<ChangeListener> changeListeners = new ArrayList();
13 13
14 public ObservableOrder(City[] cities){
15 super(cities);
14 public ObservableOrder(int length){
15 super(length);
16 16 } }
17 17
18 18 private ObservableOrder(Order order){ private ObservableOrder(Order order){
19 super(order.cities);
19 super(order.order.length);
20 20 this.order=order.order; this.order=order.order;
21 this.cities=order.cities;
22 21 } }
23 22
24 public static ObservableOrder getRandomOrder(City[] cities){
25 return new ObservableOrder(Order.getRandomOrder(cities));
23 public static ObservableOrder getRandomOrder(int length){
24 return new ObservableOrder(Order.getRandomOrder(length));
26 25 } }
27 26
28 27 @Override @Override
File src/salesman/data/Order.java changed (mode: 100644) (index 1fd039b..39d162a)
... ... import java.util.Random;
8 8
9 9 public class Order { public class Order {
10 10 protected int[] order; protected int[] order;
11 protected City[] cities;
12 11
13 12
14 13
15 public Order(City[] cities){
16 order=new int[cities.length];
17 this.cities=cities;
14
15 public Order(int length){
16 order=new int[length];
17
18 18 } }
19 19
20 20
 
... ... public class Order {
27 27 order[index]=toSet; order[index]=toSet;
28 28 } }
29 29
30 public int getTotalLength(){
30 public int getTotalLength(List<City> cities){
31 31 int length=0; int length=0;
32 32 double[][] dist = MainWindowController.data.getDistances(); double[][] dist = MainWindowController.data.getDistances();
33 33
34 34 for (int i = 0; i < order.length; i++) { for (int i = 0; i < order.length; i++) {
35 City current = cities[order[i]];
35 City current = cities.get(order[i]);
36 36 City next; City next;
37 37 try { try {
38 next = cities[order[i + 1]];
38 next = cities.get(order[i + 1]);
39 39 }catch (ArrayIndexOutOfBoundsException e){ }catch (ArrayIndexOutOfBoundsException e){
40 next = cities[order[0]];
40 next = cities.get(order[0]);
41 41 } }
42 42 length+= dist[current.getID()][next.getID()]; length+= dist[current.getID()][next.getID()];
43 43 } }
 
... ... public class Order {
45 45 } }
46 46
47 47 public int getSize(){ public int getSize(){
48 return cities.length;
48 return order.length;
49 49 } }
50 50
51 51 public void swapValues(int index1 , int index2){ public void swapValues(int index1 , int index2){
 
... ... public class Order {
63 63 public void setOrder(int[] order){ public void setOrder(int[] order){
64 64 this.order = order; this.order = order;
65 65 } }
66 public void setCities(City[] cities){
67 this.cities=cities;
68 }
69 66
70 public static Order getRandomOrder(City[] cities){
67
68 public static Order getRandomOrder(int length){
71 69 List<Integer> list = new ArrayList(); List<Integer> list = new ArrayList();
72 for (int i = 0; i <cities.length; i++) {
70 for (int i = 0; i <length; i++) {
73 71 list.add(i); list.add(i);
74 72 } }
75 Order toReturn = new Order(cities);
73 Order toReturn = new Order(length);
76 74 Random r = new Random(); Random r = new Random();
77 for (int i = 0; i < cities.length; i++) {
75 for (int i = 0; i < length; i++) {
78 76 int next =r.nextInt(list.size()); int next =r.nextInt(list.size());
79 77 toReturn.setValue(i,list.get(next)); toReturn.setValue(i,list.get(next));
80 78 list.remove(next); list.remove(next);
File src/salesman/ui/MainWindowController.java changed (mode: 100644) (index e6aaa66..0ac6541)
... ... public class MainWindowController {
139 139 gc.setLineWidth(1); gc.setLineWidth(1);
140 140 gc.setFill((Color.GRAY)); gc.setFill((Color.GRAY));
141 141 for (int i = 0; i < currentOrder.getSize(); i++) { for (int i = 0; i < currentOrder.getSize(); i++) {
142 City current = data.getCities()[currentOrder.getValue(i)];
142 City current = data.getCities().get(currentOrder.getValue(i));
143 143 City next; City next;
144 144 if ((i + 1) > numCities - 1) { if ((i + 1) > numCities - 1) {
145 next = data.getCities()[currentOrder.getValue(0)];
145 next = data.getCities().get(currentOrder.getValue(0));
146 146 } else { } else {
147 next = data.getCities()[currentOrder.getValue(i + 1)];
147 next = data.getCities().get(currentOrder.getValue(i + 1));
148 148 } }
149 149
150 150
 
... ... public class MainWindowController {
162 162 gc.setLineWidth(3); gc.setLineWidth(3);
163 163 gc.setFill((Color.GRAY)); gc.setFill((Color.GRAY));
164 164 for (int i = 0; i < best.getSize(); i++) { for (int i = 0; i < best.getSize(); i++) {
165 City current = data.getCities()[best.getValue(i)];
165 City current = data.getCities().get(best.getValue(i));
166 166 City next; City next;
167 167 if ((i + 1) > numCities - 1) { if ((i + 1) > numCities - 1) {
168 next = data.getCities()[best.getValue(0)];
168 next = data.getCities().get(best.getValue(0));
169 169 } else { } else {
170 next = data.getCities()[best.getValue(i + 1)];
170 next = data.getCities().get(best.getValue(i + 1));
171 171 } }
172 172
173 173
Hints:
Before first commit, do not forget to setup your git environment:
git config --global user.name "your_name_here"
git config --global user.email "your@email_here"

Clone this repository using HTTP(S):
git clone https://rocketgit.com/user/SF2311/travelling-salesman

Clone this repository using ssh (do not forget to upload a key first):
git clone ssh://rocketgit@ssh.rocketgit.com/user/SF2311/travelling-salesman

Clone this repository using git:
git clone git://git.rocketgit.com/user/SF2311/travelling-salesman

You are allowed to anonymously push to this repository.
This means that your pushed commits will automatically be transformed into a merge request:
... clone the repository ...
... make some changes and some commits ...
git push origin main