/*************************************************************************
 *  Compilation:  javac TimePrimitives.java
 *  Execution:    java TimePrimitives N
 *
 *  Determine the amount of time it takes to call +, %, Math.random,
 *  Math.sin, Math.sqrt, Math.pow on your system.
 *
 *  Difficulty since compiler may optimize away some code.
 *
 *  % java TimePrimitives 1000000
 *
 * From <a href="http://introcs.cs.princeton.edu/java/41analysis/TimePrimitives.java.html">
       A Princeton class website.</a>
 *
 * History:
 * Josiah Yoder, Spring 2013, Week 2:
 *   - Switched stopwatch to use nanoTime instead of currentTimeMillis.
 *   - Added a few tests.
 *
 * Copyright © 2000–2011, Robert Sedgewick and Kevin Wayne.
 * Last princeton update before copy: Wed Feb 9 09:17:30 EST 2011.
 *************************************************************************/
package class2_1_TimePrimitives;

public class TimePrimitives {

    public static int f(int i, int j) { return 0; }

    public static void main(String[] args) {
        int N = 100_000;
        int k; // test accumulator
        int k2 = 0; // Overall accumulator
        if (args.length > 0) {
            try {
                N = Integer.parseInt(args[0]);
            } catch (NumberFormatException e) {
                System.err.println("Usage: <programname> <integer number of steps>");
            }
        }
        Stopwatch timer;
        double freq, elapsed;

        for (int burnInIndex = 0; burnInIndex < 3; burnInIndex++) {

            System.out.println();
            System.out.println("Nanoseconds per operation (Burn-in index: "+burnInIndex+")");

            /***************************************************************
             * Nothing at all
             ***************************************************************/
            timer = new Stopwatch();
            elapsed = timer.elapsedTime();
            freq = 1.0E9 * elapsed / N / N;
            System.out.println("Nothing:" + "\t" + freq);

            /***************************************************************
             * empty loop
             ***************************************************************/
            timer = new Stopwatch();
            for (int i = 1; i <= N; i++) {
                for (int j = 1; j <= N; j++) {
                    ;
                }
            }
            elapsed = timer.elapsedTime();
            freq = 1.0E9 * elapsed / N / N;
            System.out.println("Empty loop:" + "\t" + freq);


            //        /***************************************************************
            //         * empty loop
            //         ***************************************************************/
            //        timer = new Stopwatch();
            //        for (int i = 1; i <= N; i++) {
            //            for (int j = 1; j <= N; j++) {
            //                ;
            //            }
            //        }
            //        elapsed = timer.elapsedTime();
            //        freq = 1.0E9 * elapsed / N / N;
            //        System.out.println("Empty loop:" + "\t" + freq);
            //
            //        /***************************************************************
            //         * empty loop
            //         ***************************************************************/
            //        timer = new Stopwatch();
            //        for (int i = 1; i <= N; i++) {
            //            for (int j = 1; j <= N; j++) {
            //                ;
            //            }
            //        }
            //        elapsed = timer.elapsedTime();
            //        freq = 1.0E9 * elapsed / N / N;
            //        System.out.println("Empty loop:" + "\t" + freq);

            /***************************************************************
             * addition
             ***************************************************************/
            timer = new Stopwatch();
            k = 0;
            for (int i = 1; i <= N; i++) {
                for (int j = 1; j <= N; j++) {
                    k += i + j;
                }
            }
            k2 += k;
            elapsed = timer.elapsedTime();
            freq = 1.0E9 * elapsed / N / N;
            System.out.println("Integer addition:" + "\t" + freq);

            /***************************************************************
             * Nothing at all
             ***************************************************************/
            timer = new Stopwatch();
            elapsed = timer.elapsedTime();
            freq = 1.0E9 * elapsed / N / N;
            System.out.println("Nothing:" + "\t" + freq);

            /***************************************************************
             * two additions, accumulation
             ***************************************************************/
            timer = new Stopwatch();
            k = 0;
            for (int i = 1; i <= N; i++) {
                for (int j = 1; j <= N; j++) {
                    k += i + j + k;
                }
            }
            elapsed = timer.elapsedTime();
            freq = 1.0E9 * elapsed / N / N;
            System.out.println("Two integer additions:" + "\t" + freq);

            /***************************************************************
             * integer subtraction
             ***************************************************************/
            timer = new Stopwatch();
            k = 0;
            for (int i = 1; i <= N; i++) {
                for (int j = 1; j <= N; j++) {
                    k += i - j;
                }
            }
            elapsed = timer.elapsedTime();
            freq = 1.0E9 * elapsed / N / N;
            System.out.println("Integer subtraction:" + "\t" + freq);


            /***************************************************************
             * multiplication
             ***************************************************************/
            timer = new Stopwatch();
            k = 0;
            for (int i = 1; i <= N; i++) {
                for (int j = 1; j <= N; j++) {
                    k += i * j;
                }
            }
            elapsed = timer.elapsedTime();
            freq = 1.0E9 * elapsed / N / N;
            System.out.println("Multiply:" + "\t" + freq);


            /***************************************************************
             * comparison
             ***************************************************************/
            timer = new Stopwatch();
            boolean b = false;
            for (int i = 1; i <= N; i++) {
                for (int j = 1; j <= N; j++) {
                    b |= (i < j);
                }
            }
            elapsed = timer.elapsedTime();
            k2 += b?1:0;
            freq = 1.0E9 * elapsed / N / N;
            System.out.println("Comparison:" + "\t" + freq);


            //        /***************************************************************
            //         * remainder
            //         ***************************************************************/
            //        timer = new Stopwatch();
            //        for (int i = 1; i <= N; i++) {
            //            int k;
            //            for (int j = 1; j <= N; j++) {
            //                k = i % j;
            //            }
            //        }
            //        elapsed = timer.elapsedTime();
            //        freq = 1.0E9 * elapsed / N / N;
            //        System.out.println("Remainder:" + "\t" + freq);


            //        /***************************************************************
            //         * division
            //         ***************************************************************/
            //        timer = new Stopwatch();
            //        for (int i = 1; i <= N; i++) {
            //            int k;
            //            for (int j = 1; j <= N; j++) {
            //                k = i / j;
            //            }
            //        }
            //        elapsed = timer.elapsedTime();
            //        freq = 1.0E9 * elapsed / N / N;
            //        System.out.println("Division:" + "\t" + freq);


            //        /***************************************************************
            //         * floating point add
            //         ***************************************************************/
            //        timer = new Stopwatch();
            //        for (int i = 1; i <= N; i++) {
            //            double k;
            //            double fi = i;
            //            for (int j = 1; j <= N; j++) {
            //                k = fi + j;
            //            }
            //        }
            //        elapsed = timer.elapsedTime();
            //        freq = 1.0E9 * elapsed / N / N;
            //        System.out.println("Float Add:" + "\t" + freq);
            //
            //
            //        /***************************************************************
            //         * floating point add
            //         ***************************************************************/
            //        timer = new Stopwatch();
            //        for (double i = 1; i <= N; i++) {
            //            double k;
            //            double fi = i;
            //            for (double j = 1; j <= N; j++) {
            //                k = fi - j;
            //            }
            //        }
            //        elapsed = timer.elapsedTime();
            //        freq = 1.0E9 * elapsed / N / N;
            //        System.out.println("Float subtraction:" + "\t" + freq);
            //
            //
            //        /***************************************************************
            //         * floating point division
            //         ***************************************************************/
            //        timer = new Stopwatch();
            //        for (double i = 1; i <= N; i++) {
            //            double k;
            //            double fi = i;
            //            for (double j = 1; j <= N; j++) {
            //                k = fi / j;
            //            }
            //        }
            //        elapsed = timer.elapsedTime();
            //        freq = 1.0E9 * elapsed / N / N;
            //        System.out.println("Float Division:" + "\t" + freq);
            //
            //
            //        /***************************************************************
            //         * floating point multiply
            //         ***************************************************************/
            //        timer = new Stopwatch();
            //        for (double i = 1; i <= N; i++) {
            //            double fi = i;
            //            double k;
            //            for (double j = 1; j <= N; j++) {
            //                k = fi * j;
            //            }
            //        }
            //        elapsed = timer.elapsedTime();
            //        freq = 1.0E9 * elapsed / N / N;
            //        System.out.println("Float Multiply:" + "\t" + freq);


            /***************************************************************
             * Empty integer function call
             ***************************************************************/
            timer = new Stopwatch();
            k = 0;
            for (int i = 1; i <= N; i++) {
                for (int j = 1; j <= N; j++) {
                    k = f(i, j);
                }
            }
            k2 +=k;
            elapsed = timer.elapsedTime();
            freq = 1.0E9 * elapsed / N / N;
            System.out.println("Function call:" + "\t" + freq);


            //        /***************************************************************
            //         * Math.sin
            //         ***************************************************************/
            //        timer = new Stopwatch();
            //        for (double i = 1; i <= N/10.0; i++) {
            //            double k;
            //            for (double j = 1; j <= N; j++) {
            //                k = Math.sin(i + j);
            //            }
            //        }
            //        elapsed = timer.elapsedTime();
            //        freq = 1.0E9 * elapsed / N / N * 10;
            //        System.out.println("Math.sin:" + "\t" + freq);
            //
            //        /***************************************************************
            //         * Math.atan2
            //         ***************************************************************/
            //        timer = new Stopwatch();
            //        for (double i = 1; i <= N/10.0; i++) {
            //            double k;
            //            for (double j = 1; j <= N; j++) {
            //                k = Math.atan2(i, j);
            //            }
            //        }
            //        elapsed = timer.elapsedTime();
            //        freq = 1.0E9 * elapsed / N / N * 10;
            //        System.out.println("Math.atan2:" + "\t" + freq);
            //
            //        /***************************************************************
            //         * Math.random
            //         ***************************************************************/
            //        timer = new Stopwatch();
            //        for (double i = 1; i <= N/10.0; i++) {
            //            double k;
            //            for (double j = 1; j <= N; j++) {
            //                k = Math.random();
            //            }
            //        }
            //        elapsed = timer.elapsedTime();
            //        freq = 1.0E9 * elapsed / N / N * 10;
            //        System.out.println("Math.random:" + "\t" + freq);

            /***************************************************************
             * addition
             ***************************************************************/
            timer = new Stopwatch();
            k = 0;
            for (int i = 1; i <= N; i++) {
                for (int j = 1; j <= N; j++) {
                    k += i + j;
                }
            }
            k2 += k;
            elapsed = timer.elapsedTime();
            freq = 1.0E9 * elapsed / N / N;
            System.out.println("Integer addition:" + "\t" + freq);

            /***************************************************************
             * addition - using result
             ***************************************************************/
            timer = new Stopwatch();
            k = 0;
            for (int i = 1; i <= N; i++) {
                for (int j = 1; j <= N; j++) {
                    k += i + j;
                }
            }
            k2 += k;
            elapsed = timer.elapsedTime();
            freq = 1.0E9 * elapsed / N / N;
            System.out.println("Integer addition (use result):" + "\t" + freq);

            /***************************************************************
             * Array Access - first element
             ***************************************************************/
            int[] array = new int[1_000_000];

            timer = new Stopwatch();
            for (int i = 1; i <= N; i++) {
                for (int j = 1; j <= N; j++) {
                    k += array[0];
                }
            }
            k2 += k;
            elapsed = timer.elapsedTime();
            freq = 1.0E9 * elapsed / N / N;
            System.out.println("read array[0]: " + "\t" + freq);

            /***************************************************************
             * Array Access - last element
             ***************************************************************/
            timer = new Stopwatch();
            for (int i = 1; i <= N; i++) {
                for (int j = 1; j <= N; j++) {
                    k += array[500_000];
                }
            }
            k2 += k;
            elapsed = timer.elapsedTime();
            freq = 1.0E9 * elapsed / N / N;
            System.out.println("read array[500_000]:" + "\t" + freq);

            /***************************************************************
             * Array Access - last element
             ***************************************************************/
            timer = new Stopwatch();
            for (int i = 1; i <= N; i++) {
                for (int j = 1; j <= N; j++) {
                    k += array[999_999];
                }
            }
            k2 += k;
            elapsed = timer.elapsedTime();
            freq = 1.0E9 * elapsed / N / N;
            System.out.println("read array[999_999]:" + "\t" + freq);

            /***************************************************************
             * Array write - middle element
             ***************************************************************/
            timer = new Stopwatch();
            for (int i = 1; i <= N; i++) {
                for (int j = 1; j <= N; j++) {
                    k += array[500_000];
                }
            }
            k2 += k;
            elapsed = timer.elapsedTime();
            freq = 1.0E9 * elapsed / N / N;
            System.out.println("write array[500_000]:" + "\t" + freq);

            /***************************************************************
             * Nothing at all
             ***************************************************************/
            timer = new Stopwatch();
            elapsed = timer.elapsedTime();
            freq = 1.0E9 * elapsed / N / N;
            System.out.println("Nothing:" + "\t" + freq);
            System.out.println("Result: (ignore) "+k2);
        }
    }
}