Group 1:
Yang: The only thing we did was to top sort the planes like a tree. The planes are a leaf and their parent is the time of the flight it is dependent on. We are using this to order the plane’s takeoff.
Vishwa <absent>
Hari
Group 2:
Harjot <absent>
Tieram: Given that we cannot go through and simulate everything, the chain of dependencies are a good heuristic
Sam: The main thing that we still need to fix is preferring planes that have other dependencies. We take everything off as soon as possible. When a plane gets into a hub with a lot of planes we do not prioritize the planes that have dependencies. The flight with the longest chain of dependencies.
Group 3
Marcus
Hao
Franklin
Group 4
Tanay
Yigit:
Tim: We assign a total time to every flight which is the cumulative sum of that flight’s departure time, the distance of the flight, and the longest total time of all its dependency. Build up a stock of dependencies. We prioritize those by sending them first to the flight route generator. It is hard to look at the board and seeing how to optimize the strategy like you could with the standard game.
Group 5
Tanveer <absent>
Lauren: We continued to look at different priority algorithms. We sort off of the departure plane and flight path with dependencies.
Jinesh: the one plane is making a semi circle because we decided that it was better to take off then to delay.
Group 6
Di <excused absence>
Patrick: we make a hash set of when the planes arrive. If the plane has no dependencies, then we take them off list. We launch the plane that will arrive later.
Monday, December 9, 2013
Thursday, December 5, 2013
Airplanes 12/03
Group 1:
Yang: We are changed our method to look at both the delay and different angles. We can now let the plane that is arriving latest to take off first. The hard problem will be if you set all the planes at time 0, since it would be hard to prioritize. This change of strategy improves almost all the boards, only Test 10 round flights 10 planes each did not do better. The reason is, if you assign for delay then you will create a small flow and block part of the board. We are focusing on minimizing the delay only since it is hard to measure throughput. For the dependent planes, we made the plane not take off until all the planes it is dependent on have landed. We are thinking of using the entire flights with the connecting flights counted.
Vishwa: The plane flight path will effect other planes in tight pack. The first path curves, so the next one curves and so on. Complications only really happen when there is a lot of planes on the board and a lot of collisions.
Hari
Group 2:
Harjot: We made a change to make the plane take off even if there will be a crash and depend on A* to avoid the
Tieram: Our strategy does not allow planes to take off before they are able to.
Sam: Dependancies mostly worked out of the box, we just had to remove the sorting. We were doing a simple sorting of distance. Moving forward we want to create a better sorting algorithm. We are now sorting by distance and want to have a series of candidates, with the flights with no dependancies take off first.
Group 3
Marcus: We are implementing a graph algorithm to change the planning queue for launching planes. We are first looking at departure time, then the dependent flight’s take departure time. This should still preserve the longest path straight, even with connections.
Hao
Franklin: This new development in the simulation makes it easier, since the dependencies makes it easier to prioritize the flights.
Group 4
Tanay:
Yigit:
Tim: We sort the planes by the total path of the plan’s distance and their dependent plane’s distance. We spent the first part of the break, refactoring and cleaning up code. We then started looking at the dependance problem. We fit our code to the new situation, delaying the planes until their dependent plane has landed. We changed the sorting method of plane deployment for the largest total flight (looking at the multiple flight as one long flight). We are having a problem with using both non-deterministic deployment and deterministic deployment.
Group 5
Tanveer
Lauren: did not make any changed to the original player. We tried out a number of different orderings and recorded the results. Non of them really stand out as the best orderings.
Jinesh <Absent>
Group 6
Di: modified the last solution a bit to fix the gap between the planes in the tight pack board. For the dependancies, we are currently debugging. We are prioritizing the plane that has the most dependancies and the longest distance.
Patrick
Yang: We are changed our method to look at both the delay and different angles. We can now let the plane that is arriving latest to take off first. The hard problem will be if you set all the planes at time 0, since it would be hard to prioritize. This change of strategy improves almost all the boards, only Test 10 round flights 10 planes each did not do better. The reason is, if you assign for delay then you will create a small flow and block part of the board. We are focusing on minimizing the delay only since it is hard to measure throughput. For the dependent planes, we made the plane not take off until all the planes it is dependent on have landed. We are thinking of using the entire flights with the connecting flights counted.
Vishwa: The plane flight path will effect other planes in tight pack. The first path curves, so the next one curves and so on. Complications only really happen when there is a lot of planes on the board and a lot of collisions.
Hari
Group 2:
Harjot: We made a change to make the plane take off even if there will be a crash and depend on A* to avoid the
Tieram: Our strategy does not allow planes to take off before they are able to.
Sam: Dependancies mostly worked out of the box, we just had to remove the sorting. We were doing a simple sorting of distance. Moving forward we want to create a better sorting algorithm. We are now sorting by distance and want to have a series of candidates, with the flights with no dependancies take off first.
Group 3
Marcus: We are implementing a graph algorithm to change the planning queue for launching planes. We are first looking at departure time, then the dependent flight’s take departure time. This should still preserve the longest path straight, even with connections.
Hao
Franklin: This new development in the simulation makes it easier, since the dependencies makes it easier to prioritize the flights.
Group 4
Tanay:
Yigit:
Tim: We sort the planes by the total path of the plan’s distance and their dependent plane’s distance. We spent the first part of the break, refactoring and cleaning up code. We then started looking at the dependance problem. We fit our code to the new situation, delaying the planes until their dependent plane has landed. We changed the sorting method of plane deployment for the largest total flight (looking at the multiple flight as one long flight). We are having a problem with using both non-deterministic deployment and deterministic deployment.
Group 5
Tanveer
Lauren: did not make any changed to the original player. We tried out a number of different orderings and recorded the results. Non of them really stand out as the best orderings.
Jinesh <Absent>
Group 6
Di: modified the last solution a bit to fix the gap between the planes in the tight pack board. For the dependancies, we are currently debugging. We are prioritizing the plane that has the most dependancies and the longest distance.
Patrick
Tuesday, December 3, 2013
Airplane 11/26
Group 1:
Yang:
Vishwa: Doing data analysis with excel. Trying to figure out with player better. The only board that has significant differences is in the stream
Hari:
Group 2:
Harjot: Added flow detection, so we are doing much better at those boards. Create a white box to show the obstacles during the flight. Once a flow is detected, those planes do not use A*, they just follow the flow path. We set up flow, buy seeing how many planes are in the flows and how long it is.
Tieram: <Excused>
Sam: We detect where the planes will collide and will create an obstacle at the location. To detect flows by how many planes are in the same distance. We give prescience to the longest flow and create waypoints around it.
Group 3
Marcus:
Hao: We have made improvements for the delay and detour. If we cannot find an angle that avoids the crash in 10 rounds, then just delay.
Franklin: We had the issue where our simulator was not working. We have fixed this. If there is a head on collision, then find an arch path to run. Our player runs a lot of simulators so it takes a while. We are looking into detecting flows, also looking at waypoints to get around the flows. We don’t detect head on collisions very well.
Group 4
Tanay: Were doing very poorly on the flows and on tight pack. We do poorly on these because we don’t look forward enough, we only look 30 steps ahead. We are looking at arcs and going around flows using having waypoints
Yigit:
Tim: <Absent>
Group 5
Tanveer: We have better collisions detection, but otherwise we have the same strategy. We have three movement patterns, a straight line, a curved takeoff and A*. We are not doing any calculation on whether it is better to take off and move around or to delay.
Lauren: We were looking into moving planes into safe zones, but we found that there are a lot of calculations and real time analysis. We decided that it was not worth continuing since it would only be useful on certain boards.
Jinesh:
Group 6
Di: Trying to schedule the plane to go directly to the destination, then delay by one. Prioritizing the plane with the longest flight. We will try to detour the planes if we can. Find that most of the planes are delayed. The detour will make the plane take off at another angle and then turn back to its destination.
Patrick <Excused>
Yang:
Vishwa: Doing data analysis with excel. Trying to figure out with player better. The only board that has significant differences is in the stream
Hari:
Group 2:
Harjot: Added flow detection, so we are doing much better at those boards. Create a white box to show the obstacles during the flight. Once a flow is detected, those planes do not use A*, they just follow the flow path. We set up flow, buy seeing how many planes are in the flows and how long it is.
Tieram: <Excused>
Sam: We detect where the planes will collide and will create an obstacle at the location. To detect flows by how many planes are in the same distance. We give prescience to the longest flow and create waypoints around it.
Group 3
Marcus:
Hao: We have made improvements for the delay and detour. If we cannot find an angle that avoids the crash in 10 rounds, then just delay.
Franklin: We had the issue where our simulator was not working. We have fixed this. If there is a head on collision, then find an arch path to run. Our player runs a lot of simulators so it takes a while. We are looking into detecting flows, also looking at waypoints to get around the flows. We don’t detect head on collisions very well.
Group 4
Tanay: Were doing very poorly on the flows and on tight pack. We do poorly on these because we don’t look forward enough, we only look 30 steps ahead. We are looking at arcs and going around flows using having waypoints
Yigit:
Tim: <Absent>
Group 5
Tanveer: We have better collisions detection, but otherwise we have the same strategy. We have three movement patterns, a straight line, a curved takeoff and A*. We are not doing any calculation on whether it is better to take off and move around or to delay.
Lauren: We were looking into moving planes into safe zones, but we found that there are a lot of calculations and real time analysis. We decided that it was not worth continuing since it would only be useful on certain boards.
Jinesh:
Group 6
Di: Trying to schedule the plane to go directly to the destination, then delay by one. Prioritizing the plane with the longest flight. We will try to detour the planes if we can. Find that most of the planes are delayed. The detour will make the plane take off at another angle and then turn back to its destination.
Patrick <Excused>
Subscribe to:
Posts (Atom)