Updated functions to vector format

include/BigInt.hpp

@@ -9,10 +9,11 @@
 #define BIG_INT_HPP
 
 #include <iostream>
+#include <stdint.h>
 #include <vector>
 
 class BigInt {
-    std::vector<unsigned long long> magnitude;
+    std::vector<uint64_t> magnitude;
     bool is_negative;
 
     public:

include/constructors/constructors.hpp

@@ -16,21 +16,21 @@
     -------------------
 */
 
-BigInt::BigInt() {
-    magnitude = { 0 };
-    is_negative = false;
-}
+BigInt::BigInt()
+    : magnitude(1,0)
+    , is_negative(false)
+    { }
 
 
 /*
     Copy constructor
     ----------------
 */
 
-BigInt::BigInt(const BigInt& num) {
-    magnitude = num.magnitude;
-    is_negative = num.is_negative;
-}
+BigInt::BigInt(const BigInt& num) 
+    : magnitude(num.magnitude)
+    , is_negative(num.is_negative)
+    { }
 
 
 /*
@@ -39,7 +39,15 @@ BigInt::BigInt(const BigInt& num) {
 */
 
 BigInt::BigInt(const long long& num) {
-    magnitude = { (unsigned long long) llabs(num) };
+    if (sizeof(long long) == (sizeof(uint64_t)))
+        magnitude = { (uint64_t) llabs(num) };
+
+    // If size not equal, long long will be bigger
+    else {
+        magnitude.push_back((uint64_t)llabs((uint64_t)num));
+        if (num / UINT64_MAX > 0)
+            magnitude.push_back((uint64_t)llabs(num / UINT64_MAX));
+    }
     is_negative = num < 0;
 }
 

include/functions/conversion.hpp

@@ -15,8 +15,16 @@
 */
 
 std::string BigInt::to_string() const {
-    // prefix with sign if negative
-    return this->sign == '-' ? "-" + this->value : this->value;
+
+    std::string num_string;
+
+    for (uint64_t ull : this->magnitude)
+        while (ull > 0) {
+            num_string += ((ull % 10) + '0'); 
+            ull /= 10;
+        }
+
+    return this->is_negative ? "-" + num_string : num_string;
 }
 
 

include/functions/random.hpp

@@ -30,14 +30,13 @@ BigInt big_random(size_t num_digits = 0) {
         // use a random number for it:
         num_digits = 1 + rand_generator() % MAX_RANDOM_LENGTH;
 
-    BigInt big_rand;
-    big_rand.value = "";    // clear value to append digits
-    while (big_rand.value.size() < num_digits)
-        big_rand.value += std::to_string(rand_generator());
-    if (big_rand.value.size() != num_digits)
-        big_rand.value.erase(num_digits);   // erase extra digits
-
-    return big_rand;
+    std::string random_value = "";
+    while (random_value.size() < num_digits)
+        random_value += std::to_string(rand_generator());
+    if (random_value.size() != num_digits)
+        random_value.erase(num_digits);   // erase extra digits
+
+    return BigInt(random_value);
 }
 
 

include/functions/utility.hpp

@@ -8,6 +8,8 @@
 #define BIG_INT_UTILITY_FUNCTIONS_HPP
 
 #include <tuple>
+#include <stdint.h>
+#include <limits>
 
 
 /*
@@ -93,7 +95,6 @@ std::tuple<std::string, std::string> get_larger_and_smaller(const std::string& n
     return std::make_tuple(larger, smaller);
 }
 
-
 /*
     is_power_of_10
     ----------------------
@@ -110,4 +111,78 @@ bool is_power_of_10(const std::string& num){
     return true;    // first digit is 1 and the following digits are all 0
 }
 
+
+/*--------------------- Vector functions ---------------------*/
+
+/*
+    add_leading_zeroes
+    ------------------
+    Adds a given number of leading zeroes to a string-represented integer `num`.
+*/
+
+void add_leading_zeroes(std::vector<uint64_t>& num, size_t num_zeroes) {
+    std::vector<uint64_t> tmp(num_zeroes, 0);
+    tmp.insert(tmp.end(), num.begin(), num.end());
+    num = tmp;
+}
+
+
+/*
+    add_trailing_zeroes
+    -------------------
+    Adds a given number of trailing zeroes to a string-represented integer `num`.
+*/
+
+void add_trailing_zeroes(std::vector<uint64_t>& num, size_t num_zeroes) {
+    std::vector<uint64_t> tmp(num_zeroes, 0);
+    num.insert(num.end(), tmp.begin(), tmp.end());
+}
+
+/*
+    strip_leading_zeroes
+    --------------------
+    Strip the leading zeroes from a number represented as a vector.
+*/
+
+void strip_trailing_zeroes(std::vector<uint64_t>& num) {
+    for (auto digit_itter = num.rbegin(); digit_itter != num.rend(); digit_itter++)
+        if (*digit_itter != 0) {
+            num = std::vector<uint64_t>(num.rend(), digit_itter + 1);
+            return;
+        }
+
+    // If all 0's
+    num.clear();
+    num.push_back(0);
+}
+
+/*
+    get_larger_and_smaller
+    ----------------------
+    Identifies the given vector-represented integers as `larger` and `smaller`,
+    padding the smaller number with leading zeroes to make it equal in length to
+    the larger number.
+    Note: for simplicity and efficiency, this function only compares length and not value.
+*/
+
+std::tuple<std::vector<uint64_t>, std::vector<uint64_t>> get_larger_and_smaller(const std::vector<uint64_t>& num1,
+        const std::vector<uint64_t>& num2) {
+    std::vector<uint64_t> larger, smaller;
+    if (num1.size() > num2.size()) {
+        larger = num1;
+        smaller = num2;
+    }
+    else {
+        larger = num2;
+        smaller = num1;
+    }
+
+    // pad the smaller number with zeroes
+    add_trailing_zeroes(smaller, larger.size() - smaller.size());
+
+    return std::make_tuple(larger, smaller);
+}
+
+
+
 #endif  // BIG_INT_UTILITY_FUNCTIONS_HPP

include/operators/assignment.hpp

@@ -17,8 +17,8 @@
 */
 
 BigInt& BigInt::operator=(const BigInt& num) {
-    value = num.value;
-    sign = num.sign;
+    magnitude = num.magnitude;
+    is_negative = num.is_negative;
 
     return *this;
 }
@@ -31,8 +31,8 @@ BigInt& BigInt::operator=(const BigInt& num) {
 
 BigInt& BigInt::operator=(const long long& num) {
     BigInt temp(num);
-    value = temp.value;
-    sign = temp.sign;
+    magnitude = temp.magnitude;
+    is_negative = temp.is_negative;
 
     return *this;
 }
@@ -45,8 +45,8 @@ BigInt& BigInt::operator=(const long long& num) {
 
 BigInt& BigInt::operator=(const std::string& num) {
     BigInt temp(num);
-    value = temp.value;
-    sign = temp.sign;
+    magnitude = temp.magnitude;
+    is_negative = temp.is_negative;
 
     return *this;
 }