This package contains a prototype of a homework/project for EECS 380
  *and* a mini-tutorial on measuring cpu time and memory consumption.

  Type 
    make clean
    make
  to build the prototype

  Type 
    ./projectName.exe
  to run the prototype. When working on a homework/project, you need 
  to change the Makefile so that produce an executable with a different name.

  If you have questions about this package, post them to 
  the umich.eecs.classes.380 newsgroup (clickable from the 
  course homepage http://www.eecs.umich.edu/courses/eecs380/
 
  Study the Makefile --- you will need to update it whenever you are
                         renaming/removing .cxx files or adding new ones

  When working on a homework/project, rename files nameMe.h and nameMe.cxx
  and mention your name in the beginning of each .cxx and .h file. 

  The UTIL sub-directory contains a library, which includes a timer
  and a memory tracker. It includes much more, but you do not need 
  to study the files in UTIL. Look at sample uses of library classes
  (in main.cxx) and mimick them in your homeworks/projects. You do not
  need to work in the UTIL directory.

  You will need to rewrite main.cxx for each homework/project.
  The current file main.cxx contains mini-tutorial on measuring runtime
  and memory consumption. You need to understand the logic behind this 
  code and will need to use same techniques in your homeworks and projects.

  In general, the main.cxx file should contain little/nothing else
  besides the main() function, which must be relatively small.
  Your C++ classes must be declared and implemented in separate files.
  You can use timers and memory tracker in those files. However, their
  extensive use may interfere with the measured runtime and memory consumption.

  ----------

  Notes about the MemUsage and Timer classes:

    MemUsage  --- the memory consumption is estimated at construction,
                  therefore you would need another instance to estimate
                  memory consumption second time. You can write
                     cout << MemUsage() << endl;

    Timer     --- the timer starts upon construction and must be stopped
                  before a time reading is requested. The timer can be 
                  restarted from start(), which continue the time measurement.

                  When measuring the runtime of your programs, you need
                  *user time* --- not the system time, not the real time.

                  On Unix systems (Linux, Solaris, etc), user and system time
                  readings are generally accurate up to 0.01 sec. Readings of
                  real (wall) time are only accurate up to 1 sec and can be
                  rounded arbitrarily.

   Both classes will most likely compile on Windows. However, no memory 
   information will be produced, and time readings may be less accurate.