menggabungkan implementasi big_int dalam header itu sendiri

ternyata lebih mudah disatukan, bacanya enak di sisi editor(vim)

Author: Mrezadwiprasetiawan

number_system/CMakeLists.txt

@@ -16,10 +16,6 @@ add_test(NAME "Test suffix prime class and print as Test, is prime" COMMAND prim
 add_test(NAME "Test find and print 100 fibonacci " COMMAND fibonacci -l 100)
 add_test(NAME "Test find and print 100th fibonnaci" COMMAND fibonacci -i 100)
 
-#library
-add_library(big_int SHARED ${SRC_SOURCES}/big_int.cxx)
-#add_library(big_int STATIC ${SRC_SOURCES}/big_int.cxx)
-
 # Untuk Testing
-add_executable(big_int_test ${SRC_SOURCES}/big_int.cxx test/big_int.cxx)
+add_executable(big_int_test ${SRC_SOURCES}/big_int.cxx)
 #add_test(NAME "Test big_int" COMMAND big_int_test)

number_system/include/big_int.hxx

@@ -1,37 +1,107 @@
 #pragma once
+#include <cassert>
 #include <cstdint>
 #include <iostream>
 #include <string>
 #include <vector>
 
-std::string uint64_t_to_string(uint64_t val);
-uint64_t string_to_uint64_t(const std::string &val);
-void mul_2_64_add_other(std::string &val, uint64_t other);
-void div_mod_2_64(const std::string &val, std::string *rem);
-
-#define __BIGINT_OPERATOR_DECL(op, alter)    \
-  big_int alter(const big_int &other) const; \
-  big_int operator op(const big_int &other) const { return alter(other); }
-#define __BIGINT_OPERATOR_LOGIC_DECL(op, alter) \
-  bool alter(const big_int &other) const;       \
-  bool operator op(const big_int &other) const { return alter(other); }
-
-#define __BIGINT_OPERATOR_SHIFT_DECL(type)                           \
-  big_int shift_left(type other) const;                              \
-  big_int operator<<(type other) const { return shift_left(other); } \
-  big_int shift_right(type other) const;                             \
-  big_int operator>>(type other) const { return shift_right(other); }
-
 // most 64bit on the highest index
 class big_int {
  private:
   std::vector<uint64_t> values;
-  std::string values_str;
+  // mutable = non logic state
+  mutable std::string values_str;
   bool negative = false;
   const static uint16_t max_thread;
 
   // For positive only
   big_int(std::vector<uint64_t> values) : values(values) {}
+  std::string uint64_to_string(uint64_t val) {
+    std::string res;
+    if (!val) return "0";
+    while (val) {
+      res.insert(res.begin(), val % 10 + '0');
+      val /= 10;
+    }
+    return res;
+  }
+
+  uint64_t string_to_uint64_t(const std::string &val) {
+    uint64_t res = 0;
+    for (auto c : val) res = res * 10 + c - '0';
+    return res;
+  }
+
+  void mul_2_64_add_other(std::string &val, uint64_t other) {
+    using namespace std;
+    if (val.empty() || val == "0") {
+      val = uint64_to_string(other);
+      return;
+    }
+    std::string res;
+    // multiply
+    std::vector<int> tmpres(val.size() + big_int::two_pow_64.size(), 0);
+    for (size_t i = 0; i < val.size(); ++i) {
+      size_t rev_i = val.size() - 1 - i;
+      for (size_t j = 0; j < big_int::two_pow_64.size(); ++j) {
+        size_t rev_j = big_int::two_pow_64.size() - 1 - j;
+        int mul = (val[rev_i] - '0') * (big_int::two_pow_64[rev_j] - '0');
+        size_t p1 = rev_i + rev_j, p2 = p1 + 1;
+        int sum = tmpres[p2] + mul;
+        tmpres[p2] = sum % 10;
+        tmpres[p1] += sum / 10;
+      }
+    }
+
+    if (!other) return;
+
+    // add the other
+    std::string b = uint64_to_string(other);
+    int carry = 0;
+
+    for (size_t i = 0; i < b.size(); ++i) {
+      size_t rev_i = tmpres.size() - 1 - i;
+      size_t rev_i_b = b.size() - 1 - i;
+      int sum = b[rev_i_b] - '0' + tmpres[rev_i];
+      sum += carry;
+      carry = sum / 10;
+      tmpres[rev_i] = sum % 10;
+    }
+
+    for (int i = 0; carry && i < tmpres.size(); ++i) {
+      int sum = tmpres[tmpres.size() - i - 1] + carry;
+      tmpres[tmpres.size() - i - 1] = sum % 10;
+      carry = sum / 10;
+    }
+
+    if (carry) tmpres.insert(tmpres.begin(), 1, carry);
+
+    while (!tmpres[0]) tmpres.erase(tmpres.begin());
+    res.resize(tmpres.size());
+    for (size_t i = 0; i < tmpres.size(); ++i) res[i] = tmpres[i] + '0';
+
+    val = res;
+  }
+
+  // TODO : Implement this method
+  void div_mod_2_64(std::string &val, std::string *remainder) const {
+    if (val.size() < big_int::two_pow_64.size()) {
+      if (remainder) *remainder = val;
+      val = "";
+      return;
+    }
+    std::vector<int> sub_res(val.size(), 0);
+    size_t offset = val.size() - big_int::two_pow_64.size();
+    uint64_t div_res = 0;
+    bool greater_equal = true;
+    bool carry = 0;
+    while (greater_equal) {
+      for (size_t i = 0; i < val.size(); ++i) {
+        size_t rev_val_i = val.size() - 1 - i;
+        size_t rev_2_64_i = rev_val_i - offset;
+      }
+    }
+  }
 
  public:
   // done
@@ -40,51 +110,180 @@ class big_int {
       : values(values), negative(negative) {}
 
   big_int(uint64_t value) {
-    if (value < (1ULL << 63))
-      values = {value};
+    if (value < (1ULL << 63)) values = {value};
     else {
       values = {~value + 1};
       this->negative = true;
     }
   }
 
-  big_int(const std::string &value);
+  big_int(std::string value) {
+    std::string rem = "0";
+    std::vector<uint64_t> chunks;
+    while (!value.empty()) {
+      div_mod_2_64(value, &rem);
+      chunks.push_back(string_to_uint64_t(rem));
+    }
+  }
+
+  std::string to_string() const {}
+
+#define FUNC_OP(op) big_int op(const big_int &other) const
 
-  // c/cpp aneh banget, perlu const di belakang untuk menandakan fungsi tidak
-  // merubah big_int
-  std::string to_string() const;
+  FUNC_OP(add) {
+    std::vector<uint64_t> this_copy = this->values, other_copy = other.values,
+                          result;
 
-  static const big_int ONE;
+    // for flag and result
+    bool negative = false;
 
-  __BIGINT_OPERATOR_DECL(+, add);
-  __BIGINT_OPERATOR_DECL(-, min);
-  __BIGINT_OPERATOR_DECL(*, mul);
-  __BIGINT_OPERATOR_DECL(/, div);
+    // padding
+    if (this->values.size() != other.values.size()) {
+      size_t pad = this->values.size() > other.values.size()
+                       ? this->values.size() - other.values.size()
+                       : other.values.size() - this->values.size();
+      this->values.size() > other.values.size()
+          ? other_copy.insert(other_copy.begin(), pad, 0)
+          : this_copy.insert(this_copy.begin(), pad, 0);
+    }
 
+    // inverse bit and add 1 for negative
+    if (this->negative != other.negative) {
+      negative = true;
+      bool carry = 1;
+      if (this->negative) {
+        for (size_t i = 0; i < this_copy.size(); ++i) {
+          this_copy[i] = ~this_copy[i] + carry;
+          carry = this_copy[i] == 0;
+        }
+      } else {
+        for (size_t i = 0; i < this_copy.size(); ++i) {
+          other_copy[i] = ~other_copy[i] + carry;
+          carry = other_copy[i] == 0;
+        }
+      }
+    }
+
+    bool carry = false;
+    for (size_t i = 0; i < this_copy.size(); ++i) {
+      result.push_back(this_copy[i] + other_copy[i] + carry);
+      carry =
+          (result[i] < this_copy[i] || (carry && result[i] == this_copy[i]));
+    }
+
+    // if carry (outside to make sure if false skip) but both not equal
+    // negative=false, if not add the carry
+    if (carry) {
+      if (negative) negative = false;
+      else {
+        result.push_back(1);
+        if (this->negative) negative = true;
+      }
+    }
+
+    return big_int(result, negative);
+  }
+
+  FUNC_OP(min) {
+    big_int big_new(other.values, !other.negative);
+    return this->add(big_new);
+  }
+  FUNC_OP(mul) {
+    size_t res_bit = (this->values.size() << 6) + (other.values.size() << 6);
+    if (res_bit < this->values.size())
+      throw std::runtime_error("overflow reached");
+
+    big_int res(0);
+
+    if (this->negative ^ other.negative) res.negative = true;
+
+    for (size_t i = 0; i < other.values.size(); ++i) {
+      uint64_t factor = other.values[i];
+      for (uint8_t j = 1; j < uint8_t(1 << 6); ++j) {
+        if (factor & (1ULL << j)) res = res + (*this << j);
+        factor = factor >> 1;
+      }
+    }
+    return res;
+  }
+
+  FUNC_OP(div) {}
+#undef FUNC_OP
+
+#define OPERATOR_DECL(op, alter) \
+  big_int operator op(const big_int &other) const { return alter(other); }
+  OPERATOR_DECL(+, add);
+  OPERATOR_DECL(-, min);
+  OPERATOR_DECL(*, mul);
+  OPERATOR_DECL(/, div);
+#undef OPERATOR_DECL
   // special case
-  big_int operator++(int) { return add(ONE); }
-  big_int operator--(int) { return min(ONE); }
-  bool operator!() { return values_str.empty() || values_str == "0"; }
-
-  __BIGINT_OPERATOR_DECL(&, _and)
-  __BIGINT_OPERATOR_DECL(|, _or)
-  __BIGINT_OPERATOR_DECL(^, _xor)
-
-  __BIGINT_OPERATOR_LOGIC_DECL(>, gt);
-  __BIGINT_OPERATOR_LOGIC_DECL(>=, gteq);
-  __BIGINT_OPERATOR_LOGIC_DECL(<, lt);
-  __BIGINT_OPERATOR_LOGIC_DECL(<=, lteq);
-  __BIGINT_OPERATOR_LOGIC_DECL(==, equal);
-  __BIGINT_OPERATOR_LOGIC_DECL(!=, noteq);
-  __BIGINT_OPERATOR_LOGIC_DECL(&&, andand);
-  __BIGINT_OPERATOR_LOGIC_DECL(||, oror);
-
-  // uint64_t udah cukup, terlanjur bikin makronya males ngapus
-  __BIGINT_OPERATOR_SHIFT_DECL(size_t);
-#undef __BIGINT_OPERATOR_DECL
-#undef __BIGINT_OPERATOR_LOGIC_DECL
-#undef __BIGINT_OPERATOR_SHIFT_DECL
-};
+  big_int operator++(int) { return add(big_int(1)); }
+  big_int operator--(int) { return min(big_int(1)); }
+  bool operator!() {
+    return (values.size() == 1 && values[0] == 0) || values.empty();
+  }
+
+#define BITWISE(op) big_int operator op(const big_int &other) const
+
+  BITWISE(&) {}
+#undef BITWISE
+
+#define OPERATOR_LOGIC_DECL(op, alter)    \
+  bool alter(const big_int &other) const; \
+  bool operator op(const big_int &other) const { return alter(other); }
+
+  OPERATOR_LOGIC_DECL(>, gt);
+  OPERATOR_LOGIC_DECL(>=, gteq);
+  OPERATOR_LOGIC_DECL(<, lt);
+  OPERATOR_LOGIC_DECL(<=, lteq);
+  OPERATOR_LOGIC_DECL(==, equal);
+  OPERATOR_LOGIC_DECL(!=, noteq);
+  OPERATOR_LOGIC_DECL(&&, andand);
+  OPERATOR_LOGIC_DECL(||, oror);
+
+  big_int shift_left(uint64_t k) const {
+    std::vector<uint64_t> res_values(this->values);
+    if (!k) return big_int(res_values, this->negative);
+    assert((k >> 6) + res_values.size() > res_values.size());
+    if (k >> 6) res_values.insert(res_values.end(), k >> 6, 0);
+    uint64_t carry = 0;
+    uint64_t bits = (k & 63ULL);
+    // mencegah shifting 64 kali jika k kelipatan 64 karena 64-0 dilewatkan
+    if (bits) {
+      for (auto it = res_values.rbegin(); it != res_values.rend(); ++it) {
+        uint64_t tmp = *it << bits | carry;
+        carry = *it >> (64ULL - bits);
+        *it = tmp;
+      }
+    }
+    return big_int(res_values, this->negative);
+  }
+
+  big_int operator<<(uint64_t k) const { return shift_left(k); }
+
+  big_int shift_right(uint64_t k) const {
+    std::vector<uint64_t> res_values(this->values);
+    if (!k) return big_int(res_values, this->negative);
+    if (k >> 6 >= res_values.size()) return big_int({0}, this->negative);
+    if (k >> 6) res_values.resize(res_values.size() - (k >> 6));
+    uint64_t carry = 0;
+    uint64_t bits = (k & 63ULL);
+    if (bits) {
+      for (auto it = res_values.begin(); it != res_values.end(); ++it) {
+        uint64_t tmp = *it >> bits | carry;
+        carry = *it << (64ULL - bits);
+        *it = tmp;
+      }
+    }
+    while (res_values.size() > 1 && !res_values.back()) res_values.pop_back();
+    return big_int(res_values, this->negative);
+  }
+
+  big_int operator>>(uint64_t k) const { return shift_right(k); }
+};  // END big_int class
+// static member init
+const std::string two_pow_64 = "18446744073709551616";
 
 inline big_int operator""_big(unsigned long long i) { return big_int(i); }
 inline big_int operator""_big(const char *str, size_t size) {