School of Informatics, University of Edinburgh

Transcription

1 CS1Ah Practical 4 Motorway Madness This is an individual practical exercise which requires you to submit some files electronically. A system which measures software similarity will be used to compare all of the submissions in order to detect unreasonable levels of collaboration. Your attention is drawn to the guidelines on plagiarism presented in Appendix A of the Computer Science 1 course guide. This practical has been issued on Thursday 5th December The deadline for your solutions is Wednesday 15th January 2003 at 5pm. Your solutions must be submitted electronically from your DICE account with the handin command (which is a short-hand version of the submit command). No alternative methods of submission will be accepted. Specifically, submissions via will not be accepted and submissions on floppy disk will not be accepted. No late submissions will be accepted. To submit your files, execute the handin command exactly as it is shown in this document. In particular, make sure that you use the correct practical identifiers, filenames and extensions. Remember that all names are case-sensitive. Failure to execute the proper submission command cannot be investigated after the practical deadline. Execute the handin command from a shell window (not the KDE command Run Command window), so you can see any error messages which result. If in doubt, consult a laboratory demonstrator for assistance. You can repeat the handin command to resubmit improved versions of your work; later submissions will override earlier ones. But do not resubmit after the deadline: your work would be treated as a late submission. The four practical exercises in Computer Science 1Ah are equally weighted and together they constitute 25% of the final mark for the course. For each practical, a mark out of 25 is recorded. For this practical, parts A, B and D carry six marks, while part C carries seven marks. 1

2 Introduction When driving on motorways in particular, some traffic congestion is fairly comprehensible (tailbacks from roadworks etc.), while other congestion is more mysterious, appearing to have no simple direct cause. This practical involves using a very simple road model in order to simulate traffic flows, and the knock-on effects of some hindrances made to these flows. The practical will give you further practice in programming in Java, and using classes and their methods. In particular, you will make use of an array that is maintained in sorted order, and carry out various operations on its elements. Unlike earlier practicals, you will have less material given as a starting point, and so will gain some experience in programming from scratch. Simulated road General modelling of road systems is complex, often requiring the brute-force power of supercomputers. Here, however, our model is very simple, both in terms of the road system and in terms of the behaviour of drivers. Our road will be a single lane, with cars flowing in one direction; initially, cars can join at the beginning only, and leave at the end only. All distances will be specified in metres, all times in seconds, and hence all speeds in metres per second. We will have a road that is 20,000 metres (i.e. 20km) long, with a default speed limit of 40 metres/second (i.e. 144 km/h). Thus, if a car is able to travel at the maximum speed throughout, it can traverse the road in 500 seconds. Each car is assumed to occupy five metres of road space (so one can infer that there cannot be more than 4000 cars on this road at once). We will simulate the flow of cars along this road over a period of 2000 seconds. The simulation will proceed as a series of 2000 iterations, each simulating what happens during one second. In each second, one car might join the road, one car might leave the road and all other cars on the road will move forward according to current conditions (unless they are stationary in a traffic jam, of course). In terms of cars joining the road, we use a simple model. This says that a new car will start along the road as soon as there is room for it, that is, there is a continuous supply of incoming traffic. Java classes Two Java classes will be central to this exercise. The first one, which is supplied to you, represents a car on the road. This records the car s length (always fixed at five metres), its current distance along the road and its current speed. The current distance is taken as the distance of the rear of the car from the beginning of the road. The other central class, which you have to develop, is one that represents the current state of the road. This includes the road s length and its global speed limit, set when the road is created. The speed limit is modelled by an object which can be queried to return the speed limit in force at any given point on the road. Aside from this, in the first instance, there is just the current collection of cars on the road. For this, the road class uses an array of cars. When there are n cars on the road, elements 0 to n 1 of this array hold the car objects, ordered by increasing distance along the road. 2

3 In later stages of the exercise, two other classes will be added. One represents a speed restriction over some part of the road. The other represents a junction feeding in further traffic at some point on the road. The above classes are all used from a top-level class, which runs the road simulation over a set period of time. In order to visualise the state of the traffic on the road at the end of the simulated period (or indeed, at any intermediate time point in the simulation), we use something which we call a speedgram. This shows car speeds along the length of the road you can see examples of speedgrams in the appendix at the end of this handout. The speedgram gives an easy way of spotting where congestion is occurring, and makes it possible to relate this to deliberate disruptions to the traffic flow. A speedgram class is supplied, allowing you to visualise road states easily. Getting Started Before starting the practical you should make your own copy of the files in the directory /group/teaching/cs1/ah/pracs/motorwaymadness. You can do this efficiently using the command: cp -r /group/teaching/cs1/ah/pracs/motorwaymadness You should only enter the above command once. If you use it a second time you will overwrite your copy of the practical and you will lose the work which you have done. Your home directory will now contain a directory MotorwayMadness containing six Java files. During this practical, you will have to modify two of these (Simulation.java and SpeedLimit.java), as well as creating some new Java files of your own. The other Java files (TestA.java, Car.java, Speedgram.java and SpeedgramWindow.java)are for you to use unchanged. If at all possible, you should avoid submitting code that doesn t compile. Start the practical early and consult a demonstrator if you are having problems figuring things out for yourself. If nevertheless you contemplate submitting code that has compile errors, please comment out the offending code and add a comment explaining what error message you were getting and what you don t understand. By commenting out, you should always be able to get your code back into a state where it compiles. Working on your computer at home If you have access to a computer at home, you may wish to use it when doing some of your practical work. For this you will need a copy of Sun s Java Development Kit Version 1.4 or similar. You can obtain it from Sun s Web site at java.sun.com or it is available on the CD-ROM included with the textbook, Java: How to Program by Deitel and Deitel. You will need to make a copy of the MotorwayMadness directory. If you have Internet access, the most convenient way to do this is to copy files from the web, although this is tedious. A better way is to use the secure copy command scp to remotely copy files from your DICE account. Another way, or if you do not have Internet access, is to take the files home on a floppy disk. On the DICE machines, the command mcopy can be used to copy files onto 3

4 a DOS formatted floppy disk. If you work at home on a Windows machine, you might want to use mcopy -t to copy files onto your floppy. This fixes up Linux line breaks so that Windows editors will recognise them. Please consult a lab demonstrator if you need help with how to retrieve the files needed for the practical exercise. Please do not ask your tutor or the course lecturers about this. Part A: Getting on the road The Car class definition, for objects representing cars, is in the supplied Car.java file. You should have a look at the fields and inspector methods, to make sure you understand what they do. You can ignore the move method until starting Part B. You should now create a file called Road.java containing class definitions for an object representing the road. This should have four fields, all private. The first two are to be called length and numcars and are both of type int. They are used to hold the road s length and the number of cars currently on it, respectively. The third field is to be called cars and is an array of Car objects. It is used to hold, in increasing order of distance travelled, the cars on the road. The fourth field, to be called speedlimit is an object of class SpeedLimit. This is the object which will hold information about the speed limit (and later, speed restrictions) in force on the road. Now, add a constructor method and three inspector methods: public Road (int length, SpeedLimit speedlimit) public int getnumcars () public int getlength () public Car getcar (int i) In addition to storing its two parameterised field values, the constructor should also set numcars to zero, and set cars to be a new array with length/car.length elements. The getcar method should return the i-th element of the car array (for added security, it might check that i is in range, and return null if not). Next, add another method: public void insertcar (int i, Car newcar) This is to insert the newcar object at position i in the array of cars. Prior to insertion, the assumption will be that elements 0 to numcars-1 of the array contain cars (and that these are in order of increasing distance travelled). It should further be assumed that i is in the range 0 to numcars-1. Therefore, it will first be necessary to make room for the new car by moving existing Car objects at positions i onwards up one place in the array. The idea is similar to that used in the method for insertion into an ordered array that you have seen in lectures (except that here the insertion point is specified). As a final step, you need to increment numcars, to reflect the presence of the extra car. Finally, add one more method (to the Road class): 4

5 public void update () { } Notice that this has an empty body. You will make it do something rather more interesting in part B. Testing A class called TestA has been supplied to help you to test your work in this part, before it is ready to work with the full simulation. Have a look at the details of the class. It creates a road, populates it with some cars, then prints out their details. To use it, you will need to compile the various classes. The command javac *.java will achieve this. Then, to run the part A test, you should issue the command java TestA Make sure that the resulting output makes sense (you will need to read TestA.java to check this). You might like to experiment by making changes to TestA.java and checking that the new output is as you would expect. Submission When you are happy that your new Road class is behaving correctly, you can submit this part for assessment with the following command: handin A4a Road.java Later submissions will overwrite earlier ones. There is no need to hand in the TestA.java file. Once you have made your submission, either delete TestA.java with the command rm TestA.java or rename it (in case you want it for reference) with the command mv TestA.java TestA.saved This will avoid the reporting of spurious compiler errors later on in the practical, when changes in other classes make the TestA class no longer applicable. Part B: Learning to drive We are now ready to simulate traffic flowing along the road, in one-second steps. First, read the move method in the Car class. This takes two arguments, the first being the distance that (the rear of) the car in front has travelled, and the second being the speed limit (as an integer) in force at the point on the road where the front of the car 5

6 is currently located. Based on these, the method works out the maximum acceptable speed (involving a careful driver rule which never attempts to cover more than one third of the distance to the car in front, the current speed limit, and an assumption on the car s powers of acceleration). Given this method for a single car, you should now write a new body for the update method in your Road class. This will update the entire state of the road for a onesecond time step. With it in place, you will be able to try a road simulation, using the Simulation class in the supplied Simulation.java file. There are three things that have to be done by the update method, in the following order: 1. Check whether there are any cars on the road and, if so, whether the car furthest along (in array element numcars-1) should now depart, i.e. whether its distance equals the road length or more. If so, remove it, just by decrementing numcars. 2. Update all the current cars, in positions numcars-1 down to 0, using their move methods. Hint: use a for-loop, counting down the array, and maintain a variable that records the distance, prior to updating, of the car ahead of the one being considered. There is no car ahead of the first car considered, of course, so initialise the variable to reflect an imaginary car that is well in front (say, in terms of Road fields, at distance 2*length metres). 3. Check whether there is space for a new car to join the road, that is, whether there are either no cars on the road or the distance of the car least far along (in array element 0) equals the standard car length or more. If so, create a new car object, at distance 0 and with speed 0, and insert it at array position 0 using the insertcar method you wrote in Part A. Testing As before, the command javac *.java will compile all your classes. Then, to run the simulation, issue the command java Simulation This will simulate 2000 seconds of road traffic, and then display a speedgram, which should look like the one in the appendix at the end of this handout. If debugging is needed, you may find it useful temporarily to change main to simulate only one second (i.e. only one use of your update method) or only the first few seconds. Submission When you are happy that your new Road class is behaving correctly, you can submit this part for assessment with the following command: handin A4b Road.java Later submissions will overwrite earlier ones. 6

7 Part C: Hazards In Part B, there were no hindrances on the road, so that the resulting speedgram shows a smooth flow of cars travelling at the speed limit. Now, we will investigate the introduction of a hazard causing a reduced maximum speed on a section of road. This might reflect a formal reduction in the speed limit, at roadworks for example, or might reflect drivers slowing down to inspect the scene of a police-related incident. You should now create a file called Hazard.java containing class definitions for an object representing such a slowdown. This should have three fields, all private. These are to be called start, duration and reducedlimit, and are all of type int. They are used to hold the starting point (in metres from the beginning of the road) and length (in metres) of the hazard, and the reduced speed limit applying. Add a constructor method public Hazard (int start, int duration, int reducedlimit) and inspector methods for each of the fields. You then need to make some changes to the SpeedLimit and Simulation classes, to add a slowdown. Firstly, in the SpeedLimit class, add an extra field called hazard which is a Hazard object, and add a matching second argument called hazard to the SpeedLimit constructor method, storing the provided value in the new field. Secondly, still in the SpeedLimit class, rewrite the limitat method so that it returns the current speed limit for the given distance (i.e. the normal limit if there is no hazard, or the distance lies outside the hazard, or the reduced limit if the distance lies inside the hazard). Finally, in the Simulation class, in the main method, replace the right-hand side of the statement that creates the new Road object by the following: new Road(20000, new SpeedLimit(40, new Hazard(15000, 20, 10))); This creates the road with a 20 metre long slowdown to 10 metres/second, starting at a point 3 of the way along. 4 Testing As before, the command javac *.java will compile all your classes. Then, to run the simulation, issue the command java Simulation The resulting speedgram should look like the one in the appendix. 7

8 Submission When you are happy that everything is behaving correctly, you can submit this part for assessment with the following command: handin A4c Hazard.java SpeedLimit.java Road.java Remember to hand in all three files. Later submissions will overwrite earlier ones. Part D: Merge points Finally, we investigate the introduction of an extra flow of traffic joining the road partway along. We shall assume good behaviour on the part of the incoming traffic, in that a new car will only ever join the road when there is ample space. We will make the arrival of new cars probabilistic. You should create a file called MergePoint.java containing class definitions for an object representing such a merge point. This should have a single field, to be called point, which is a private int, used to hold the point (in metres from the beginning of the road) at which the merge happens. Add a constructor method and an inspector method: public MergePoint (int point) public int getpoint () You then need to make some changes to the Road and Simulation classes. In the Road class, add an extra field called mergepoint which is a MergePoint object, add a matching fourth argument called mergepoint to the Road constructor method and store it in the corresponding field. Then, at the end of the update method, you should insert code to deal with the merge point as follows: 1. Search the array of cars, trying to find two adjacent elements (i +1 and i, say), where the first car is at or after the merge point and the second car is before it. 2. If the search succeeds, and there are at least three car lengths between the merge point and the rear of the car in front (to allow for the length of the new car itself), and also between the merge point and the front of the car behind, then with probability 0.8, a new car is created, with its rear at the merge point, travelling at the same speed as the car in front and inserted at array position i +1using the insertcar method. Note that you can generate a random floating point number in the range 0.0 to 1 by calling the library method Math.random(). In the Simulation class, in the main method, replace the right-hand side of the statement that creates the new Road object by the following: new Road(20000, new SpeedLimit(40, new Hazard(15000, 20, 10)), new MergePoint(10000)); This creates the road with a merge point half-way along. Test your completed changes by running the main method. The resulting speedgram should look very like the one in the appendix, with minor variations caused by the probabilistic merging. 8

9 Testing As before, use javac *.java to compile and java Simulation to run the simulation, checking that the output looks like the one given in the appendix. For this part only there will be minor variations from run to run, as a natural consequence of our probabilistic simulation of merging. Submission When you are happy that everything is behaving correctly you can submit this part for assessment with the following command handin A4d MergePoint.java Road.java Remember to hand in both files. Later submissions will overwrite earlier ones. Appendix - Speedgram examples Be careful: Some online viewers make a poor job of reproducing the illustrations. To be confident, you should compare your on-screen results with the versions from the printed handout. The horizontal axis of a speedgram represents the road, start at left, end at right. Each vertical line represents a car at that position, with height of line proportional to speed. Speedgram for Part B 9

10