CS 315 Assignment 1: Timing and Big O

Due: September 8, 2011, in class.

Examine and test the factorial functions fact(n) where
n is int, Integer, long,
float, and double.
For how large a value of n does fact(n) correctly
and accurately compute the factorial in each case? (We will assume
that "accurately" means that all digits of the factorial are correct.)
Did you get any indication (such as a runtime exception) if the
value of the factorial was incorrect?

The file timing.java contains some mystery functions
mickey, minnie, donald, goofy,
pluto,
gyro,
and daffy, and also a BigInteger version of fact.
We want to analyze the performance of these functions experimentally.

For daffy and donald, time the functions for values
of n from 30 through 44 . Plot these times
(if appropriate) on semi-log paper.

For mickey, minnie, goofy, and pluto,
initialize by making an array of size n with randomarr(n).
The initialization of the array should not be inside the timing calls.
Use values of n of 1000, 2000, 4000
... through 128000 .

For gyro, make an array using randomarr(n) and call
pluto on it first. (pluto should not be included in
the timing). Use values of n of 1000, 2000,
4000 ... through 128000 .

For fact(BigInteger n), test on values of n from
1000 through 64000, doubling each time. You can make
a BigInteger using code such as:

BigInteger bign = BigInteger.valueOf((long) 1000);

A BigIntegerbign that is not too large can be converted to
an int using bign.intValue() . There are operations
.add(), .subtract(), .multiply(), and
.divide(), each wih a BigInteger argument.

For each of the functions, plot the time taken vs. n on
log-log paper and estimate the big-O for the function.
Note that the timer will not be accurate for very small times,
e.g. less than a millisecond (0.001 second). If all the times of a
function are too small, just report that the function is too fast
to measure (and don't plot it). Do not include times that are too
small in your plots, since the reported times are just noise.

For mickey, minnie, goofy, and pluto,
also estimate the Big O of each function using the ratio of times
as the input size is doubled. The time of the stopwatch in seconds
can be obtained (as double) as timer.time().
For small values of the input size, the times will be noisy and the
ratio will not be meaningful, so you may need to ignore the first few
ratio values and concentrate on the ratios for larger inputs.