COMP 310
Fall 2014
HW02 Supplied Code
COMP 310
|
HW02 Supplied Code |
|
|
Download the supplied code here (docs). Descriptions of all the included code are below.
A wrapper around Java's java.util.Observable to make it easier to use.
package util;
import java.util.*;
/**
* A simplified Observable class that immediately notifies its Observers when its notifyAll() method is called. The changed state of the Dispatcher does not need to be separately set.
*/
public class Dispatcher extends Observable {
/**
* Immediately notifies all the Observers held.
* @param param An input parameter that is passed on to all the Observers.
*/
public void notifyAll(Object param) {
setChanged();
notifyObservers(param);
}
}
Top-level interface abstractly defining routines that provide randomized values.
package util;
import java.awt.*;
public interface IRandomizer {
/**
* Generates a random location point subject to the constraint that 0<=X<=rect.width and 0<=Y<=rect.height.
* @param rect The bounds for the x and y values of the created Point
* @return A Point object whose x and y are subject to the given bounds
*/
public Point randomLoc( Rectangle rect);
/**
* Generates a random location point subject to the constraint that 0<=X<=dim.width and 0<=Y<=dim.height.
* @param dim The bounds for the x and y values of the created Point
* @return A Point object whose x and y are subject to the given bounds
*/
public Point randomLoc( Dimension dim);
/**
* Returns a random integer greater than or equal to min and less than or equal to max.
* @param min The minimum allowed value
* @param max The maximum allowed value
* @return an int subject to the given bounds
*/
public int randomInt(int min, int max);
/**
* Returns a random double greater than or equal to min and less than max.
* @param min The minimum allowed value
* @param max The maximum allowed value
* @return a double subject to the given bounds
*/
public double randomDouble(double min, double max);
/**
* Returns a random velocity (as a Point) subject to the constraint that the absolute value of the velocity (speed)
* within the bound (inclusive) defined by rect. Thus the resultant velocity may be negative. The given Rectangle
* should use all positive values.
* @param rect The bounds for the absolute value of the velocity in the x and y directions.
* @return a Point object with x and y subject to the given bounds.
*/
public Point randomVel( Rectangle rect);
/**
* Returns a random square Dimension, whose width is maxDim.width/2<=width<=maxDim.width
* @param maxDim The bounds on the side of the created Dimension.
* @return A random square Dimension subject to the given bound
*/
public Dimension randomDim( Dimension maxDim);
/**
* Generates a randomly located and sized rectangle
* @param rect The bounds for the location of the created rectangle
* @param maxDim The bounds for the dimensions of the create rectangle
* @return A Rectangle with location and dimensions subject to the given bounds.
*/
public Rectangle randomBounds( Rectangle rect, Dimension maxDim);
/**
* Generates a random color
* @return a random Color object
*/
public Color randomColor();
/**
* Returns a random choice of one of two objects, x and y, where probX is the probability
* that x will be picked (0<=x<=1).
* @param x The first of two choices
* @param y The second of two choices
* @param probX The probability of the first choice
* @return Either x or y as per the probability of choosing them.
*/
public Object randomChoice(Object x, Object y, double probX);
}
Concrete implementation of IRandomizer defining specific algorithms that provide randomized values.
package util;
import java.awt.*;
/**
* Utility class that supplies class routines for generating various random values
*/
public class Randomizer implements IRandomizer {
public static Randomizer Singleton = new Randomizer();
private Randomizer() {
}
/**
* Generates a random location point subject to the constraint that 0<=X<=rect.width and 0<=Y<=rect.height.
* @param rect The bounds for the x and y values of the created Point
* @return A Point object whose x and y are subject to the given bounds
*/
public Point randomLoc( Rectangle rect) {
return (new Point( randomInt(0, rect.width), randomInt(0, rect.height)));
}
/**
* Generates a random location point subject to the constraint that 0<=X<=dim.width and 0<=Y<=dim.height.
* @param dim The bounds for the x and y values of the created Point
* @return A Point object whose x and y are subject to the given bounds
*/
public Point randomLoc( Dimension dim) {
return (new Point( randomInt(0, dim.width), randomInt(0, dim.height)));
}
/**
* Returns a random integer greater than or equal to min and less than or equal to max.
* @param min The minimum allowed value
* @param max The maximum allowed value
* @return an int subject to the given bounds
*/
public int randomInt(int min, int max) {
return (int)Math.floor((Math.random()*(1+max-min))+min);
}
/**
* Returns a random double greater than or equal to min and less than max.
* @param min The minimum allowed value
* @param max The maximum allowed value
* @return a double subject to the given bounds
*/
public double randomDouble(double min, double max) {
return (Math.random()*(max-min))+min;
}
/**
* Returns a random velocity (as a Point) subject to the constraint that the absolute value of the velocity (speed)
* within the bound (inclusive) defined by rect. Thus the resultant velocity may be negative. The given Rectangle
* should use all positive values.
* @param rect The bounds for the absolute value of the velocity in the x and y directions.
* @return a Point object with x and y subject to the given bounds.
*/
public Point randomVel( Rectangle rect) {
return (new Point (randomInt(-rect.width, rect.width), randomInt(-rect.height, rect.height)));
}
/**
* Returns a random square Dimension, whose width is maxDim.width/2<=width<=maxDim.width
* @param maxDim The bounds on the side of the created Dimension.
* @return A random square Dimension subject to the given bound
*/
public Dimension randomDim( Dimension maxDim) {
int x = randomInt(maxDim.width/2,maxDim.width);
return new Dimension(x,x);
}
/**
* Generates a randomly located and sized rectangle
* @param rect The bounds for the location of the created rectangle
* @param maxDim The bounds for the dimensions of the create rectangle
* @return A Rectangle with location and dimensions subject to the given bounds.
*/
public Rectangle randomBounds( Rectangle rect, Dimension maxDim) {
return new Rectangle(randomLoc(rect), randomDim(maxDim));
}
/**
* Generates a random color
* @return a random Color object
*/
public Color randomColor() {
return new Color( randomInt(0,255),randomInt(0,255),randomInt(0,255));
}
/**
* Returns a random choice of one of two objects, x and y, where probX is the probability
* that x will be picked (0<=x<=1).
* @param x The first of two choices
* @param y The second of two choices
* @param probX The probability of the first choice
* @return Either x or y as per the probability of choosing them.
*/
public Object randomChoice(Object x, Object y, double probX) {
return (Math.random()<probX) ? x: y;
}
}
Utility that provide sinusoidally-varying values.
package util;
/**
* A utility class that can be used to create smoothly varying sinusoidal
* numerical data.
* Note that this is not a singleton class nor does it have static methods as
* its behavior depends on the minimum, maximum and delta values given to
* its constructor.
*/
public class SineMaker {
/**
* The midpoint of the min and max values.
*/
private double _mid;
/**
* The amplitude of the sinusoidal output
*/
private double _ampl;
/**
* The amount that _theta is incremented each time, in radians.
*/
private double _delta;
/**
* The current angle used to generate the current
* sinusoidal value. Initialized to produce the minimum value.
*/
private double _theta = -Math.PI/2.0;
/**
* The constructor takes several values to control the object's behavior.
* @param min The minimum and initial value to produce.
* @param max The maximum value to produce.
* @param delta The amount in radians that the generating angle is incremented each time
* */
public SineMaker(double min, double max, double delta) {
_mid = (max+min)/2.0;
_ampl = (max-min)/2.0;
_delta = delta;
}
/**
* Returns a different value each time it is called. The value varies smoothly in a
* sinusoidal fashion, incrementing each time as per the above specified delta
* angle increase.
* @return the next value as a double
*/
public double getDblVal() {
double result = _mid + _ampl*Math.sin(_theta);
_theta += _delta; // shorthand for _theta = _theta + _delta
return result;
}
/**
* Same as getDblVal, but returns the result rounded to the nearest integer.
* Note that getDblVal and getIntVal are not independent as getIntVal merely calls
* getDblVal.
* @return the next value as an int
*/
public int getIntVal() {
return (int) Math.round(getDblVal());
}
}
© 2014 by Stephen Wong