package stdlib;
import java.util.function.*;

public class DoublingTest {
	private static double time;
	private static long ops;
	/**
	 * During a doubling test, the provided code may call {@code incOps} and/or {@code addOps}.
	 * If either is called, then the number of operations so recorded will be reported by {@code run}.
	 */
	public static void incOps () { ops++; }
	/**
	 * During a doubling test, the provided code may call {@code incOps} and/or {@code addOps}.
	 * If either is called, then the number of operations so recorded will be reported by {@code run}.
	 */
	public static void addOps (int count) {
		if (count < 1) throw new IllegalArgumentException ();
		ops += count;
	}
	/**
	 * See fully parameterized {@code run} for a description.
	 * In this abbreviated form, {@code numTestsPerValue} is 1.
	 * {@code setup} does nothing, therefore no value is provided to {@code timed}.
	 */
	public static void run (int initialValue, int numValues, Consumer<Integer> timed) {
			run (initialValue, numValues, 1, x -> {}, timed);
	}
	/**
	 * See fully parameterized {@code run} for a description.
	 * In this abbreviated form, {@code numTestsPerValue} is 1.
	 * No value is passed from {@code setup} to {@code timed}.
	 */
	public static void run (int initialValue, int numValues, Consumer<Integer> setup, Consumer<Integer> timed) {
		run (initialValue, numValues, 1, setup, timed);
	}
	/**
	 * See fully parameterized {@code run} for a description.
	 * In this abbreviated form, no value is passed from {@code setup} to {@code timed}.
	 */
	public static void run (int initialValue, int numValues, int numTestsPerValue, Consumer<Integer> setup, Consumer<Integer> timed) {
		run (initialValue, numValues, numTestsPerValue, (Integer x) -> { setup.accept (x); return null; }, (x,t) -> timed.accept (x));
	}
	/**
	 * See fully parameterized {@code run} for a description.
	 * In this abbreviated form, {@code numTestsPerValue} is 1.
	 */
	public static <T> void run (int initialValue, int numValues, Function<Integer,T> setup, BiConsumer<Integer,T> timed) {
		run (initialValue, numValues, 1, setup, timed);
	}
	/**
	 * See fully parameterized {@code run} for a description.
	 * In this abbreviated form, the integer value is not passed to {@code timed}.
	 */
	public static <T> void run (int initialValue, int numValues, int numTestsPerValue, Function<Integer,T> setup, Consumer<T> timed) {
		run (initialValue, numValues, numTestsPerValue, setup, (x,t) -> timed.accept (t));
	}
	/**
	 * See fully parameterized {@code run} for a description.
	 * In this abbreviated form, {@code numTestsPerValue} is 1.
	 * The integer value is not passed to {@code timed}.
	 */
	public static <T> void run (int initialValue, int numValues, Function<Integer,T> setup, Consumer<T> timed) {
		run (initialValue, numValues, 1, setup, timed);
	}
	/**
	 * Run the function {@code timed} with increasing large values for the first integer parameter (N).
	 * Running time is reported to the console.
	 * Initial value of N is given by {@code initialValue}.
	 * N doubles each time the test is run.
	 * The number of different values for N is given by {@code numValues}.
	 * If {@code numTestsPerValue} is larger than one, then the test will be run multiple times for each N, and the average time reported.
	 * The {@code setup} function is called before {@code timed}, and the result (of type T) is provided to {@code timed} as the second parameter.
	 * {@code setup} is called once before each call to {@code timed}.
	 */
	public static <T> void run (int initialValue, int numValues, int numTestsPerValue, Function<Integer,T> setup, BiConsumer<Integer,T> timed) {
		int value = initialValue;
		runOnce (value, numTestsPerValue, setup, timed);
		if (ops != 0) {
			System.out.format("N=%,13d, ops=%,13d,             seconds=%5.3f\n", value, ops/numTestsPerValue, time/numTestsPerValue);
		} else {
			System.out.format("N=%,13d, seconds=%5.3f\n", value, time/numTestsPerValue);
		}
		double prevOps = ops;
		double prevTime = time;
		for (int i=1; i<numValues; i++) {
			value *= 2;
			runOnce (value, numTestsPerValue, setup, timed);
			if (ops != 0) {
				System.out.format("N=%,13d, ops=%,13d ratio=%5.1f, seconds=%5.3f ratio=%5.3f\n", value, ops/numTestsPerValue, ops/prevOps, time/numTestsPerValue, time/prevTime);
			} else {
				System.out.format("N=%,13d, seconds=%5.3f ratio=%5.3f\n", value, time/numTestsPerValue, time/prevTime);
			}
			prevOps = ops;
			prevTime = time;
		}
	}
	private static <T> void runOnce (int value, int numTestsPerValue, Function<Integer,T> setup, BiConsumer<Integer,T> timed) {
		ops = 0;
		time = 0;
		for (int testNum = 0; testNum < numTestsPerValue; testNum++) {
			T setupResult = setup.apply (value);
			Stopwatch sw = new Stopwatch ();
			timed.accept (value, setupResult);
			time += sw.elapsedTime ();
		}
	}

	// Now repeat everything with Long, rather than Integer

	/**
	 * See fully parameterized {@code runLong} for a description.
	 * In this abbreviated form, {@code numTestsPerValue} is 1.
	 * {@code setup} does nothing, therefore no value is provided to {@code timed}.
	 */
	public static void runLong (long initialValue, int numValues, Consumer<Long> timed) {
		runLong (initialValue, numValues, 1, x -> {}, timed);
	}
	/**
	 * See fully parameterized {@code runLong} for a description.
	 * In this abbreviated form, {@code numTestsPerValue} is 1.
	 * No value is passed from {@code setup} to {@code timed}.
	 */
	public static void runLong (long initialValue, int numValues, Consumer<Long> setup, Consumer<Long> timed) {
		runLong (initialValue, numValues, 1, setup, timed);
	}
	/**
	 * See fully parameterized {@code runLong} for a description.
	 * In this abbreviated form, no value is passed from {@code setup} to {@code timed}.
	 */
	public static void runLong (long initialValue, int numValues, int numTestsPerValue, Consumer<Long> setup, Consumer<Long> timed) {
		runLong (initialValue, numValues, numTestsPerValue, (Long x) -> { setup.accept (x); return null; }, (x,t) -> timed.accept (x));
	}
	/**
	 * See fully parameterized {@code runLong} for a description.
	 * In this abbreviated form, {@code numTestsPerValue} is 1.
	 */
	public static <T> void runLong (long initialValue, int numValues, Function<Long,T> setup, BiConsumer<Long,T> timed) {
		runLong (initialValue, numValues, 1, setup, timed);
	}
	/**
	 * See fully parameterized {@code runLong} for a description.
	 * In this abbreviated form, the integer value is not passed to {@code timed}.
	 */
	public static <T> void runLong (long initialValue, int numValues, int numTestsPerValue, Function<Long,T> setup, Consumer<T> timed) {
		runLong (initialValue, numValues, numTestsPerValue, setup, (x,t) -> timed.accept (t));
	}
	/**
	 * See fully parameterized {@code runLong} for a description.
	 * In this abbreviated form, {@code numTestsPerValue} is 1.
	 * The integer value is not passed to {@code timed}.
	 */
	public static <T> void runLong (long initialValue, int numValues, Function<Long,T> setup, Consumer<T> timed) {
		runLong (initialValue, numValues, 1, setup, timed);
	}
	/**
	 * Run the function {@code timed} with increasing large values for the first integer parameter (N).
	 * Running time is reported to the console.
	 * Initial value of N is given by {@code initialValue}.
	 * N doubles each time the test is runLong.
	 * The number of different values for N is given by {@code numValues}.
	 * If {@code numTestsPerValue} is larger than one, then the test will be runLong multiple times for each N, and the average time reported.
	 * The {@code setup} function is called before {@code timed}, and the result (of type T) is provided to {@code timed} as the second parameter.
	 * {@code setup} is called once before each call to {@code timed}.
	 */
	public static <T> void runLong (long initialValue, int numValues, int numTestsPerValue, Function<Long,T> setup, BiConsumer<Long,T> timed) {
		long value = initialValue;
		runOnce (value, numTestsPerValue, setup, timed);
		if (ops != 0) {
			System.out.format("N=%,13d, ops=%,13d,             seconds=%5.3f\n", value, ops/numTestsPerValue, time/numTestsPerValue);
		} else {
			System.out.format("N=%,13d, seconds=%5.3f\n", value, time/numTestsPerValue);
		}
		double prevOps = ops;
		double prevTime = time;
		for (int i=1; i<numValues; i++) {
			value *= 2;
			runOnce (value, numTestsPerValue, setup, timed);
			if (ops != 0) {
				System.out.format("N=%,13d, ops=%,13d ratio=%5.1f, seconds=%5.3f ratio=%5.3f\n", value, ops/numTestsPerValue, ops/prevOps, time/numTestsPerValue, time/prevTime);
			} else {
				System.out.format("N=%,13d, seconds=%5.3f ratio=%5.3f\n", value, time/numTestsPerValue, time/prevTime);
			}
			prevOps = ops;
			prevTime = time;
		}
	}
	private static <T> void runOnce (long value, int numTestsPerValue, Function<Long,T> setup, BiConsumer<Long,T> timed) {
		ops = 0;
		time = 0;
		for (int testNum = 0; testNum < numTestsPerValue; testNum++) {
			T setupResult = setup.apply (value);
			Stopwatch sw = new Stopwatch ();
			timed.accept (value, setupResult);
			time += sw.elapsedTime ();
		}
	}
}