Lab 10 In-Class: More Classes

In this lab you will develop a class that models a random walk and write a few client programs that use the class. A random walk is basically a sequence of steps in some enclosed space where the direction of each step is random. The walk terminates either when a maximum number of steps has been taken or a step goes outside of the boundary of the space. Random walks are used to model physical phenomena such as the motion of molecules and economic phenomena such as stock prices.

We will assume that the random walk takes place on a square grid with the point (0,0) at the upper left hand corner (as in a graphics window). By default each step will be one unit up, one unit down, one unit to the left, or one unit to the right. (No diagonal movement.)

The basic RandomWalk class will have the following instance data (all type int):

Open a file RandomWalk.java in emacs. You'll define the RandomWalk class incrementally testing each part as you go. Be sure to include documentation as you develop the class.
  1. First declare the instance data (as described above) and add the following two constructors and toString method.

  2. Compile what you have so far then open the file TestWalk.java. This file will be used to test your RandomWalk methods. So far it prompts the user to enter a maximum number of steps, a width for the grid and the x and y coordinates of a position. Add the following:

    Compile and run the program to make sure everything is correct so far.

  3. Next add the following method to the RandomWalk class: void takeStep()

    This method simulates taking a single step either up, down, left, or right. To "take a step" generate a random number with 4 values (say 0, 1, 2, 3) then use a switch statement to change the position (one random value will represent going right, one left, and so on). Your method should also increment the number of steps taken. Use either the Random class or Math.random from the Math class to generate the random number.

  4. Add a for loop to TestWalk.java to have each of your RandomWalk objects take 5 steps. Print out each object after each step so you can see what is going on. Compile and run the program to make sure it is correct so far. The walk is random so each time you run the program the positions will change.

  5. The default movement in takeStep is one unit in any direction. It may be beneficial to allow the programmer to specify a size for the step. Overload the takeStep method to take an integer that represents the step size. Instead of incrementing the position, this new method will add the step size in the appropriate direction. don't forget about cut-and-paste when you overload

  6. Make the appropriate changes to TestWalk.java to test the overloaded version of the takeStep method.

  7. Next add graphics capabilities to the RandomWalk class so the steps can be drawn. A step will be drawn as a line from the previous position to the new position when a step is taken. This requires doing the following:

  8. Compile your class and correct any syntax errors.

  9. Now test your new methods with an applet. The file StepApplet.java contains the skeleton of an applet to test the methods and file Step.html contains an HTML file to run the applet in the appletviewer. Save these to your directory. Open StepApplet.java and add code to instantiate two RandomWalk objects - a blue one centered in the applet (use the 3 parameter constructor that centers by default) and the second a red one positioned initially at (100, 50). In both cases make the maximum number of steps 20 and the width of the grid 400 (the width of the applet - use the constant). Write a for loop that has each object take and draw 20 steps with step size 3. Note that you can copy some of the code from TestWalk.java and modify the parameters to do this.

  10. Compile the applet and run it in the appletviewer. Choose Restart under the Applet option on the menu to see the randomness.

  11. Change the step size to 8, then compile and run the applet to see the difference. Next try a step size of 1.

  12. Now add to RandomWalk.java the following two methods. Each should be a single return statement that returns the value of a boolean expression.

  13. Add to the RandomWalk class a method named walk that has no parameters and returns nothing. Its job is to simulate a complete random walk. That is, it should generate a sequence of steps as long the maximum number of steps has not been taken and it is still in bounds (inside the square). This should be a very simple loop (while or do... while) --- you will need to call the methods takeStep, moreSteps, and inBounds. This method should not draw the walk.

  14. Compile the class and correct any syntax errors.

  15. Add to TestWalk.java a statement to instantiate a RandomWalk object with a width of 20 and 200 as the maximum number of steps. (You may want to comment out most of the code currently in TestWalk -- especially the user input and the loop that takes five steps -- as the walk method will be easier to test on its own. The /* ... */ style of comment is useful for this.) Then add a statement to have the object walk. Print the object after the walk. Compile and run the program. Run it more than once -- you should be able to tell by the value printed whether the object went out of bounds or whether it stopped because it reached the maximum number of steps.

  16. Next overload the walk method in the RandomWalk class by adding a graphical version. As with the takeStep method this needs two parameters to represent the step size and the Graphics object. You can copy your current walk method and make just a few changes.

  17. Use the applet WalkApplet.java and associated html file Walk.html to test your graphical walk. Add code in WalkApplet.java to instantiate a RandomWalk object with 5000 for the maximum number of steps and 200 (the applet width) for the width and the color and position of your choice. Add code to have the object do a graphical "walk."

  18. Compile and run the applet. Restart it several times to see the randomness.

  19. Now write a client program (nongraphical) in a file named DrunkenWalk.java. The program should simulate a drunk staggering randomly on some sort of platform (imagine a square dock in the middle of a lake). The goal of the program is to simulate the walk many times (because of randomness each walk is different) and count the number of times the drunk falls off the platform (goes out of bounds). Your program should read in the width of the platform, the maximum number of steps, and the number of drunks to simulate. It should then have a loop (a for loop would be a good idea) that on each iteration instantiates a new RandomWalk object to represent a drunk, has the object walk, then determines whether or not the drunk fell off the platform (and updates a counter if it did). After the loop print out the number of times the drunk fell off and the number of times it didn't. Compile and run your program. To see the "randomness" you should run it several times with at least 1000 for the number of drunks to simulate. Try input of 10 for the width and 200 for the number of steps first (sometimes the drunk falls off, sometimes not); try 10 for the width and 500 for the steps (you should see different behavior); try 50 for the width and 200 for the steps (again different behavior).

  20. Finally you will write a second client program that simulates two particles moving in space. Its goal is to determine the number of times the two particles collide (occupy exactly the same position after the same number of steps -- the steps could be thought of as simulating time). This means your program needs a way to determine whether or not the particles (the RandomWalk objects) are in the same position. Hence, you need to add some methods to the RandomWalk class to do this. So, before writing the collisions program, add the following methods to the RandomWalk class.

    Note that all three methods are public. Compile the RandomWalk class to make sure there are no syntax errors.

  21. Now write a graphical client program - an applet that has uses random walk objects to simulate two particles moving in space. Note: You can use a copy of an existing applet instead of creating it completely from scratch

    Assume the particles are in a square applet with width 600. Use 100,000 for the maximum number of steps. Start one particle 9 pixels to the left of the applet center and the other 9 pixels to the right. The two "particles" should be different colors. Use a step size of 3. Your program should contain a loop that has each particle take a step as long as the particles have not exceeded the maximum number of steps (it is ok to let them go out of bounds). The program then determines how often the particles have collided. The program should call the static method samePosition you just added to the RandomWalk class to determine if the particles are in the same position (have "collided"). Use drawString to draw the number of collisions (appropriately labeled) on the applet. Use a color that will show up!

    Compile and run your applet to make sure it works. As before run it several times.

  22. The parameters given to the program are important! Change the step size to 5. What happens to the number of collisions? Include a comment in the client program that explains why this change will produce a meaningless outcome.

  23. ** EXTRA CREDIT ** In using random walks to simulate behavior it is often of interest to know how far away from the initial position the object gets as it moves. There are several different possibilities for measuring the distance. In this case it makes sense to use "Manhattan" distance - the sum of the vertical and horizontal distances from the starting point. For example, the Manhattan distance from the point (20, 350) to (200, 100) is 430 (horizontal distance of 180 + vertical distance of 250).

    1. Add instance variables for the initial position (currently that is lost as the walk takes place) and the maximum distance so far to the RandomWalk class. Initialize these appropriately in each constructor.
    2. Now the takeStep methods need to compute the distance from the initial position (the sum of the absolute values of the distance in the horizontal direction and in the vertical direction) and update the maximum when a step is taken. Remember that Math.abs returns the absolute value of a number; you can also use the Math.max method to find the maximum of the new distance and the previous maximum.
    3. Finally add an accessor method to return that distance so a client program can access it.
             public int getMaxDistance()
      
    4. Test the maximum by adding statements in Collisions applet to get and print the maximum distance for each of the particles after the loop.

  24. Before printing anything be sure that all your files have appropriate documentation including your name.

What to Turn In

Turn in hardcopy of RandomWalk.java, TestWalk.java, DrunkenWalk.java, and CollisionsApplet.java. (No need to turn in StepApplet.java and WalkApplet.java but they should be in the directory you tar.) Tar your lab10 directory and email it to your instructor with cpsc120 lab10 in the subject line.