Project 1

Posted: Wednesday, Oct 6th, 2010
Due: Wednesday, Oct 20th 2010, 11:59pm (Pacific Time)
Late deadline: Thursday, Oct 21st 2010, 11:59pm (Pacific Time)

Introduction

You have two weeks to complete the assignment. It's a non-trivial assignment, so you should get started early.

Files

• Makefile
• BigInt.h
• BigInt.cc
• fact.cc

Assignment

We'll give you the specification for this class, and the implementation for some of the member functions. You will have to decide how to represent internally the BigInt first. Then, you will complete the member (and related) functions and test it on some programs.

Summary of requirements (details appear in following sections):

• Complete the BigInt implementation (write constructors, destructors, comparison operator, output operator, +, *, +=, etc.)
• Reimplement BigInt::operator *=
• Write a BigInt test program, bigtest.cc, which thoroughly test your class and create test data files for it if necessary.
• Create a README file explaining your tests and documenting any bugs.

BigInt interface

Here are the operations on BigInt. You must implement them all. Do NOT change the interface of the class (otherwise we will not be able to test your code, and you will get a bad score). Assume that the big integers are always positive or zero (no sign is necessary).

class BigInt
{
  public:
    
    BigInt();                          // default constructor, value = 0
    BigInt(const BigInt &);        // copy constructor

    BigInt(int);               // assign an integer value
    BigInt(const String &);    // assign a string     
    ~BigInt();                 // destructor

    // operators: arithmetic, relational, output

    friend ostream & operator <<(ostream &, const BigInt &);

    const BigInt & operator += (const BigInt &);    

    const BigInt & operator *= (const BigInt &);    
    BigInt & operator = (const BigInt &);

    friend int operator == (const BigInt &, const BigInt &);
    friend int operator < (const BigInt &, const BigInt &);
  private:

    // add your representation here
};


BigInt operator +(const BigInt &, const BigInt &);
BigInt operator *(const BigInt &, const BigInt &);
int operator != (const BigInt &, const BigInt &);
int operator > (const BigInt &, const BigInt &);
int operator >= (const BigInt &, const BigInt &);
int operator <= (const BigInt &, const BigInt &);

Multiplication is a special case. There is an implementation of *= in the current BigInt.cc, implemented in terms of += (i.e., using repeated additions). You may use this version of the function to help you test your += function, although won't be able to use it until you've implemented several of the other functions too. However, you are required to reimplement *= in a more efficient way for your final program (see Hints on Arithmetic Operations, below).

See BigInt.h for more thorough specification of these functions.

Representation of BigInts

The internal representation is your choice, as long as it is dynamically allocated (i.e., dynamic array, STL vectors, strings, etc.).

Hints on arithmetic operations

You are required to add and multiply using the grade school methods you learned. For add that means adding digit by digit, and carrying a 1 where necessary. When working on your algorithm for a+=b we recommend you consider cases where a has more digits, b has more digits, and they are the same size.

To multiply a BigInt by a BigInt consider the example below:

Note that each partial product is shifted-left (padded with the appropriate number of zeros). Rather than shift the partial product by adding the appropriate number of zeros, one of the numbers being multiplied can be shifted (of course this is what is really happening in the example above where the top number is multiplied by 9, 80, and 700). This allows the product to be accumulated by summing a sequence of partial products where each partial product involves multiplying by a digit in the range 0-9. In the example above the final product is computed by

             (123,456 X 9) + (1,234,560 X 8) + (12,345,600 X 7)

Other implementation constraints

Once you implement < and ==, the other relational operators are already defined in terms of those two.

Testing your code

You may structure your test program in a few possible ways: one option is a program that takes no input, and runs several fixed tests over BigInts created in the program. Your output should be somewhat self-explanatory. E.g., for one of the tests of your add function, you could print the value of the BigInts being added (before the add), and what the result was, e.g.:

30 + 4 = 70

Or your program could take some input for BigInt values (i.e., they would be read in as Strings), to make it easier to test the same operations on different values. If your program takes input, you are also required to provide test data files for the program which collectively completely test your program. Your program should just read from cin, and you can use UNIX input redirection to get the input from a file.

How thoroughly you test your BigInt code will be a non-trivial portion of your grade on this assignment.

READ ME

Factorial program

We have given you a Makefile which makes an executable fact from fact.cc when you type make. You need to add rules to this Makefile for compiling your test program.

The program prompts for a number and then prints factorials from the entered number down to 1. If you invoke the program with a command-line argument as in fact 14 it will compute and print all factorials from the command-line argument down to 1.

Incremental development

For example, if your code to build a BigInt is untested, and you are testing += at the same time, it's difficult to determine where to look for any bugs that appear when you try to add. If, instead, you already know that your BigInts are being built correctly (because you tested this code in isolation), then you can isolate mistakes to +=.

A minimal subset you might want to test initially is one or more of your BigInt constructors with the printing routine (already written for you). Once you get your copy constructor, assignment operator and destructor working, you can then tackle the relational operators and +=, testing the latter in part using the *= operator (which is currently implemented in terms of +=). Then you can reimplement *=.

Style and Documentation

Grading

Submitting on time

Submitting late