//  BigInt.cpp

//  BigInt stores an integer.
//  This version stores only non negative integers.
//  The integers may grow to very large size.  The
//  vector that stores the integer grows to match
//  the size of the number.

//  If BigInt has not been initialized, it prints
//  its value as #UNK.

//  tom bailey  16 feb 00

/*
	The storage for a BigInt contains

	bool known;
	vector<short> digit;    // digit[0] is the units digit

*/

#include <iostream>
#include <vector>
using namespace std;

#include "BigInt.h"


//  constructors

// post: this BigInt is #unknown
BigInt::BigInt() : known( false ) {
}


// pre:  n >= 0
// post: this BigInt represents n
BigInt::BigInt( long n ) {
	if( n<0 )
		known = false;
	else {
		known = true;
		while( n>0 ) {
			digit.push_back( n%10 );
			n /= 10;
		}
	}
}

	
// post: this BigInt is a copy of bigint
BigInt::BigInt( const BigInt & bigint ) : known( bigint.known ) {
	if( known )
		for( short i=0; i<bigint.digit.size(); i++ )
			digit.push_back( bigint.digit[i] );
}


//  addition operators

// post: the sum of this BigInt and right has been returned
BigInt 
BigInt::operator+( const BigInt & right ) const {
	BigInt result( *this );
	result += right;
	return result;
}


// post: this BigInt has been increased by right
const BigInt &
BigInt::operator += ( const BigInt & right ) {
	if( ! right.known ) {
		known = false;
		digit.resize( 0 );
	}
	else if( known ) {
		short both;
		if( digit.size() <= right.digit.size() )
			both = digit.size();
		else
			both = right.digit.size();
		// both is the largest index with digits in both 
		// numbers

		short carry( 0 );
		short i;
		for( i=0; i<both; ++i ) {
			short val = digit[i] + right.digit[i] + carry;
			digit[i] = val % 10;
			carry = val / 10;
		}
		for( ; i<digit.size(); ++i ) {
			short val = digit[i] + carry;
			digit[i] = val % 10;
			carry = val / 10;
		}
		for( ; i<right.digit.size(); ++i ) {
			short val = right.digit[i] + carry;
			digit.push_back( val % 10 );
			carry = val / 10;
		}
		if( carry > 0 )
			digit.push_back( carry );
	}
	return *this;
}


//  assignment

// post: this BigInt is a copy of rhs
const BigInt &
BigInt::operator=( const BigInt & rhs ) {
	if( this != &rhs ) {
		known = rhs.known;
		digit.resize( 0 );
		if( known ) 
			for( short i=0; i<rhs.digit.size(); ++i )
				digit.push_back( rhs.digit[i] );
	}
	return *this;
}


//  input/output helpers

// post: the value of this BigInt has been written to outf
void 
BigInt::print( ostream & outf ) const {
	if( ! known )
		outf << "#UNK";
	else if( digit.size() == 0 )
		outf << 0;
	else
		for( short i=digit.size()-1; i>=0; --i )
			outf << digit[i];
}


//  input/output operators

ostream & 
operator<<( ostream & outf, const BigInt & bigint ) {
	bigint.print( outf );
	return outf;
}