The goal of this lab is to gain more comfort with C++ functions and arrays. We will practice using arrays to process a list of numbers in various ways. A skeleton version the program will appear in your cs35/labs/01 directory when you run update35. The program handin35 will only submit files in this directory. In later labs you may have the opportunity to work with a partner, but for this lab you should work on your own.

For this lab you will prompt the user to enter a series of integers in a given range. Then you will perform some statistical analyses on the data and report the results. The most common statistical measure is the mean, which is simply the average. Another useful measure is the standard deviation, which provides an indication of how much the individual values in the data differ from the mean. A small standard deviation indicates that the data is tightly clustered. A large standard deviation indicates that the data is widespread. Finally, a histogram is a graphical way of summarizing the data by dividing it into separate ranges and then indicating how many data values fall into each range. Here is a sample run of a program that performs these three statistical analyses:

This program calculates statistics on a set of given data.
It calculates the mean, standard deviation, and prints a 
histogram of the values.

Enter integers in the range 0-100 to be stored, -1 to end.
> 90
> 89
> 97
> 95
> 123
Invalid value, try again.
> 84
> 71
> 78
> 88
> 82
> 100
> 55
> -1
Read in 11 valid values.

Mean: 84.455

Standard deviation: 12.324

Histogram:
   0 -    9: 
  10 -   19: 
  20 -   29: 
  30 -   39: 
  40 -   49: 
  50 -   59: *
  60 -   69: 
  70 -   79: **
  80 -   89: ****
  90 -   99: ***
 100 -  100: *

Develop your program incrementally. Create a main function first. Declare the array that will hold the data here and pass it to the functions for processing. The capacity of your array should be at least 50. Add the required functions one at a time, testing each one by calling it from main. Remember that you will need to declare the functions above main and then define them below main. Once you are convinced that a function is correct, move on to the next required function.

• To read in the data, you should use a function with the prototype:

  int getIntegerArray(int data[], int capacity, int min, int max, int sentinel);
  

  This function will read integers into the data array, which can hold at most capacity values. The values must be between min and max. The user will enter the sentinel value to quit. This function will return the number of valid values read in. Note the capacity may be larger than the actual number of values the user enters.
• To calculate the mean, you should write a function mean() (you must determine the prototype) which takes as parameters an int array containing the entered data and an int for the effective size; i.e., the number of values stored in the array. The function should return the calculated average as a float .
• To calculate the standard deviation, you should use a function standardDeviation() (you must determine the prototype) that takes as parameters an int array containing the entered data and an int for the effective size; i.e., the number of values stored in the array. To calculate the standard deviation, perform the following steps:
  1. Calculate the mean of the values in the array.
  2. Go through the individual values in the array and calculate the square of the difference between each value and the mean. Add all of these squared differences to a running total. There is a pow(base, exponent) function that you can use to calculate the square, which is part of the cmath library.
  3. Take the total from the previous step and divide it by the number of values in the array.
  4. Calculate the square root of the resulting quantity, which represents the standard deviation. There is a sqrt function, which is also part of the cmath library.
  5. Be sure to include the cmath library at the top of your program.
• To print the histogram, you should use a function with the prototype:

  void histogram(int data[], int n, int min, int max, int binSize);
  

  Notice that the return type of this function is void. This indicates that a function does not return any value. In this case the function prints information on the screen rather than returning a value. The parameters of this function include the data array, its effective size n, the smallest and largest possible values stored in the array, and the size of each bin. The number of asterisks in a particular row indicates the number of values in the data that fall into each designated range. You will need to use printf rather than cout to format the output appropriately. A handy tutorial on printf can be found here. In the sample run shown above, the bin size was 10. However, you should not assume that the bin size will always be 10. Shown below is the same set of data used in the sample run, but with a binSize of 7.

  Histogram:
     0 -    6: 
     7 -   13: 
    14 -   20: 
    21 -   27: 
    28 -   34: 
    35 -   41: 
    42 -   48: 
    49 -   55: *
    56 -   62: 
    63 -   69: 
    70 -   76: *
    77 -   83: **
    84 -   90: ****
    91 -   97: **
    98 -  100: *
  

  Notice that the last bin will often be a different size than the all the other bins.

You should not attempt to solve these problems until you solve the rest of the lab. This will not earn any extra credit, but is a good way to challenge your understanding of the concepts. While it won't help your score, it will give you major street cred.

First, try to think of implementation of your data array that does not have a capacity for user input. That is, no matter how many values the user enters, your array does not need to grow. The array size should still be small, e.g., a capacity of 200 that can still handle 500 values of user-input.

If you've figured that one out, try adding any additional function to print out a stem-and-leaf display - a statistics display similar to a histogram but without any lost information. See here for details. For the sample run above, your stem-and-leaf plot will look as follows:

Stem-leaf plot: 
   0 -    9: 
  10 -   19: 
  20 -   29: 
  30 -   39: 
  40 -   49: 
  50 -   59: 5
  60 -   69: 
  70 -   79: 18
  80 -   89: 2489
  90 -   99: 057
 100 -  100: 0

Notice that each * in the histogram was replaced by the actual singles digit in the data. Also, each row of values is sorted and may contain duplicates.
Once you are satisfied with your code, hand it in by typing handin35. This will copy the code from your cs35/labs/01 to my grading directory. You may run handin35 as many times as you like, and only the most recent submission will be recorded.