hugenumber.cpp

一个较完备的HugeNumber类

#include<iostream>
#include<cstring>
#include<iomanip>
using namespace std;

#include"HugeNumber.h"

HugeNumber::HugeNumber( int s )
: size ( s )
{
	hugeNumber = new int [ size + 1 ];
	floatPosition = size;
	precision = 0;

	for ( int i = 0; i <= size; i ++ )
		hugeNumber[ i ] = 0;
}

HugeNumber::HugeNumber( int * number, int s, int pos, int positiveNegtive, int precisionN )
: size ( s ), precision( precisionN ) 
{
	hugeNumber = new int [ size + 1 ];
	
	hugeNumber[ 0 ] = positiveNegtive;

	for ( int i = size - 1; i >= 0; i -- )
		hugeNumber[ i + 1 ] = number[ i ];

	floatPosition = pos;
}

HugeNumber::HugeNumber( const HugeNumber &huge )
{
	size = huge.size;
	floatPosition = huge.floatPosition;
	precision = huge.precision;

	delete []hugeNumber;
	hugeNumber = new int [ size + 1 ];

	for ( int i = size; i >= 0; i -- )
		hugeNumber[ i ] = huge.hugeNumber[ i ];
}


HugeNumber::~HugeNumber()
{
	delete []hugeNumber;
}

HugeNumber & HugeNumber::operator = ( const HugeNumber & huge )
{
	if ( &huge == this )
		return *this;

	size = huge.size;
	floatPosition = huge.floatPosition;
	precision = huge.precision;

	delete []hugeNumber;
	hugeNumber = new int [ size + 1 ];

	for ( int i = size; i >= 0; i -- )
		hugeNumber[ i ] = huge.hugeNumber[ i ];
 
	return *this;
}

bool HugeNumber::operator > ( const HugeNumber &huge )
{
	if ( floatPosition > huge.floatPosition )
		return true;
	else if ( floatPosition < huge.floatPosition )
		return false;
	else
	{
		int size_;
		int *a = NULL, *b = NULL;
		if ( size >= huge.size )
		{
			size_ = size;
			a = new int [ size_ + 1 ];
			b = new int [ size_ + 1 ];

			copy( a, hugeNumber, size_ + 1 );

			for ( int i = 0; i <= size_; i ++ )
				if ( i <= huge.size )
					b[ i ] = huge.hugeNumber[ i ];
				else
					b[ i ] = 0;
		}
		else
		{
			size_ = huge.size;
			a = new int [ size_ + 1 ];
			b = new int [ size_ + 1 ];

			for ( int j = 0; j <= size_; j ++ )
				if ( j <= size )
					a[ j ] = hugeNumber[ j ];
				else
					a[ j ] = 0;

			copy( b, huge.hugeNumber, size_ + 1);
		}

		for ( int k = 1; k <= size_; )
			if ( a[ k ] > b[ k ] )
				return true;
			else if ( a[ k ] < b[ k ] )
				return false;
			else
				k ++;

		return false;
	}
}

void HugeNumber::print()
{
	if ( hugeNumber[ 0 ] )
		cout << '-';
	for ( int i = 1; i <= size; i ++ )
	{
		cout << hugeNumber [ i ];

		if ( i != size && i == floatPosition )
			cout << '.';
	}
	cout << endl;
}

HugeNumber & HugeNumber::operator += ( HugeNumber & huge )
{
	int pN;
	if ( hugeNumber[ 0 ] == 0 && huge.hugeNumber[ 0 ] == 1 )
	{
		huge.hugeNumber[ 0 ] = 0;
		*this -= huge;

		return *this;
	}
	else if ( hugeNumber[ 0 ] == 1 && huge.hugeNumber[ 0 ] == 0 )
	{
		hugeNumber[ 0 ] = 0;

		HugeNumber temp;
		temp = huge;
		temp -= *this;
		*this = temp;
		
		return *this;
	}
	else if ( hugeNumber [ 0 ] == 0 && huge.hugeNumber[ 0 ] == 0 )
		pN = 0;
	else
		pN = 1;

	int aFloatLength = size - floatPosition, 
		bFloatLength = huge.size - huge.floatPosition,
		aIntLength = floatPosition,
		bIntLength = huge.floatPosition;

	int rFloatLength = max( aFloatLength, bFloatLength ),
		rIntLength = max( aIntLength, bIntLength );

	int resultSize = rFloatLength + rIntLength;

	int *result = new int [ resultSize + 1 ];

	int i = rFloatLength; 
	if ( rFloatLength != aFloatLength )
		for ( i = rFloatLength; i > aFloatLength; i -- )
			result[ rIntLength + i ] = huge.hugeNumber[ bIntLength + i ];
	if ( rFloatLength != bFloatLength )
		for ( i = rFloatLength; i > bFloatLength; i -- )
			result[ rIntLength + i ] = hugeNumber[ aIntLength + i ];


	int indexA = aIntLength + i, indexB = bIntLength + i, indexR = rIntLength + i;
	int up = 0;
	while ( indexA && indexB )
	{
		result[ indexR ] = hugeNumber[ indexA -- ] + huge.hugeNumber[ indexB -- ] + up;
		up = result[ indexR ] / 10;
		result[ indexR ] %= 10;

		indexR --;
	}
	
	while ( indexA )
	{
		result[ indexR ] = hugeNumber[ indexA -- ] + up;
		up = result[ indexR ] / 10;
		result[ indexR ] %= 10;

		indexR --;
	}

	while ( indexB )
	{
		result[ indexR ] = huge.hugeNumber[ indexB -- ] + up;
		up = result[ indexR ] / 10;
		result[ indexR ] %= 10;

		indexR --;
	}

	int margin = 0;
	if ( up ) 
	{
		result[ 0 ] = up;
		margin = 1;
	}
	
	HugeNumber temp( result + 1 - margin, resultSize + margin, rIntLength + margin, pN, precision );
	delete []result;

	*this = temp;
	return *this;
}

HugeNumber & HugeNumber::operator -= ( HugeNumber &huge )
{
	int pN;
	if ( hugeNumber[ 0 ] == 0 && huge.hugeNumber[ 0 ] == 1 )
	{
		huge.hugeNumber[ 0 ] = 0;

		*this += huge;

		return *this;
	}
	else if ( hugeNumber[ 0 ] == 1 && huge.hugeNumber[ 0 ] == 0 )
	{
		huge.hugeNumber[ 0 ] = 1;
		*this += huge;

		return *this;
	}
	else if ( hugeNumber[ 0 ] == 0 && huge.hugeNumber[ 0 ] == 0 )
	{
		if ( huge > *this )
		{
			HugeNumber temp;
			temp = huge;

			temp -= *this;
			*this = temp;
			
			hugeNumber[ 0 ] = 1;
			return *this;
		}
		pN = 0;
	}
	else
	{
		hugeNumber[ 0 ] = 0;
		huge.hugeNumber[ 0 ] = 0;
		if ( huge > *this )
		{
			HugeNumber temp;
			temp = huge;

			temp -= *this;
			*this = temp;

			return *this;
		}
		pN = 1;
	}

	int rIntLength = max( floatPosition, huge.floatPosition ),
		aFloatLength = size - floatPosition,
		bFloatLength = huge.size - huge.floatPosition,
		rFloatLength = max( aFloatLength, bFloatLength );

	int length = rIntLength + rFloatLength + 1;
	int * a = new int [ length ];
	int * b = new int [ length ];
	int * result = new int [ length ];

	//copy hugeNumber[] and huge.hugeNumber to a[] and b[]
	int i;
	for ( i = 1; i <= rFloatLength; i ++ )
	{
		a[ rIntLength + i ] = ( i <= aFloatLength ? hugeNumber[ floatPosition + i ] : 0 );
		b[ rIntLength + i ] = ( i <= bFloatLength ? huge.hugeNumber[ huge.floatPosition + i ] : 0 );
	}

	int destA = rIntLength - floatPosition;
	int destB = rIntLength - huge.floatPosition;
	for ( i = 1; i <= rIntLength; i ++ )
	{
		a[ i ] = ( i <= destA ? 0 : hugeNumber[ i - destA ] );
		b[ i ] = ( i <= destB ? 0 : huge.hugeNumber[ i - destB ] );
	}
	 
	//sub the a[] and b[], and put the result in result[]
	int down = 0;
	for ( i = length - 1; i >= 1; i -- )
	{
		result[ i ] = a[ i ] - b[ i ] - down;
		if ( result[ i ] < 0 )
		{
			down = 1;
			result[ i ] += 10;
		}
		else
			down = 0;
	}

	int Length = length - 1, begin = 1, TempIntLength = rIntLength;
	for ( i = 1; result[ i ] == 0 && i < rIntLength; i ++ )
	{
		Length --;
		begin ++;
		TempIntLength --;
	}
	for ( i = length - 1; result[ i ] == 0 && i > rIntLength; i -- )
		Length --;

	HugeNumber temp( result + begin, Length, TempIntLength , pN, precision );
	*this = temp;

	delete []a;
	delete []b;
	delete []result;

	return *this;
}

HugeNumber & HugeNumber::operator *= ( const HugeNumber &huge )
{
	int pN;
	if ( hugeNumber[ 0 ] == huge.hugeNumber[ 0 ] )
		pN = 0;
	else
		pN = 1;

	int sizeA = size, sizeB = huge.size;
	int rSize = sizeA + sizeB;
	int *result = new int[ rSize + 1 ];
	init( result, rSize + 1 );

	int distRA = rSize - sizeA;
	for ( int indexB = sizeB; indexB >= 1; indexB -- )
	{
		int temp = huge.hugeNumber[ indexB ];
		int move = sizeB - indexB;
		int upMul = 0, upAdd = 0;

		int indexR;
		for ( int indexA = sizeA; indexA >= 1; indexA -- )
		{
			int t = temp * hugeNumber[ indexA ] + upMul;
			upMul = t / 10;
			t %= 10;

			indexR = indexA + distRA - move;
			result[ indexR ] += ( t + upAdd );
			upAdd = result[ indexR ] / 10;
			result[ indexR ] %= 10;
		}
		
		result[ indexR - 1 ] += ( upMul + upAdd );
	}

	int margin = 0;
	if ( result[ 1 ] == 0 )
		margin = 1;
	
	HugeNumber rTemp( result + 1 + margin, rSize - margin, floatPosition + huge.floatPosition - margin, pN, precision );

	delete []result;

	*this = rTemp;
	return *this;
}

HugeNumber & HugeNumber::operator /= ( const HugeNumber &huge )
{
	int pN;
	if ( hugeNumber[ 0 ] == huge.hugeNumber[ 0 ] )
		pN = 0;