#include <large_number.h>

Collaboration diagram for large_number:

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_number &	operator++ ()

large_number &	operator++ (int)

large_number &	operator+= (large_number n)

large_number &	operator+= (int n)

large_number &	operator= (const large_number &b)

template<class T >
large_number &	operator*= (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::ostream &	operator<< (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_number &	operator+ (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.

Definition at line 24 of file large_number.h.

Constructor & Destructor Documentation

◆ large_number() [1/5]

large_number::large_number ( )

inline

< initializer with value = 1

Definition at line 27 of file large_number.h.

27{ _digits.push_back(1); }

large_number::_digits

std::vector< unsigned char > _digits

Definition large_number.h:285

◆ large_number() [2/5]

large_number::large_number ( int n )

inlineexplicit

< initializer from an integer < initializer from an integer initializer from another large_number

Definition at line 39 of file large_number.h.

◆ large_number() [3/5]

large_number::large_number ( const large_number & a )

inline

initializer from a vector

Definition at line 48 of file large_number.h.

◆ large_number() [4/5]

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

inlineexplicit

initializer from a string

Definition at line 51 of file large_number.h.

◆ large_number() [5/5]

large_number::large_number ( char const * number_str )

inlineexplicit

Definition at line 54 of file large_number.h.

                                                  {
        for (size_t i = strlen(number_str); i > 0; i--) {
            char a = number_str[i - 1] - '0';
            if (a >= 0 && a <= 9)
                _digits.push_back(a);
        }
    }

Member Function Documentation

◆ add_digit()

void large_number::add_digit ( unsigned int value )

inline

add a digit at MSB to the large number

Definition at line 118 of file large_number.h.

                                       {
        if (value > 9) {
            std::cerr << "digit > 9!!\n";
            exit(EXIT_FAILURE);
        }
 
        _digits.push_back(value);
    }

◆ digit_char()

char large_number::digit_char ( size_t i ) const

inline

returns i^th digit as an ASCII character

Definition at line 248 of file large_number.h.

                                    {
        return _digits[num_digits() - i - 1] + '0';
    }

◆ 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

Definition at line 258 of file large_number.h.

                             {
        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 = static_cast<uint64_t>((*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;
        }
    }

◆ num_digits()

size_t large_number::num_digits ( ) const

inline

Get number of digits in the number

Definition at line 130 of file large_number.h.

130{ return _digits.size(); }

◆ operator*=()

template<class T >

large_number & large_number::operator*= ( const T n )

inline

operator overload to increment

Definition at line 238 of file large_number.h.

                                        {
        static_assert(std::is_integral<T>::value,
                      "Must be integer addition unsigned integer types.");
        this->multiply(n);
        return *this;
    }

◆ operator++() [1/2]

large_number & large_number::operator++ ( )

inline

operator overload to increment (prefix)

Definition at line 175 of file large_number.h.

                               {
        (*this) += 1;
        return *this;
    }

◆ operator++() [2/2]

large_number & large_number::operator++ ( int )

inline

operator overload to increment (postfix)

Definition at line 183 of file large_number.h.

                                  {
        static large_number tmp(_digits);
        ++(*this);
        return tmp;
    }

◆ operator+=() [1/2]

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

inline

Definition at line 212 of file large_number.h.

212{ return (*this) += large_number(n); }

large_number::large_number

large_number()

Definition large_number.h:27

◆ operator+=() [2/2]

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

inline

operator overload to add

Definition at line 192 of file large_number.h.

                                             {
        // if adding with another large_number
        large_number *b = reinterpret_cast<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;
        }
        return *this;
    }

◆ operator=()

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

inline

assignment operator

Definition at line 229 of file large_number.h.

                                                   {
        this->_digits = b._digits;
        return *this;
    }

◆ operator[]() [1/2]

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

Definition at line 137 of file large_number.h.

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

◆ operator[]() [2/2]

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

inline

Definition at line 139 of file large_number.h.

                                                           {
        return this->_digits[n];
    }

◆ test()

static bool large_number::test ( )

inlinestatic

Function to check implementation

Definition at line 65 of file large_number.h.

                       {
        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;
    }

Friends And Related Symbol Documentation

◆ operator!=

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

friend

operator overload to compare two numbers

Definition at line 168 of file large_number.h.

                                                                         {
        return !(a == b);
    }

◆ operator+

template<class T >

large_number & operator+	(	const large_number &	a,
		const T &	b )

friend

operator overload to perform addition

Definition at line 220 of file large_number.h.

                                                                      {
        static large_number c = a;
        c += b;
        return c;
    }

◆ operator<<

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

friend

operator overload to compare two numbers

Definition at line 146 of file large_number.h.

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

◆ operator==

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

friend

operator overload to compare two numbers

Definition at line 155 of file large_number.h.

                                                                         {
        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;
    }

Member Data Documentation

◆ _digits

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

private

where individual digits are stored

Definition at line 285 of file large_number.h.

The documentation for this class was generated from the following file:

math/large_number.h

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Friends

Detailed Description

Constructor & Destructor Documentation

◆ large_number() [1/5]

◆ large_number() [2/5]

◆ large_number() [3/5]

◆ large_number() [4/5]

◆ large_number() [5/5]

Member Function Documentation

◆ add_digit()

◆ digit_char()

◆ multiply()

◆ num_digits()

◆ operator*=()

◆ operator++() [1/2]

◆ operator++() [2/2]

◆ operator+=() [1/2]

◆ operator+=() [2/2]

◆ operator=()

◆ operator[]() [1/2]

◆ operator[]() [2/2]

◆ test()

Friends And Related Symbol Documentation

◆ operator!=

◆ operator+

◆ operator<<

◆ operator==

Member Data Documentation

◆ _digits