mirror of
https://hub.njuu.cf/TheAlgorithms/C-Plus-Plus.git
synced 2023-10-11 13:05:55 +08:00
324 lines
7.9 KiB
C++
324 lines
7.9 KiB
C++
/**
|
|
* @author Krishna Vedala
|
|
* @email krishna (dot) vedala (at) ieee (dot) org
|
|
**/
|
|
|
|
#ifndef __LARGE_NUMBER__
|
|
#define __LARGE_NUMBER__
|
|
#include <type_traits>
|
|
#include <iostream>
|
|
#include <cassert>
|
|
#include <vector>
|
|
|
|
/**
|
|
* Store large unsigned numbers as a C++ vector
|
|
* The class provides convenience functions to add a
|
|
* digit to the number, perform multiplication of
|
|
* large number with long unsigned integers.
|
|
**/
|
|
class large_number
|
|
{
|
|
public:
|
|
large_number() /**< initializer */
|
|
{
|
|
_digits.push_back(1);
|
|
}
|
|
|
|
large_number(unsigned long n) /**< initializer */
|
|
{
|
|
unsigned long carry = n;
|
|
do
|
|
{
|
|
add_digit(carry % 10);
|
|
carry /= 10;
|
|
} while (carry != 0);
|
|
}
|
|
|
|
large_number(const large_number &a) /**< initializer */
|
|
{
|
|
_digits = a._digits;
|
|
}
|
|
|
|
large_number(const std::vector<unsigned char> &vec) /**< initializer */
|
|
{
|
|
_digits = vec;
|
|
}
|
|
|
|
/**
|
|
* Function to check implementation
|
|
**/
|
|
static bool test()
|
|
{
|
|
std::cout << "------ Checking `large_number` class implementations\t" << std::endl;
|
|
large_number a(40);
|
|
a *= 10;
|
|
if (a != large_number(400))
|
|
{
|
|
std::cerr << "\tFailed 1/5 (" << a << "!=400)" << std::endl;
|
|
return false;
|
|
}
|
|
std::cout << "\tPassed 1/5...";
|
|
a += 120;
|
|
if (a != large_number(520))
|
|
{
|
|
std::cerr << "\tFailed 2/5 (" << a << "!=520)" << std::endl;
|
|
return false;
|
|
}
|
|
std::cout << "\tPassed 2/5...";
|
|
a *= 10;
|
|
if (a != large_number(5200))
|
|
{
|
|
std::cerr << "\tFailed 3/5 (" << a << "!=5200)" << std::endl;
|
|
return false;
|
|
}
|
|
std::cout << "\tPassed 3/5...";
|
|
++a;
|
|
if (a != large_number(5201))
|
|
{
|
|
std::cerr << "\tFailed 4/5 (" << a << "!=5201)" << std::endl;
|
|
return false;
|
|
}
|
|
std::cout << "\tPassed 4/5...";
|
|
a++;
|
|
if (a != large_number(5202))
|
|
{
|
|
std::cerr << "\tFailed 5/5 (" << a << "!=5202)" << std::endl;
|
|
return false;
|
|
}
|
|
std::cout << "\tPassed 5/5..." << std::endl;
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* add a digit at MSB to the large number
|
|
**/
|
|
void add_digit(unsigned int value)
|
|
{
|
|
if (value > 9)
|
|
{
|
|
std::cerr << "digit > 9!!\n";
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
_digits.push_back(value);
|
|
}
|
|
|
|
/**
|
|
* Get number of digits in the number
|
|
**/
|
|
const size_t num_digits() const
|
|
{
|
|
return _digits.size();
|
|
}
|
|
|
|
/**
|
|
* operator over load to access the
|
|
* i^th digit conveniently and also
|
|
* assign value to it
|
|
**/
|
|
inline unsigned char &operator[](size_t n)
|
|
{
|
|
return this->_digits[n];
|
|
}
|
|
|
|
inline const unsigned char &operator[](size_t n) const
|
|
{
|
|
return this->_digits[n];
|
|
}
|
|
|
|
/**
|
|
* operator overload to compare two numbers
|
|
**/
|
|
friend std::ostream &operator<<(std::ostream &out, const large_number &a)
|
|
{
|
|
for (size_t i = a.num_digits(); i > 0; i--)
|
|
out << a[i - 1] + '0';
|
|
return out;
|
|
}
|
|
|
|
/**
|
|
* operator overload to compare two numbers
|
|
**/
|
|
friend bool operator==(const large_number &a, const large_number b)
|
|
{
|
|
size_t N = a.num_digits();
|
|
if (N != b.num_digits())
|
|
return false;
|
|
for (size_t i = 0; i < N; i++)
|
|
if (a[i] != b[i])
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* operator overload to compare two numbers
|
|
**/
|
|
friend bool operator!=(const large_number &a, const large_number b)
|
|
{
|
|
return !(a == b);
|
|
}
|
|
|
|
/**
|
|
* operator overload to increment (prefix)
|
|
**/
|
|
large_number &operator++()
|
|
{
|
|
this->add((unsigned int)1);
|
|
return *this;
|
|
}
|
|
|
|
/**
|
|
* operator overload to increment (postfix)
|
|
**/
|
|
large_number &operator++(int)
|
|
{
|
|
large_number tmp(_digits);
|
|
++(*this);
|
|
return tmp;
|
|
}
|
|
|
|
/**
|
|
* operator overload to add
|
|
**/
|
|
template <class T>
|
|
large_number &operator+=(T &n)
|
|
{
|
|
if (std::is_same<T, large_number>::value) // if adding with another large_number
|
|
{
|
|
large_number *b = &n;
|
|
const size_t max_L = std::max(this->num_digits(), b->num_digits());
|
|
unsigned int carry = 0, temp;
|
|
for (size_t i = 0; i < max_L; i++)
|
|
{
|
|
temp += carry;
|
|
if (i < b->num_digits())
|
|
temp += (*b)[i];
|
|
if (i < this->num_digits())
|
|
temp += (*this)[i];
|
|
if (temp < 10)
|
|
carry = 0;
|
|
else
|
|
{
|
|
carry = temp / 10;
|
|
temp = temp % 10;
|
|
}
|
|
if (i < this->num_digits())
|
|
(*this)[i] = temp;
|
|
else
|
|
this->add_digit(temp);
|
|
}
|
|
while (carry != 0)
|
|
{
|
|
if (i < this->num_digits())
|
|
(*this)[i] = carry % 10;
|
|
else
|
|
this->add_digit(carry % 10);
|
|
carry /= 10;
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
|
|
static_assert(std::is_integral<T>::value, "Must be integer addition unsigned integer types.");
|
|
// typedef typename std::make_unsigned<T>::type T2;
|
|
this->add(b);
|
|
return *this;
|
|
}
|
|
|
|
// /**
|
|
// * operator overload to increment
|
|
// **/
|
|
// friend large_number &operator+(large_number a, const large_number b)
|
|
// {
|
|
// const size_t max_L = std::max(a.num_digits(), b.num_digits());
|
|
|
|
// return a;
|
|
// }
|
|
|
|
/**
|
|
* operator overload to increment
|
|
**/
|
|
template <class T>
|
|
large_number &operator*=(const T n)
|
|
{
|
|
static_assert(std::is_integral<T>::value, "Must be integer addition unsigned integer types.");
|
|
this->multiply(n);
|
|
return *this;
|
|
}
|
|
|
|
/**
|
|
* returns i^th digit as an ASCII character
|
|
**/
|
|
const char digit_char(size_t i) const
|
|
{
|
|
return _digits[num_digits() - i - 1] + '0';
|
|
}
|
|
|
|
private:
|
|
/**
|
|
* multiply large number with another integer and
|
|
* store the result in the same large number
|
|
**/
|
|
template <class T>
|
|
void multiply(const T n)
|
|
{
|
|
static_assert(std::is_integral<T>::value, "Can only have integer types.");
|
|
// assert(!(std::is_signed<T>::value)); //, "Implemented only for unsigned integer types.");
|
|
|
|
size_t i;
|
|
unsigned long long carry = 0, temp;
|
|
for (i = 0; i < this->num_digits(); i++)
|
|
{
|
|
temp = (*this)[i] * n;
|
|
temp += carry;
|
|
if (temp < 10)
|
|
carry = 0;
|
|
else
|
|
{
|
|
carry = temp / 10;
|
|
temp = temp % 10;
|
|
}
|
|
(*this)[i] = temp;
|
|
}
|
|
|
|
while (carry != 0)
|
|
{
|
|
this->add_digit(carry % 10);
|
|
carry /= 10;
|
|
}
|
|
};
|
|
|
|
/**
|
|
* add large number with another integer and
|
|
* store the result in the same large number
|
|
**/
|
|
template <class T>
|
|
void add(const T n)
|
|
{
|
|
static_assert(std::is_integral<T>::value, "Can only have integer types.");
|
|
// static_assert(!(std::is_signed<T>::value), "Implemented only for unsigned integer types.");
|
|
|
|
size_t i = 0;
|
|
long long carry = n;
|
|
|
|
while (carry != 0)
|
|
{
|
|
if (i < this->num_digits())
|
|
{
|
|
carry += (*this)[i];
|
|
(*this)[i] = carry % 10;
|
|
i++;
|
|
}
|
|
else
|
|
this->add_digit(carry % 10);
|
|
carry /= 10;
|
|
if (carry == 0)
|
|
return;
|
|
}
|
|
};
|
|
|
|
std::vector<unsigned char> _digits; /**< where individual digits are stored */
|
|
};
|
|
|
|
#endif
|