Lab 7  Comp 170-201 -- Dordal/Nabicht -- Wed, October 9, 2002
Final version due Fri Oct 18

In this lab we will create a histogram, using arrays. At the end, we'll
draw a graph of the data, so your project will be an *applet*. 
(Not to worry; I supply the drawing code.)
All the data analysis will go into init(); only the actual drawing
will go into paint().

First, let's generate a big array of random data:

// will need "import java.util.Random;"

final int DATASIZE = 1000;
double [] data = new double [DATASIZE];
for (int i=0; i<DATASIZE; i++) {
    double x = gen.nextDouble();        // be sure to create Random gen
    x = 10*x;
    data[i] = x*x;
}

This leaves the array data[] filled with numbers in the range from 0.0 to 
100.0. (Originally, x is between 0 and 1, but when we multiply it by 10 
it's between 0 and 10, and then x*x is between 0 and 100).

Now you are to collect frequency data. We'll have 10 categories:
0-10, 10-20, ... , 90-100. (Check that this is 10 categories, not 11.)
Create a second array, frequency, of size 10, of integers.
As frequency[] is used in two different methods of the applet, init() and 
paint(), you will need to declare it as a private global variable of your 
class.  frequency[0] is to be a count of how many elements in data[] are 
in the range 0-10; frequency[1] is to be a count of how many elements are 
in the range 10-20, etc. These are sometimes called *buckets*.

Given an x = data[i], one way to figure out which bucket to increment is with
a big if-else statement:
        if (x<10)      frequency[0]++;
        else if (x<20) frequency[1]++;
        else if (x<30) frequency[2]++; 
        else .... 
This is somewhat tiresome, however, so here's an easier way: if we divide 
x by 10, we get a double in the range 0.0-10.0. Now "cast" x to be an int.
        int index = (int) (x/10);
Before updating the appropriate frequency, with
        frequency[index]++;
you really should check first that index < frequency.length. If it's not,
you probably should just ignore it, although you might also print out an
error message.

Pull this all together to get the counts into the array "frequency".

Now, what the heck, let's *plot* the data. Below is a function that you should
copy-paste into your applet to do the drawing. 

    // draws a histogram of bars 20 units wide, scaled so a bar of 
    // height max is 200 units wide, with (x,y) as lowerleft corner).
    public void histoplot(Graphics g, int[] bars, int max, int x, int y) {
        final int WIDTH=20;
        final int MAXHEIGHT=200;
        for (int i=0; i<bars.length; i++) {
            double scaledheight = MAXHEIGHT * ((double) bars[i])/max;
            int upper_y = y - (int) scaledheight;
            g.drawRect(x+i*WIDTH, upper_y, WIDTH, (int)scaledheight);
        }
        Integer MAX = new Integer(max);
        g.drawString(MAX.toString(), x-30, y-MAXHEIGHT+5);
    }
    
You will call this from your applet's paint() method. The form of the call is
                histoplot(g, frequency, max, 100, 300);
where g is the Graphics, frequency is your array of frequencies, 100 and 300 
are the x and y coordinates respectively of the chart's lower-left corner, 
and max is the maximum of all the values in the frequency array.

You will have to write a simple loop to find max, although, if you use
DATASIZE = 1000, you can try MAX = 300 initially. (Another quick-and-dirty
trick is that max is almost certainly frequency[0], although you shouldn't
assume this in your final version.) The actual value of max
is printed out on the histogram to indicate the scale.

Don't confuse the array frequency[], of integers, with the array data[].

1. After you get this running, make another run with a larger DATASIZE, 
eg 10,000 or even 100,000. Why is the histogram more smooth then?

2. Now change frequency to be an array of 20 integers, and adjust the data 
so all the buckets are used. (The easiest way is to go through the 
array data[] and multiply each entry by 2.0.) Note that the bucket "sizes" 
are still 10 each; that is, to get the index values you still divide by 10. 
Be sure to check for index==20 now the same way we checked for index==10 
above. Draw the graph again. Note that histoplot still works, because the 
size of the array that it plots is not "hard-coded" in.

3. I carefully arranged the initialization code for data[], above, at the top,
so that the data values would lie between 0.0 and 100.0. Where in the rest
of the program do you make use of this assumption? If the data values range
from 0 to 200, as in #2 above, and you still make frequency an array of 
size 10, does the program run? Is some of the data ignored? If so, what data?