Copyright © Cay S. Horstmann 2009, 2012

This work is licensed under a Creative Commons
Attribution-Noncommercial-Share Alike 3.0 United States License.

See lab 1 for reporting instructions.

Problems with this icon are optional

- Distances
- When you are given two points (x1, y1) and (x2, y2) on the plane, the
distance between them can be computed according to the following
figure:
Write Java code that computes a variable

`double distance`

from variables`x1`

and`x2`

. Use variables`dx`

and`dy`

, and do*not*use`Math.pow`

. - In BlueJ, complete this class
`Distance`

with your expression and run it with test cases (x1, y1) = (0, 0) and (x2, y2) = (30, 40). What output do you get? - Pick three more test cases: A horizontal line, a vertical line, and a line with a 45 degree angle. What outputs do you get? Why are they correct?

- When you are given two points (x1, y1) and (x2, y2) on the plane, the
distance between them can be computed according to the following
figure:
- Distances on Earth
- Using this site, find the (approximate) longitude and latitude of San Francisco and San Jose. What are they?
- This
Wikipedia article gives a good overview of computing the distance
between two points on Earth. Let's start with the first formula,
Use this formula to write a program

`Distance2`

that computes the distance between San Jose and San Francisco, keeping in mind the following:- Google's angles are in degrees. You must convert the angles to radian. The Math class has a useful method for this.
- arccos is
`Math.acos`

. - The formula gives the angular distance. You need to multiply it by the radius of the Earth, which I trust Google will find for you.

What is your program?

- What does it compute for the distance?
- What is the distance between San Francisco and New York?
- The Wikipedia article claims that the first formula isn't all that good for small distances. Try the Haversine formula and compare the results. What do you get for San Francisco-San Jose and San Francisco-New York with both formulas? Is the Wikipedia article right in stating that the first formula has a higher error?

- CodingBat
- Task 1
- Task 2
- Task
3. You need to know how to test a condition:
`if (str.length() <= 3) return ...; else return ...;`

Paste your answers into the lab report.

- Manipulating Strings
The Exploratorium has a nifty exhibit showing that, according to research at Cambrigde Uinversity, our brain tolerates scrmabled letters in a word when reading text.

The following exercises explore this scrambling.

- Modify the
`StringScrambler`

class so that the`scramble`

method returns a word that is made up of- the last letter of
`word`

- all but the first and last letter of
`word`

- the first letter of
`word`

For example, if the input is

`received`

, the output should bedeceiver

Hint: Call

`substring`

three times and concatenate (+) the results. What is your program? - the last letter of
- Test your program by making an object of type
`StringScrambler`

in the BlueJ workbench. Then call the`scramble`

method with an input of`resigned`

. What output do you get? - What happens when you use very short strings, i.e. strings with 2 characters? 1 character? The empty string? Explain your results.
- Call
`scrambleSentence`

with a sentence of your choice such as`"Java programming is easy and enjoyable"`

. Just run it—it calls your`scramble`

method for each word in the sentence.What result do you get?

- Actually, this scrambling isn't so good. For best results, you should
leave the first and last letter alone. Let's change the
`scramble`

method so that it scrambles the second and third letter of each word. For example,`"word"`

should get changed to`"wrod"`

.What is your

`scramble`

method now? - Try
`scrambleSentence`

again with the same sentence as in step 4. What is the result? - That is better. But it would be even nicer if we could switch any
letter with its successor, as long as we leave the first and last
character alone. Instead of swapping positions 1 and 2, let's swap
positions
`i`

and`i + 1`

where`i = randomInt(1, ...)`

.The

`randomInt`

method has been provided for your convenience.What is your

`scramble`

method now? - Try
`scrambleSentence`

again with the same sentence as in step 4. What is the result? - Almost there. Now pick a random location, but not
the first or the last two. Then pick another random location after the
first but not the last. Swap those.
What is your

`scramble`

method now? - Try
`scrambleSentence`

again with the same sentence as in step 4. What is the result?

- Modify the
- Random Walk
- Particles move across a plane by a fixed distance, then change
direction by turning at a random angle between 0 and 360 degrees, then
move again by the same distance, and so on. Intuitively, it would seem
that the particles never move very far because all those motions would
cancel each other out. This turns out not to be true—it can be
shown that the particles travel arbitrary distances, given enough time.
We want to model this in Alice. We don't bother with particles and just
reuse our car model.
Unzip the file and move the

`car`

directory in a folder`sjsu/cs46a/lab5`

inside your home directory. (Don't overwrite your old lab project.) Open the project in Netbeans. Rename it to`car5`

so you don't confuse it with the one from Lab 3. - As before, implement a class
`Car`

with a`drive`

method. But this time, your method should have no parameters.public class Car extends RedRover { public void drive() { move(MoveDirection.FORWARD, ...); turn(TurnDirection.LEFT, ...); } }

Move the car by two units, then turn it by a random angle (which in Alice is measured between 0 and 1, not 0/360 or 0/2π). Hint:

`Math.random()`

.Be sure to use a named constant for the distance.

What is the code of your

`drive`

method? - Now place the following code in
`myFirstMethod`

in the`Scene`

class.Car myRover = new Car(50); myRover.setVehicle(this); // Needed to make the car appear in the scene for (int i = 1; i <= 20; i++) { car1.drive(); }

We'll discuss the loop in chapter 6—it means “run the next statement 20 times”. Just copy/paste it.

What happens when you run the program?

- It's pretty difficult to see where the car has been. Let's do the
obvious and drop a cola bottle after every move. Here is how you drop
one:
Prop bottle = new Prop(ColaBottleResource.COLA_BOTTLE); bottle.setPositionRelativeToVehicle(getPositionRelativeToVehicle()); bottle.setVehicle(getVehicle());

Add these lines to the

`drive`

method. Netbeans should complain about not knowing`ColaBottleResource`

. Use Ctrl+Space after that word, or click on the warning icon, to get a list of possible completions/actions. Choose`import org.lgna.story.resources.prop.ColaBottleResource`

. Compile and run. What happens? - Ok, now we can see the trace of the car. But how much did it travel?
In
`myFirstM`

`ethod`

, drop a cola bottle*before*the car starts moving. Note that you are no longer in a`Car`

method, so you need to call`myRover.getPositionRelativeToVehicle()`

instead of`getPositionRelativeToVehicle()`

etc.Mercifully, you don't need to use the Pythagorean theorem in Alice to compute distances. After the 100 steps, compute

`myRover.getDistanceTo(bottle)`

, where`bottle`

was the initial cola bottle. Have the initial bottle say that distance. (Why not the car? It might be off-screen by now.)Note that the

`say`

method takes a`String`

parameter, not a`double`

.What is the code of your

`run`

method? - How much did your car travel when you ran the program?

- Particles move across a plane by a fixed distance, then change
direction by turning at a random angle between 0 and 360 degrees, then
move again by the same distance, and so on. Intuitively, it would seem
that the particles never move very far because all those motions would
cancel each other out. This turns out not to be true—it can be
shown that the particles travel arbitrary distances, given enough time.
We want to model this in Alice. We don't bother with particles and just
reuse our car model.