Sample Assignment: The Statistician Class


stats.h:
The header file for the new statistician
class. Actually, you don't have to write much of this file.
Just start with
our version
and add your name and other information at the top.
If some of your member functions are implemented as inline
functions, then you may put those implementations in this file too.
stats.cxx:
The implementation file for the new
statistician class. You will write all of this file, which will
have the implementations of all the statistician's member functions.
stattest.cxx:
A simple interactive test program.
statexam.cxx:
A noninteractive test program that will
be used to grade the correctness of your statistician class.
As indicated above, you will implement a new class called statistician, using a header file (most of which is written for you) and an implementation file (which you will write by yourself). The statistician is a class that is designed to keep track of simple statistics about a sequence of real numbers. There are two member functions that you should understand at an informal level before you proceed any further. The prototypes for these two functions are shown here as part of the statistician class declaration:
class statistician { public: ... void next(double r); double mean( ) const; ... };
The member function "next" is used to give a sequence of numbers to the statistician one at a time. The member function "mean" is a constant member function that returns the arithmetic mean (i.e., the average) of all the numbers that have been given to the statistician.
Example: Suppose that you want a statistician to compute the mean of the sequence 1.1, 2.8, 0.9. Then you could write these statements:
// Declares a statistician object called s statistician s; // Give the three numbers 1.1, 2.8 and 0.9 to the statistician s.next(1.1); s.next(2.8); s.next(0.9); // Call the mean function, and print the result followed by a carriage return cout << s.mean( ) << endl;
The output statement will print 1.0, since 1.0 is the mean of the three numbers 1.1, 2.8 and 0.9.
Once you understand the workings of the next and mean member functions, you
can look at the complete specification of the statistician class, which is
in the file
stats.h
.
Notice that the statistician class in this file is part of a
namespace called main_savitch_2C
. You should use
this namespace for your statistician.
In this file you will find a
precondition/postcondition contract for all the statistician's member
functions, including:
==
which tests to see whether two statisticians
are "equal". The prototype is:
int operator ==(const statistician& s, const statistician& t);In order for two statisticians to be equal, they must have the same length (i.e., they have been given the same number of numbers). Also, if their length is greater than zero, they must also have the same mean, the same minimum, the same maximum, and the same sum. For example: Suppose that a statistician s has been given four numbers 1, 2, 3, 4. A second statistician t has been given four numbers 1, 1.5, 3.5, 4. Then the test (
s==t
)
must return true since both s and t have
equal values for all the member functions, as shown here:
statistician operator +(const statistician& s, const statistician& t);
statistician operator *(double scale, const statistician& s);This is not a member function. The result of a multiplication such as 2*s is a new statistician that looks as if it had been given all the numbers of s, multiplied by the constant 2. Examples: Suppose that s is a statistician that has been given 1, 2, 3, and u is another statistician. Then the assignment statement u=2*s will result in u behaving as if it had been given the numbers 2, 4, 6. As another example, the assignment statement u=3*s will result in u behaving as if it had been given the numbers 3, 6, 9. Notice that neither + nor
==
are member functions. (See Section 2.5 in
the class notes). The result of s+t is a new statistician that looks
as if it had been given all the numbers of the sequence for s, followed
by all the numbers of the sequence for t.
For example:
Suppose that we have three statisticians s, t, and u. The statistician
s has been given the numbers 1, 2, 3; the statistician t has been
given the numbers 4, 5. Then the assignment statement u=s+t will
result in u behaving as if it had been given the five numbers
1, 2, 3, 4, 5.
stats.h
.
Notice how the private member variables are being
used to keep track of information about the statistician's sequence of
numbers. The statistician does
NOT keep track of all the numbers in the sequence. There is no
need to do so, and trying to do so can get you into trouble. Instead, it
keeps track of only the information that is relevant to its member
functions: How many numbers have been seen? What is the sum of those
numbers? If you have seen at least one number, then what are the smallest
and largest numbers that you've seen so far? These four items should be
your only private member variables.
Be careful about how you set the private member variable that keeps track of the smallest number. My suggestion is that you do NOT have the constructor initialize this member variables (because when the constructor does its work, there have not yet been any numbers, so there is no smallest number). But part of the work of the "next" function is to correctly maintain the private member variables. This means that the first time that the next function is called, it should set the private member variable that keeps track of smallest values. Later, if next is called again with a smaller number, then the next function will change the member variable that is keeping track of the smallest value. (You'll have a similar process for the member variable that's keeping track of the largest value).
void statistician::next(double r) { // This is just a stub, to be implemented later. }A first implementation might have only:
Even with just stubs, your stats.cxx file will correctly
compile and link with the interactive test program,
stattest.cxx
.
For example, if you are using the g++ compiler, you would compile
and link the stattest program with these three commands:
g++ Wall c stats.cxx g++ Wall c stattest.cxx g++ stattest.o stats.o o stattest
ANSWER: No, leave those preconditions in there! The TA will clobber you (and I will too) if you delete the checks of the preconditions. Instead, you must find out where one of your functions is violating a precondition. Here is a typical example: Some students started by implementing the operator == along these lines:
bool operator == (const statistician& s1, const statistician& s2) { return (s1.length( ) == s2.length( )) && (s1.sum( ) == s2.sum( )) && (s1.minimum( ) == s2.minimum( )) && (s1.maximum( ) == s2.maximum( )); }The problem with this implementation is that the operator == is allowed to be called even if s1 or s2 or both are empty. In such a case, the function will eventually get down to the test (s1.minimum( ) == s2.minimum( )) and...assertion failed! because you cannot call minimum for an empty statistician.
How do you fix this problem? In your operator == you should start with a test to see whether s1 or s2 is empty (and handle those cases in a way that does not call minimum() or maximum() ).
MORAL: The functions you write can call other functions, but they must be careful to not violate preconditions.
ANSWER: There are several solutions. One idea is to not initialize them at all. In this case, you must be careful to make sure of two things: (A) When the first number is given to the next function, it puts that first number into both tiniest and largest. (B) None of the other functions ever try to use tiniest or largest for an empty statistician.
ANSWER: Well, any function that accesses tiniest, largest, minimum() or maximum() probably needs a special case. Sometimes the special case can be simple. For example, the start of my operator + has two special cases:
if (s1.length( ) == 0) return s2; if (s2.length( ) == 0) return s1;...now the rest of my code doesn't need to worry about s1 or s2 being empty.
ANSWER: Here's an example: Suppose that a statistician x has been given three numbers 10, 20 and 40. Then we execute the statement y = 1*x; The statistician y must act as if it had been given 10, 20 and 40 so y.minimum() will be 40 and y.maximum() will be 10.
ANSWER: First of all, make sure that you've completed the first lab exam from last week's lab ( http://www.cs.colorado.edu/~main/ds/lab1.html ). In fact, if you send a compilation problem to me or the TAs, and the first line of your message does not say that you've completed that lab exercise, well, you can guess what our answer will be. (Sorry to be so stern, but it's really needed.) Second: Make sure that all the code in your stats.cxx is in the namespace main_savitch_2C (look at the similar example of the point class on page 62).
ANSWER: See the second part of the answer to the previous question.
ANSWER: Yes. At this point of the game, about 60% of warnings are errors. (In CSCI 1300, I would say that 80% are errors.) In any case, the TAs will beat you up if your code generates any warnings. Spotting the cause of the warnings is an important part of learning about C++.
ANSWER: Not much of that is needed until a function gets longer than 1015 lines. I'll give you some examples of such functions in programming assignment 2 (which I'll post in the morning).
// Problem 1: s1.length( ) = s2.length( ) + s3.length( ); // You can't assign to a function such as length. Try assigning to // s1.sum (the variable) instead. // Problem 2: if (s1.length == s2.length) // You have to call the function. Try (s1.length() == s2.length()).