Power Outage

Exercises

1. In Java,
   1. What does the keyword final mean when it is used:
      1. As a variable modifier?
      2. As a method modifier?
      3. As a class modifier?
   2. What does the keyword extends mean?
   3. What does this refer to?
   4. What does super refer to?
   5. What is an interface?
   6. What is a superclass? What is a subclass?
2. Study the source code for the partially complete program shown below.
   1. Describe the real-world problem that is modeled by the program.
   2. In what ways is the model extremely realistic?
   3. In what ways does the model approximate reality? How good are the approximations? How could they be improved?
   4. What are some interesting questions that could be answered using the program shown below or some variation of it that could not easily be answered without such a program?
3. Finish the incomplete classes shown below. Do not change any of the code that is already written.
4. For each of the classes shown below that does not have a main method, add a main method that could serve as the starting point of a program if the class was made public. In each of your main methods, include statements that invoke the other public methods of the class, including each of the public constructors. Pass interesting arguments to the methods when you invoke them. The goal is to convince yourself, by executing each of the main methods and observing the output produced (if any), that all of the public methods work as intended. If you are not sure how a method is supposed to work, then ask.
5. Make sure you have completed the previous exercises before attempting this exercise. Study the main method of the PowerOutage class carefully.
   1. What do you observe when you run the program? Run the program several times.
   2. Explain why the value returned by oneHop.powerOut() is sometimes greater than, sometimes equal to, and sometimes less than the value returned by okPath.powerOut().
6. Modify the implementation of PathFinder.findGoodPath so that the method returns a SignalPath object that is always at least as good as and is sometimes better than the object referred to by the variable in PowerOutage.main named oneHop in terms of the value returned by the objects’ powerOut methods. Larger .powerOut() values are better than smaller ones.
7. Modify the implementation of PathFinder.findOptimalPath so that the method returns a SignalPath object that is as good as possible in terms of the value returned by the object’s .powerOut method. Explain how your implementation works in English; present your explanation in the form of comments that accompany your implementation.
8. Implement the program shown below, including the missing parts, in JavaScript instead of Java.

import java.util.*; public class PowerOutage { public static void main(String args[]) { final int n=10, areaWidth=10, areaHeight=10, powerBoost=1; Repeater[] repeaters = Repeaters.randomSequence( n, areaWidth, areaHeight, powerBoost ); final Repeater first = repeaters[0]; final Repeater last = repeaters[repeaters.length - 1]; final SignalHop oneHop = new SignalHop(first, last); final SignalPath okPath = PathFinder.findOkayPath(first, last, repeaters), goodPath = PathFinder.findGoodPath(first, last, repeaters), optimalPath = PathFinder.findOptimalPath(first, last, repeaters); SignalPath allInclusivePath = new SignalPath(repeaters); System.out.println("cahoots: " + allInclusivePath.powerOut()); System.out.println("one hop: " + oneHop.powerOut()); System.out.println("ok path: " + okPath.powerOut()); System.out.println("not bad: " + goodPath.powerOut()); System.out.println("optimal: " + optimalPath.powerOut()); } } class Repeaters { private static Repeater randomRepeater( double areaWidth, double areaHeight, double powerBoost ) { return new Repeater( Math.random() * areaWidth, Math.random() * areaHeight, powerBoost ); } public static Repeater[] randomSequence( int n, double areaWidth, double areaHeight, double powerBoost ) { Repeater[] sequence = new Repeater[n]; for (int i = 0; i < n; i++) { sequence[i] = randomRepeater( areaWidth, areaHeight, powerBoost ); } return sequence; } } class PathFinder { private static Repeater findNearestInRange( Repeater from, Repeater to, Repeater[] network ) { int n = network.length; Segment leader = new Segment(from, to); double limit = leader.length(); for (int i=0; i < n; i++) { Repeater r = network[i]; if (r == from) continue; Segment s1 = new Segment(from, r); Segment s2 = new Segment(r, to); if (s1.length() < limit && s2.length() < limit) { if (s1.length() < leader.length()) { leader = s1; } } } return (Repeater)leader.pointB(); } public static SignalPath findOkayPath( Repeater first, Repeater last, Repeater[] repeaters ) { final SignalPath okPath = new SignalPath(); Repeater next = first; while (next != last) { okPath.add(next); next = findNearestInRange(next, last, repeaters); } okPath.add(next); return okPath; } public static SignalPath findGoodPath( Repeater first, Repeater last, Repeater[] repeaters ) { // Do better. return findOkayPath(first, last, repeaters); } public static SignalPath findOptimalPath( Repeater first, Repeater last, Repeater[] repeaters ) { // Do best. return findOkayPath(first, last, repeaters); } } class Point { public Point(double x, double y) { } public final double x() { } public final double y() { } public boolean equals(Point p) { } public final double distanceFrom(Point p) { } public String toString() { } } class Segment { public Segment(Point a, Point b) { } public final double slope() { } public final double length() { } public final Point pointA() { } public final Point pointB() { } public String toString() { } } interface AmplifierSequence { public double lastPowerIn(); public double powerOut(); } // https://en.wikipedia.org/wiki/Cellular_repeater final class Repeater extends Point implements AmplifierSequence { public Repeater(double x, double y, double boost) { } public Repeater(double x, double y) { // boost defaults to 1. } /** lastPowerIn returns 1. */ /** powerOut returns the value of boost. */ } // https://en.wikipedia.org/wiki/Radio_propagation#Free_space_propagation final class SignalHop implements AmplifierSequence { private double lastPowerIn; private double powerOut; private final Repeater a, b; public SignalHop(Repeater a, Repeater b) { this.a = a; this.b = b; Segment hop = new Segment(a, b); lastPowerIn = a.powerOut() / Math.pow(hop.length(), 2); powerOut = b.powerOut() * lastPowerIn; } public Repeater repeaterA() { return a; } public Repeater repeaterB() { return b; } public double lastPowerIn() { return lastPowerIn; } public double powerOut() { return powerOut; } } final class SignalPath implements AmplifierSequence { private final List<Repeater> path = new LinkedList<Repeater>(); private Repeater lastRepeater = null; private double lastPowerIn = 1, powerOut = 0; public SignalPath() { } public SignalPath(Repeater[] repeaters) { if (repeaters != null) for (Repeater r : repeaters) add(r); } public SignalPath add(Repeater r) { path.add(r); if (lastRepeater != null) { final SignalHop hop = new SignalHop(lastRepeater, r); lastPowerIn *= hop.lastPowerIn(); } powerOut = r.powerOut() * lastPowerIn; lastRepeater = r; return this; } public double lastPowerIn() { return lastPowerIn; } public double powerOut() { return powerOut; } }