import java.util.Random;

/**
 * This class investigates the behavior of the search methods in Searches.
 */
public class SearchTester
{
    /**
     * This method creates and returns an array of ints of the specified size.  It
     * ensures that the values in the array are in increasing order, yet random, by
     * remembering the last value added to the array and adding a random int to that
     * value to produce the next each time.
     * 
     * @param size  The length of the array to be created
     * @return An ordered array of integers of the specified size
     */
    public int[] buildOrderedArray(int size) {
        int[] nums = new int[size];     // Create the array we're going to fill
        Random rng = new Random();
        int next = 0;                   // Stores prevous value added to array
        for(int i=0; i<size; i=i+1) {       
            next = next + rng.nextInt(10);  // Add random to previous value to get next
            nums[i] = next;
        }
        return nums;
    }

    /**
     * This method creates an array of length size, performs multiple linear searches on
     * it, and reports the average number of comparisons required per search.
     * 
     * @param size  The length of the array to be searched
     * @param numSearches  The number of searches to be performed
     */
    public void averageLinearSearchCost(int size, int numSearches) {
        Random rng = new Random();
        int[] nums = buildOrderedArray(size);   // The array we'll search
        Searches s = new Searches();            // Need an instance of our Searches class
        for (int i=0; i<numSearches; i=i+1) {
            int key = nums[rng.nextInt(size)];  // Pick something to search for
            s.linearSearch(nums, key);   // Search for it
        }
        //         System.out.print("Did "+numSearches+" linear searches on array of length "+size);
        //         System.out.println(". Took "+(s.getCount()/(double)numSearches)+" comparisons on avg.");
        System.out.println(size+"\t"+(s.getCount()/(double)numSearches));
    }    

    /**
     * This method creates an array of length size, performs multiple binary searches on
     * it, and reports the average number of comparisons required per search.
     * 
     * @param size  The length of the array to be searched
     * @param numSearches  The number of searches to be performed
     */
    public void averageBinarySearchCost(int size, int numSearches) {
        Random rng = new Random();
        int[] nums = buildOrderedArray(size);   // The array we'll search
        Searches s = new Searches();            // Need an instance of our Searches class
        for (int i=0; i<numSearches; i=i+1) {   
            int key = nums[rng.nextInt(size)];  // Pick something to search for
            s.binarySearch(nums, key);          // Search for it
        }
        //       System.out.print("Did "+numSearches+" binary searches on array of length "+size);
        //       System.out.println(" Average # comparisons = "+(s.getCount()/(double)numSearches));
        System.out.println(size+"\t"+(s.getCount()/(double)numSearches));
    }

    
    public void runTests() {
        
        // Keep the arrays fairly small for linear search
        
        System.out.println("Testing linear search: array size, # comparisons");
        for (int size = 100; size<=10000; size=size+100) {
            averageLinearSearchCost(size, 500);
        }

        // For binary search we'll do two different loops -- one over small values
        // and one with larger steps.
        
        System.out.println("Testing binary search: array size, # comparisons");
        for (int size = 1000; size<100000; size=size+1000) {
            averageBinarySearchCost(size, 500);
        }
        
        
        System.out.println("Testing binary search with larger array sizes");
        for (int size = 100000; size<10000000; size=size+100000) {
            averageBinarySearchCost(size, 500);
        }

    }
}