Algorithms_in_C++  1.0.0
Set of algorithms implemented in C++.
large_number Class Reference

#include <large_number.h>

Collaboration diagram for large_number:
[legend]

Public Member Functions

 large_number ()
 
 large_number (int n)
 
 large_number (const large_number &a)
 
 large_number (std::vector< unsigned char > &vec)
 
 large_number (char const *number_str)
 
void add_digit (unsigned int value)
 
size_t num_digits () const
 
unsigned char & operator[] (size_t n)
 
const unsigned char & operator[] (size_t n) const
 
large_numberoperator++ ()
 
large_numberoperator++ (int)
 
large_numberoperator+= (large_number n)
 
large_numberoperator+= (int n)
 
large_numberoperator= (const large_number &b)
 
template<class T >
large_numberoperator*= (const T n)
 
char digit_char (size_t i) const
 

Static Public Member Functions

static bool test ()
 

Private Member Functions

template<class T >
void multiply (const T n)
 

Private Attributes

std::vector< unsigned char > _digits
 

Friends

std::ostreamoperator<< (std::ostream &out, const large_number &a)
 
bool operator== (large_number const &a, large_number const &b)
 
bool operator!= (large_number const &a, large_number const &b)
 
template<class T >
large_numberoperator+ (const large_number &a, const T &b)
 

Detailed Description

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.

Constructor & Destructor Documentation

◆ large_number() [1/4]

large_number::large_number ( )
inline

< initializer with value = 1

27 { _digits.push_back(1); }
Here is the call graph for this function:

◆ large_number() [2/4]

large_number::large_number ( int  n)
inlineexplicit

< initializer from an integer initializer from another large_number

Here is the call graph for this function:

◆ large_number() [3/4]

large_number::large_number ( const large_number a)
inline

initializer from a vector

◆ large_number() [4/4]

large_number::large_number ( std::vector< unsigned char > &  vec)
inlineexplicit

initializer from a string

Member Function Documentation

◆ add_digit()

void large_number::add_digit ( unsigned int  value)
inline

add a digit at MSB to the large number

118  {
119  if (value > 9) {
120  std::cerr << "digit > 9!!\n";
121  exit(EXIT_FAILURE);
122  }
123 
124  _digits.push_back(value);
125  }
Here is the call graph for this function:

◆ digit_char()

char large_number::digit_char ( size_t  i) const
inline

returns i^th digit as an ASCII character

248  {
249  return _digits[num_digits() - i - 1] + '0';
250  }
Here is the call graph for this function:

◆ multiply()

template<class T >
void large_number::multiply ( const T  n)
inlineprivate

multiply large number with another integer and store the result in the same large number

258  {
259  static_assert(std::is_integral<T>::value,
260  "Can only have integer types.");
261  // assert(!(std::is_signed<T>::value)); //, "Implemented only for
262  // unsigned integer types.");
263 
264  size_t i;
265  uint64_t carry = 0, temp;
266  for (i = 0; i < this->num_digits(); i++) {
267  temp = static_cast<uint64_t>((*this)[i]) * n;
268  temp += carry;
269  if (temp < 10) {
270  carry = 0;
271  } else {
272  carry = temp / 10;
273  temp = temp % 10;
274  }
275  (*this)[i] = temp;
276  }
277 
278  while (carry != 0) {
279  this->add_digit(carry % 10);
280  carry /= 10;
281  }
282  }
Here is the call graph for this function:

◆ num_digits()

size_t large_number::num_digits ( ) const
inline

Get number of digits in the number

130 { return _digits.size(); }
Here is the call graph for this function:

◆ operator*=()

template<class T >
large_number& large_number::operator*= ( const T  n)
inline

operator overload to increment

238  {
239  static_assert(std::is_integral<T>::value,
240  "Must be integer addition unsigned integer types.");
241  this->multiply(n);
242  return *this;
243  }
Here is the call graph for this function:

◆ operator++() [1/2]

large_number& large_number::operator++ ( )
inline

operator overload to increment (prefix)

175  {
176  (*this) += 1;
177  return *this;
178  }

◆ operator++() [2/2]

large_number& large_number::operator++ ( int  )
inline

operator overload to increment (postfix)

183  {
184  static large_number tmp(_digits);
185  ++(*this);
186  return tmp;
187  }

◆ operator+=()

large_number& large_number::operator+= ( large_number  n)
inline

operator overload to add

192  {
193  // if adding with another large_number
194  large_number *b = reinterpret_cast<large_number *>(&n);
195  const size_t max_L = std::max(this->num_digits(), b->num_digits());
196  unsigned int carry = 0;
197  size_t i;
198  for (i = 0; i < max_L || carry != 0; i++) {
199  if (i < b->num_digits())
200  carry += (*b)[i];
201  if (i < this->num_digits())
202  carry += (*this)[i];
203  if (i < this->num_digits())
204  (*this)[i] = carry % 10;
205  else
206  this->add_digit(carry % 10);
207  carry /= 10;
208  }
209  return *this;
210  }
Here is the call graph for this function:

◆ operator=()

large_number& large_number::operator= ( const large_number b)
inline

assignment operator

229  {
230  this->_digits = b._digits;
231  return *this;
232  }

◆ operator[]()

unsigned char& large_number::operator[] ( size_t  n)
inline

operator over load to access the i^th digit conveniently and also assign value to it

137 { return this->_digits[n]; }

◆ test()

static bool large_number::test ( )
inlinestatic

Function to check implementation

65  {
66  std::cout << "------ Checking `large_number` class implementations\t"
67  << std::endl;
68  large_number a(40);
69  // 1. test multiplication
70  a *= 10;
71  if (a != large_number(400)) {
72  std::cerr << "\tFailed 1/6 (" << a << "!=400)" << std::endl;
73  return false;
74  }
75  std::cout << "\tPassed 1/6...";
76  // 2. test compound addition with integer
77  a += 120;
78  if (a != large_number(520)) {
79  std::cerr << "\tFailed 2/6 (" << a << "!=520)" << std::endl;
80  return false;
81  }
82  std::cout << "\tPassed 2/6...";
83  // 3. test compound multiplication again
84  a *= 10;
85  if (a != large_number(5200)) {
86  std::cerr << "\tFailed 3/6 (" << a << "!=5200)" << std::endl;
87  return false;
88  }
89  std::cout << "\tPassed 3/6...";
90  // 4. test increment (prefix)
91  ++a;
92  if (a != large_number(5201)) {
93  std::cerr << "\tFailed 4/6 (" << a << "!=5201)" << std::endl;
94  return false;
95  }
96  std::cout << "\tPassed 4/6...";
97  // 5. test increment (postfix)
98  a++;
99  if (a != large_number(5202)) {
100  std::cerr << "\tFailed 5/6 (" << a << "!=5202)" << std::endl;
101  return false;
102  }
103  std::cout << "\tPassed 5/6...";
104  // 6. test addition with another large number
105  a = a + large_number("7000000000000000000000000000000");
106  if (a != large_number("7000000000000000000000000005202")) {
107  std::cerr << "\tFailed 6/6 (" << a
108  << "!=7000000000000000000000000005202)" << std::endl;
109  return false;
110  }
111  std::cout << "\tPassed 6/6..." << std::endl;
112  return true;
113  }
Here is the call graph for this function:

Friends And Related Function Documentation

◆ operator!=

bool operator!= ( large_number const &  a,
large_number const &  b 
)
friend

operator overload to compare two numbers

168  {
169  return !(a == b);
170  }

◆ operator+

template<class T >
large_number& operator+ ( const large_number a,
const T &  b 
)
friend

operator overload to perform addition

220  {
221  static large_number c = a;
222  c += b;
223  return c;
224  }

◆ operator<<

std::ostream& operator<< ( std::ostream out,
const large_number a 
)
friend

operator overload to compare two numbers

146  {
147  for (size_t i = a.num_digits(); i > 0; i--)
148  out << static_cast<int>(a[i - 1]);
149  return out;
150  }

◆ operator==

bool operator== ( large_number const &  a,
large_number const &  b 
)
friend

operator overload to compare two numbers

155  {
156  size_t N = a.num_digits();
157  if (N != b.num_digits())
158  return false;
159  for (size_t i = 0; i < N; i++)
160  if (a[i] != b[i])
161  return false;
162  return true;
163  }

Member Data Documentation

◆ _digits

std::vector<unsigned char> large_number::_digits
private

where individual digits are stored


The documentation for this class was generated from the following file:
large_number::add_digit
void add_digit(unsigned int value)
Definition: large_number.h:118
std::vector::size
T size(T... args)
large_number
Definition: large_number.h:24
large_number::num_digits
size_t num_digits() const
Definition: large_number.h:130
std::vector::push_back
T push_back(T... args)
large_number::large_number
large_number()
Definition: large_number.h:27
std::cerr
large_number::multiply
void multiply(const T n)
Definition: large_number.h:258
large_number::_digits
std::vector< unsigned char > _digits
Definition: large_number.h:285
std::is_integral
std::endl
T endl(T... args)
std::max
T max(T... args)
std::exit
T exit(T... args)