Homework 2: Stats

Educational Objectives: After successfully completing this assignment, the student should be able to accomplish the following:

• Use a loop structure to read user input of unknown size through std::cin and store it in an array.
• Use conditional branching to selectively perform computational tasks.
• Declare (prototype) and define (implement) functions.
• Declare and define functions with arguments of various types, including pointers, references, const pointers, and const references.
• Call functions, making appropriate use of the function arguments and their types.
• Make decisions as to appropriate function call parameter type, from among: value, reference, const reference, pointer, and const pointer.
• Compile and run a C++ program in the Unix/Linux environment using g++.

Operational Objectives: Create a single file named stats.cpp that computes the mean and median of a sequence of integers received via standard input.

Deliverables: One file stats.cpp.

Background

Given a finite collection of n numbers:

1. The mean is the sum of the numbers divided by n, and
2. The median is the middle value (in case n is odd) or the average of the two middle values (in case n is even).

Note that to find the median of a collection of data, it is convenient to first sort the data, that is, put the data in increasing (or non-decreasing) order. Then the median is just the middle datum in the sorted sequence (or the average of the two middle data, if there are an even number).

One of the simplest sort algorithms is called Selection Sort, which operates on an array of elements and has a computation which can be described in one sentence: For each element of the array, find the smallest element with equal or higher index in the array and swap these two elements. Here is a "pseudocode" description of the algorithm:

for i in [0...n)       // for each element of array A
  k = i                // find the smallest element following it
  for j in [i+1...n)
    if A[j] < A[k]
      k = j
    endif
  endfor               // now A[k] is the smallest element following A[i]
  swap the values in A[i] and A[k]
endfor

(You could test whether A[k] < A[i] before the swap, but it is not clear this would speed up the process - swapping may be faster than testing.)

Procedural Requirements:

1. Create and work within a separate subdirectory cop3330/hw2. Review the COP 3330 rules found in Introduction/Work Rules.

2. Turn in one file stats.cpp using the hw2submit.sh submit script.

   Warning: Submit scripts do not work on the program and linprog servers. Use shell.cs.fsu.edu to submit projects. If you do not receive the second confirmation with the contents of your project, there has been a malfunction.

Technical Requirements and Specifications

1. The project should compile error- and warning-free on linprog with the command g++ -ostats.x -Wall -Wextra stats.cpp.

2. The number of integers input by the user is not known in advance, except that it will not exceed 100. Numbers are input through standard input, either from keyboard or file re-direct. The program should read numbers until a non-digit or end-of-file is encountered or 100 numbers have been read.

3. Once the input numbers have been read, the program should calculate the mean and median and then report these values to standard output.

4. The source code should be structured and organized as follows:

   1. Implement separate functions with the following prototypes:

      float Mean   (const int* a, size_t size); // calculates mean of data in a
      float Median (int* a, size_t size);       // calculates median of data in a
      void  Swap   (int& x, int& y);            // interchanges values of x and y
      void  Sort   (int* a, size_t size);       // sorts the data in a
      

   2. I/O is handled by function main(); no other functions should do any I/O
   3. Function main() calls Mean() and Median()
   4. Function Median() calls Sort()
   5. Function Sort() calls Swap()

5. The Sort() function should implement the Selection Sort algorithm.

6. When in doubt, your program should behave like the distributed executable examples in stats_i.x and stats_s.x in area51. Identical behavior is not required, but the general I/O behavior should be the same. In particular, the data input loop should not be interupted by prompts for a next datum - this will make file redirect cumbersome. Just ask for the data one time, then read until a non-digit or end of file is encountered.

Hints

• Two test files are distributed in cop3330p/fall08/hw2. A working executable is distributed in cop3330p/fall08/area51. To run the sample executable on a file, say data1, first make sure you have an executable copy of the program and the data file, then enter the command:
       stats.x < data1
  This is a Unix/Linux operation that redirects the contents of data1 into standard input for stats.x. Using > redirects program output. For example, the command:
       stats.x < data1 > data1.out
  sends the contents of data1 to standard input and then sends the program output into the file data1.out. These are very handy operations for testing programs.
• Note that the array in which input is stored is passed to the functions as a pointer. In the case of Mean(), this pointer is const, indicating that the elements of the array may not be changed by the call. However in the case of Median(), the array element values are allowed to change. These values are in fact changed by the call to Sort().
• The function Sort() operates on the array input as a pointer. When the function returns, the values of the array should be in increasing order.
• The selection sort algorithm requires a nested pair of for loops (one inside the other).
• The function Swap() encapsulates the chore of swapping two values. Your sort implementation should call Swap whever two values need to be swapped. Note that the two parameters for Swap are passed by reference, so that the function acts on the values in the calling routine.
• Sorting the data is essential to calculate the median: when in an array that is sorted, the middle (two) values are those contained in the middle (two) indices of the array.
• The middle index of an array of n elements, when n is odd, is [(n-1)/2]. The middle two indices, when n is even, are [n/2 - 1] and [n/2].
• Be careful when subtracting 1 from an unsigned integer type such as size_t.
• Look at the code examples in Chapter 3 of the lecture notes to find simple ways to structure your main I/O loop.