package lrs.visitor; import lrs.IAlgo; import lrs.LRStruct; /** * Computes the average of an LRStruct of Doubles. Mathematically, the average * of an empty list does not exist. We return null in this case. null is used * to represent non-existence. * @author D. X. Nguyen * @version 1.0 */ public class Average implements IAlgo { private int _accLen = 0; // accumulated length private double _accSum = 0.0; // accumulated sum public Average() { } public Object emptyCase(LRStruct host, Object notUsed) { return null; } /** * Initializes the accumulated length and the accumluated sum, and asks the * rest to execute a helper algorithm to figure out the average. The helper * algorithm is an anonymous (local) inner class that has access to the * private fields of the outer algorithm and can update them accordingly. */ public Object nonEmptyCase(LRStruct host, Object notUsed) { _accLen = 1; _accSum = ((Double)host.getFirst()).doubleValue(); return host.getRest().execute(new IAlgo() { /** * At this point, the accumulated length is the length of the host, * the accumulated sum is the sum of the host. The average is thus * the ration of the accumulated sum over the accumulated length. */ public Object emptyCase(LRStruct h, Object nu) { return new Double(_accSum / _accLen); } /** * Updates the accumulated length and accumulated sum in the outer * algorithm, and recurs on the rest of the host h. */ public Object nonEmptyCase(LRStruct h, Object nu) { _accLen++; _accSum += ((Double)h.getFirst()).doubleValue(); return h.getRest().execute(this, null); } } , null); } }