OpenSoure_Repos/TheAlgorithms-C-Plus-Plus
1
0
Fork 0
mirror of https://hub.njuu.cf/TheAlgorithms/C-Plus-Plus.git synced 2023-10-11 13:05:55 +08:00
Code Issues Packages Projects Releases Wiki Activity

code cleanup

Browse Source
This commit is contained in:
Krishna Vedala 2020-05-24 16:24:41 -04:00
parent 6276e4ec06
commit b802dbe077
1 changed files with 231 additions and 240 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

471
others/large_number.h
View File

@ -5,6 +5,7 @@
#ifndef OTHERS_LARGE_NUMBER_H_ #ifndef OTHERS_LARGE_NUMBER_H_
#define OTHERS_LARGE_NUMBER_H_ #define OTHERS_LARGE_NUMBER_H_
#include <algorithm>
#include <cassert> #include <cassert>
#include <cinttypes> #include <cinttypes>
#include <cstring> #include <cstring>
@ -19,263 +20,253 @@
* large number with long unsigned integers. * large number with long unsigned integers.
**/ **/
class large_number { class large_number {
public: public:
large_number() /**< initializer with value = 1 */ { _digits.push_back(1); } /**< initializer with value = 1 */
large_number() { _digits.push_back(1); }
large_number(uint64_t n) /**< initializer from an integer */ /**< initializer from an integer */
{ explicit large_number(uint64_t n) {
uint64_t carry = n; uint64_t carry = n;
do { do {
add_digit(carry % 10); add_digit(carry % 10);
carry /= 10; carry /= 10;
} while (carry != 0); } while (carry != 0);
}
/**< initializer from another large_number */
explicit large_number(const large_number &a) { _digits = a._digits; }
/**< initializer from a vector */
explicit large_number(const std::vector<unsigned char> &vec) {
_digits = vec;
}
/**< initializer from a string */
explicit large_number(const char *number_str) {
for (size_t i = strlen(number_str); i > 0; i--) {
unsigned char a = number_str[i - 1] - '0';
if (a >= 0 && a <= 9) _digits.push_back(a);
}
}
/**
* Function to check implementation
**/
static bool test() {
std::cout << "------ Checking `large_number` class implementations\t"
<< std::endl;
large_number a(40);
// 1. test multiplication
a *= 10;
if (a != large_number(400)) {
std::cerr << "\tFailed 1/6 (" << a << "!=400)" << std::endl;
return false;
}
std::cout << "\tPassed 1/6...";
// 2. test compound addition with integer
a += 120;
if (a != large_number(520)) {
std::cerr << "\tFailed 2/6 (" << a << "!=520)" << std::endl;
return false;
}
std::cout << "\tPassed 2/6...";
// 3. test compound multiplication again
a *= 10;
if (a != large_number(5200)) {
std::cerr << "\tFailed 3/6 (" << a << "!=5200)" << std::endl;
return false;
}
std::cout << "\tPassed 3/6...";
// 4. test increment (prefix)
++a;
if (a != large_number(5201)) {
std::cerr << "\tFailed 4/6 (" << a << "!=5201)" << std::endl;
return false;
}
std::cout << "\tPassed 4/6...";
// 5. test increment (postfix)
a++;
if (a != large_number(5202)) {
std::cerr << "\tFailed 5/6 (" << a << "!=5202)" << std::endl;
return false;
}
std::cout << "\tPassed 5/6...";
// 6. test addition with another large number
a = a + large_number("7000000000000000000000000000000");
if (a != large_number("7000000000000000000000000005202")) {
std::cerr << "\tFailed 6/6 (" << a << "!=7000000000000000000000000005202)"
<< std::endl;
return false;
}
std::cout << "\tPassed 6/6..." << 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);
} }
large_number( _digits.push_back(value);
const large_number &a) /**< initializer from another large_number */ }
{
_digits = a._digits;
}
large_number( /**
const std::vector<unsigned char> &vec) /**< initializer from a vector */ * Get number of digits in the number
{ **/
_digits = vec; const size_t num_digits() const { return _digits.size(); }
}
large_number(const char *number_str) /**< initializer from a string */ /**
{ * operator over load to access the
for (size_t i = strlen(number_str); i > 0; i--) { * i^th digit conveniently and also
unsigned char a = number_str[i - 1] - '0'; * assign value to it
if (a >= 0 && a <= 9) **/
_digits.push_back(a); inline unsigned char &operator[](size_t n) { return this->_digits[n]; }
}
}
/** inline const unsigned char &operator[](size_t n) const {
* Function to check implementation return this->_digits[n];
**/ }
static bool test() {
std::cout << "------ Checking `large_number` class implementations\t"
<< std::endl;
large_number a(40);
// 1. test multiplication
a *= 10;
if (a != large_number(400)) {
std::cerr << "\tFailed 1/6 (" << a << "!=400)" << std::endl;
return false;
}
std::cout << "\tPassed 1/6...";
// 2. test compound addition with integer
a += 120;
if (a != large_number(520)) {
std::cerr << "\tFailed 2/6 (" << a << "!=520)" << std::endl;
return false;
}
std::cout << "\tPassed 2/6...";
// 3. test compound multiplication again
a *= 10;
if (a != large_number(5200)) {
std::cerr << "\tFailed 3/6 (" << a << "!=5200)" << std::endl;
return false;
}
std::cout << "\tPassed 3/6...";
// 4. test increment (prefix)
++a;
if (a != large_number(5201)) {
std::cerr << "\tFailed 4/6 (" << a << "!=5201)" << std::endl;
return false;
}
std::cout << "\tPassed 4/6...";
// 5. test increment (postfix)
a++;
if (a != large_number(5202)) {
std::cerr << "\tFailed 5/6 (" << a << "!=5202)" << std::endl;
return false;
}
std::cout << "\tPassed 5/6...";
// 6. test addition with another large number
a = a + large_number("7000000000000000000000000000000");
if (a != large_number("7000000000000000000000000005202")) {
std::cerr << "\tFailed 6/6 (" << a
<< "!=7000000000000000000000000005202)" << std::endl;
return false;
}
std::cout << "\tPassed 6/6..." << std::endl;
return true;
}
/** /**
* add a digit at MSB to the large number * operator overload to compare two numbers
**/ **/
void add_digit(unsigned int value) { friend std::ostream &operator<<(std::ostream &out, const large_number &a) {
if (value > 9) { for (size_t i = a.num_digits(); i > 0; i--)
std::cerr << "digit > 9!!\n"; out << static_cast<int>(a[i - 1]);
exit(EXIT_FAILURE); return out;
} }
_digits.push_back(value); /**
} * operator overload to compare two numbers
**/
friend bool operator==(large_number const &a, large_number const &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;
}
/** /**
* Get number of digits in the number * operator overload to compare two numbers
**/ **/
const size_t num_digits() const { return _digits.size(); } friend bool operator!=(large_number const &a, large_number const &b) {
return !(a == b);
}
/** /**
* operator over load to access the * operator overload to increment (prefix)
* i^th digit conveniently and also **/
* assign value to it large_number &operator++() {
**/ (*this) += 1;
inline unsigned char &operator[](size_t n) { return this->_digits[n]; } return *this;
}
inline const unsigned char &operator[](size_t n) const { /**
return this->_digits[n]; * operator overload to increment (postfix)
} **/
large_number operator++(int) {
large_number tmp(_digits);
++(*this);
return tmp;
}
/** /**
* operator overload to compare two numbers * operator overload to add
**/ **/
friend std::ostream &operator<<(std::ostream &out, const large_number &a) { template <class T>
for (size_t i = a.num_digits(); i > 0; i--) large_number &operator+=(T n) {
out << static_cast<int>(a[i - 1]); // if adding with another large_number
return out; if (typeid(T) == typeid(large_number)) {
} large_number *b = static_cast<large_number *>(&n);
const size_t max_L = std::max(this->num_digits(), b->num_digits());
/** unsigned int carry = 0;
* operator overload to compare two numbers size_t i;
**/ for (i = 0; i < max_L || carry != 0; i++) {
friend bool operator==(large_number const &a, large_number const &b) { if (i < b->num_digits()) carry += (*b)[i];
size_t N = a.num_digits(); if (i < this->num_digits()) carry += (*this)[i];
if (N != b.num_digits()) if (i < this->num_digits())
return false; (*this)[i] = carry % 10;
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!=(large_number const &a, large_number const &b) {
return !(a == b);
}
/**
* operator overload to increment (prefix)
**/
large_number &operator++() {
(*this) += 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 (typeid(T) ==
typeid(large_number)) // if adding with another large_number
{
large_number *b = (large_number *)&n;
const size_t max_L = std::max(this->num_digits(), b->num_digits());
unsigned int carry = 0;
size_t i;
for (i = 0; i < max_L || carry != 0; i++) {
if (i < b->num_digits())
carry += (*b)[i];
if (i < this->num_digits())
carry += (*this)[i];
if (i < this->num_digits())
(*this)[i] = carry % 10;
else
this->add_digit(carry % 10);
carry /= 10;
}
} else if (std::is_integral<T>::value)
return (*this) += large_number(n);
else else
std::cerr << "Must be integer addition unsigned integer types." this->add_digit(carry % 10);
<< std::endl; carry /= 10;
return *this; }
} else if (std::is_integral<T>::value) {
return (*this) += large_number(n);
} else {
std::cerr << "Must be integer addition unsigned integer types."
<< std::endl;
}
return *this;
}
/**
* operator overload to perform addition
**/
template <class T>
friend large_number &operator+(const large_number &a, const T &b) {
a += b;
return a;
}
/**
* assignment operator
**/
void operator=(const large_number &b) { _digits = b._digits; }
/**
* 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;
uint64_t 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) {
* operator overload to perform addition this->add_digit(carry % 10);
**/ carry /= 10;
template <class T>
friend large_number &operator+(large_number &a, const T &b) {
a += b;
return a;
} }
}
/** std::vector<unsigned char> _digits; /**< where individual digits are stored */
* assignment operator
**/
void operator=(const large_number &b) { _digits = b._digits; }
/**
* 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;
}
};
std::vector<unsigned char>
_digits; /**< where individual digits are stored */
}; };
#endif // OTHERS_LARGE_NUMBER_H_ #endif // OTHERS_LARGE_NUMBER_H_