//
// Program to compute the variance of a set of numbers. 
//
// Command-line arguments are:
//    number of threads (P) -- required; number of threads to use
//    number of numbers (N) -- optional; see below
//
// If only one command-line argument is given, the program reads
//    input numbers (floating-point okay) from standard input until 
//    end-of-file is reached.
// If two command-line arguments are given, the program generates
//    N random numbers to use as input.
//
// Program output:
//    computed variance
//    elapsed time needed for computation, starting when all the
//      input numbers have been read in / generated, and ending
//      when the variance has been computed.
// 
import java.text.*;		// has NumberFormat
import java.util.*;		// has Vector, Random

// ---- Class containing main program --------------------------------

public class Variance {

    // ---- Member variables (for use by all threads) ----------------

    private int P;		// number of threads
    private double[] nums;	// numbers to add
				// (count in nums.length)

    // ---- Constructors ---------------------------------------------

    // Constructor for input from stdin.
    public Variance(int P) {
	this.P = P;
	getStdinInput();
    }

    // Constructor for randomly-generated input.
    public Variance(int P, int n) {
	this.P = P;
	getRandomInput(n);
    }

    // ---- Method to do intended work -------------------------------

    public void compute() {

	// Start timing.
	double startTime = Timer.elapsedSeconds();

	// Compute variance.
	// ==== START OF CODE TO REPLACE ====

	double sum = 0.0;
	for (int i = 0; i < nums.length; ++i)
		sum += nums[i];
	
	double avg = sum / nums.length;

	double variance = 0.0;
	for (int i = 0; i < nums.length; ++i) 
	    variance += (nums[i] - avg)*(nums[i] - avg);
	
	// ==== END OF CODE TO REPLACE ====

	// Stop timing. 
	double endTime = Timer.elapsedSeconds();

	// Print result.
	NumberFormat nf = NumberFormat.getInstance();
				// set up to print answer in fixed-point
				//   (not exponential) integer format.
	nf.setMaximumFractionDigits(4);
	System.out.println("Variance times number of points = " + 
			   nf.format(variance));
	System.out.println("Elapsed time (seconds) = " +
			   Timer.format(endTime - startTime));
    }

    // ---- Main program ---------------------------------------------

    public static void main(String[] args) {

	if (args.length < 1) {
	    System.err.println("Usage:  java Variance " +
			       "numThreads [numNumbers]");
	    System.exit(1);
	}

	int P = Integer.parseInt(args[0]);

	Variance obj;

	if (args.length == 1)
	    obj = new Variance(P);
	else
	    obj = new Variance(P, Integer.parseInt(args[1]));

	obj.compute();
    }

    // ---- Helper methods -------------------------------------------

    // Get input from standard input.
    private void getStdinInput() {
	SimpleReader infile = new SimpleReader();
	Vector vTemp = new Vector();
	try {
	    while (true)	// loop ends on EOF exception
		vTemp.add(new Double(infile.readDouble()));
	}
	catch (SimpleReaderIOException e) { }
	nums = new double[vTemp.size()];
	for (int i = 0; i < nums.length; ++i)
	    nums[i] = ((Double) vTemp.elementAt(i)).doubleValue();
    }

    // Generate (pseudo)random input.
    // Uses the same seed every time so answer does not depend on number
    //   of threads.
    private void getRandomInput(int n) {
	nums = new double[n];
	Random generator = new Random(1);
	for (int i = 0; i < nums.length; ++i) 
	    nums[i] = generator.nextDouble();
    }
}