code cleanup

others/large_number.h

@@ -5,6 +5,7 @@
 
 #ifndef OTHERS_LARGE_NUMBER_H_
 #define OTHERS_LARGE_NUMBER_H_
+#include <algorithm>
 #include <cassert>
 #include <cinttypes>
 #include <cstring>
@@ -19,11 +20,12 @@
  * large number with long unsigned integers.
  **/
 class large_number {
-public:
-    large_number() /**< initializer with value = 1 */ { _digits.push_back(1); }
+ public:
+  /**< 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;
     do {
       add_digit(carry % 10);
@@ -31,24 +33,19 @@ public:
     } while (carry != 0);
   }
 
-    large_number(
-        const large_number &a) /**< initializer from another large_number */
-    {
-        _digits = a._digits;
-    }
+  /**< initializer from another large_number */
+  explicit large_number(const large_number &a) { _digits = a._digits; }
 
-    large_number(
-        const std::vector<unsigned char> &vec) /**< initializer from a vector */
-    {
+  /**< initializer from a vector */
+  explicit large_number(const std::vector<unsigned char> &vec) {
     _digits = vec;
   }
 
-    large_number(const char *number_str) /**< initializer from a string */
-    {
+  /**< 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);
+      if (a >= 0 && a <= 9) _digits.push_back(a);
     }
   }
 
@@ -97,8 +94,8 @@ public:
     // 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;
+      std::cerr << "\tFailed 6/6 (" << a << "!=7000000000000000000000000005202)"
+                << std::endl;
       return false;
     }
     std::cout << "\tPassed 6/6..." << std::endl;
@@ -147,11 +144,9 @@ public:
    **/
   friend bool operator==(large_number const &a, large_number const &b) {
     size_t N = a.num_digits();
-        if (N != b.num_digits())
-            return false;
+    if (N != b.num_digits()) return false;
     for (size_t i = 0; i < N; i++)
-            if (a[i] != b[i])
-                return false;
+      if (a[i] != b[i]) return false;
     return true;
   }
 
@@ -184,29 +179,27 @@ public:
    **/
   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;
+    // if adding with another large_number
+    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;
       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 < 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)
+    } else if (std::is_integral<T>::value) {
       return (*this) += large_number(n);
-        else
+    } else {
       std::cerr << "Must be integer addition unsigned integer types."
                 << std::endl;
+    }
     return *this;
   }
 
@@ -214,7 +207,7 @@ public:
    * operator overload to perform addition
    **/
   template <class T>
-    friend large_number &operator+(large_number &a, const T &b) {
+  friend large_number &operator+(const large_number &a, const T &b) {
     a += b;
     return a;
   }
@@ -242,26 +235,25 @@ public:
     return _digits[num_digits() - i - 1] + '0';
   }
 
-private:
+ 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.");
+    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;
+    uint64_t carry = 0, temp;
     for (i = 0; i < this->num_digits(); i++) {
       temp = (*this)[i] * n;
       temp += carry;
-            if (temp < 10)
+      if (temp < 10) {
         carry = 0;
-            else {
+      } else {
         carry = temp / 10;
         temp = temp % 10;
       }
@@ -272,10 +264,9 @@ private:
       this->add_digit(carry % 10);
       carry /= 10;
     }
-    };
+  }
 
-    std::vector<unsigned char>
-        _digits; /**< where individual digits are stored */
+  std::vector<unsigned char> _digits; /**< where individual digits are stored */
 };
 
 #endif  // OTHERS_LARGE_NUMBER_H_