hugeint.cpp

CHugeInt

// HugeInt.cpp: implementation of the CHugeInt class.
//
//////////////////////////////////////////////////////////////////////

#include "HugeInt.h"

#include <iostream>
#include <vector>
#include <math.h>
#include <assert.h>
using namespace std;

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

const int CHugeInt::m_ciWeight = 10000;

CHugeInt::CHugeInt()
{

}

CHugeInt::~CHugeInt()
{

}

CHugeInt::CHugeInt(int iSrc)
{
	Add(iSrc);
}

CHugeInt::CHugeInt(const CHugeInt& hiSrc)
{
	m_vecData = hiSrc.m_vecData;
}

inline void CHugeInt::Zero()
{
	m_vecData.clear();
}

void CHugeInt::Output()
{
	for (int i = 0; i < m_vecData.size(); i++)
	{
		if (i == 0)
		{
			printf("%d", m_vecData[m_vecData.size() - i - 1]);
		}
		else
		{
			printf("%04d", m_vecData[m_vecData.size() - i - 1]);
		}
	}
}

void CHugeInt::AddSmall(int iIndex, int iValue)
{
	// check parameters
	assert(iIndex <= m_vecData.size());
	assert(iValue < m_ciWeight);

	while ((iIndex < m_vecData.size())
		&& ((m_vecData[iIndex] + iValue) >= m_ciWeight) 
		)
	{
		m_vecData[iIndex] += iValue;
		iValue = m_vecData[iIndex]/m_ciWeight;
		m_vecData[iIndex] = m_vecData[iIndex]%m_ciWeight;
		iIndex++;
	}

	if (iIndex == m_vecData.size())
	{
		m_vecData.push_back(iValue);
	}
	else
	{
		m_vecData[iIndex] += iValue;
	}
}

inline void CHugeInt::Add(int iIndex, int iValue)
{
	// check parameters
	assert(iIndex <= m_vecData.size());

	do
	{
		AddSmall(iIndex, iValue%m_ciWeight);
		iValue = iValue/m_ciWeight;
		iIndex++;
	}while (iValue != 0);
}

inline CHugeInt& CHugeInt::Add(int iOperand)
{
	int iIndex = 0;
	do
	{
		AddSmall(iIndex, iOperand%m_ciWeight);
		iOperand = iOperand/m_ciWeight;
		iIndex++;
	}while (iOperand != 0);

	return *this;
}

CHugeInt& CHugeInt::Multiple(int iOperand)
{
	vector<int> vecA(m_vecData);
	m_vecData.clear();

	int j = 0;
	for (; j < vecA.size(); j++)
	{
		Add(j, iOperand * vecA[j]);
	}
	
	return *this;
}

inline CHugeInt& CHugeInt::operator = (int iOperand)
{
	m_vecData.clear();
	// 
	return Add(iOperand);
}

CHugeInt& CHugeInt::Add(const CHugeInt& hiOperand)
{
	int i = 0;
	for (; i < hiOperand.m_vecData.size(); i++)
	{
		AddSmall(i, hiOperand.m_vecData[i]);
	}

	return *this;
}

CHugeInt& CHugeInt::Multiple(const CHugeInt& hiOperand)
{
	vector<int> vecTemp;
	const vector<int>* pvecB;
	if (&hiOperand == this)
	{
		vecTemp = hiOperand.m_vecData;
		pvecB = &vecTemp;
	}
	else
	{
		pvecB = &hiOperand.m_vecData;
	}
	vector<int> vecA(m_vecData);
	m_vecData.clear();

	int i = 0;
	for (; i < pvecB->size(); i++)
	{
		int j = 0;
		for (; j < vecA.size(); j++)
		{
			Add(i + j, (*pvecB)[i] * vecA[j]);
		}
	}

	return *this;
}

CHugeInt& CHugeInt::operator = (const CHugeInt& hiOperand)
{
	// assign to self, thought need not
	if (&hiOperand == this)
	{
		return *this;
	}

	// 
	m_vecData = hiOperand.m_vecData;

	return *this;
}