refactor(Base): Using for methods name in Base.

Author: lordpaijo

include/imeth/base/base.hpp

@@ -5,34 +5,34 @@ namespace imeth {
 class Base {
 public:
     // Convert FROM decimal TO any base (2-36)
-    static std::string decimalToBinary(int decimal);
-    static std::string decimalToTrinary(int decimal);
-    static std::string decimalToOctal(int decimal);
-    static std::string decimalToHexadecimal(int decimal);
-    static std::string decimalToBase(int decimal, int base);
+    static std::string decimal_to_binary(int decimal);
+    static std::string decimal_to_trinary(int decimal);
+    static std::string decimal_to_octal(int decimal);
+    static std::string decimal_to_hexadecimal(int decimal);
+    static std::string decimal_to_base(int decimal, int base);
 
     // Convert FROM any base TO decimal
-    static int binaryToDecimal(const std::string& binary);
-    static int trinaryToDecimal(const std::string& trinary);
-    static int octalToDecimal(const std::string& octal);
-    static int hexadecimalToDecimal(const std::string& hex);
-    static int baseToDecimal(const std::string& number, int base);
+    static int binary_to_decimal(const std::string& binary);
+    static int trinary_to_decimal(const std::string& trinary);
+    static int octal_to_decimal(const std::string& octal);
+    static int hexadecimal_to_decimal(const std::string& hex);
+    static int base_to_decimal(const std::string& number, int base);
 
     // Direct conversion between bases (goes through decimal)
     static std::string convert(const std::string& number, int fromBase, int toBase);
 
     // Arithmetic operations in different bases
-    static std::string addInBase(const std::string& num1, const std::string& num2, int base);
-    static std::string subtractInBase(const std::string& num1, const std::string& num2, int base);
-    static std::string multiplyInBase(const std::string& num1, const std::string& num2, int base);
+    static std::string add_in_base(const std::string& num1, const std::string& num2, int base);
+    static std::string subtract_in_base(const std::string& num1, const std::string& num2, int base);
+    static std::string multiply_in_base(const std::string& num1, const std::string& num2, int base);
 
     // Utility functions
-    static bool isValidInBase(const std::string& number, int base);
-    static std::string toUpperCase(const std::string& str);
+    static bool is_valid_in_base(const std::string& number, int base);
+    static std::string to_upper_case(const std::string& str);
 
 private:
     static const std::string DIGITS;
-    static char digitToChar(int digit);
-    static int charToDigit(char c);
+    static char digit_to_char(int digit);
+    static int char_to_digit(char c);
 };
 } // namespace imeth

include/imeth/base/binary.hpp

@@ -4,26 +4,26 @@
 namespace imeth {
 namespace Binary {
     // Conversion
-     std::string fromDecimal(int decimal);
-     int toDecimal(const std::string& binary);
+     std::string from_decimal(int decimal);
+     int to_decimal(const std::string& binary);
 
     // Arithmetic operations
      std::string add(const std::string& a, const std::string& b);
      std::string subtract(const std::string& a, const std::string& b);
      std::string multiply(const std::string& a, const std::string& b);
 
     // Bitwise operations
-     std::string bitwiseAND(const std::string& a, const std::string& b);
-     std::string bitwiseOR(const std::string& a, const std::string& b);
-     std::string bitwiseXOR(const std::string& a, const std::string& b);
-     std::string bitwiseNOT(const std::string& binary);
-     std::string leftShift(const std::string& binary, int positions);
-     std::string rightShift(const std::string& binary, int positions);
+     std::string bitwise_AND(const std::string& a, const std::string& b);
+     std::string bitwise_OR(const std::string& a, const std::string& b);
+     std::string bitwise_XOR(const std::string& a, const std::string& b);
+     std::string bitwise_NOT(const std::string& binary);
+     std::string left_shift(const std::string& binary, int positions);
+     std::string right_shift(const std::string& binary, int positions);
 
     // Utility
-     bool isValid(const std::string& binary);
-     std::string padLeft(const std::string& binary, size_t length);
-     int countOnes(const std::string& binary);
-     int countZeros(const std::string& binary);
+     bool is_valid(const std::string& binary);
+     std::string pad_left(const std::string& binary, size_t length);
+     int count_ones(const std::string& binary);
+     int count_zeros(const std::string& binary);
 }; // namespace binary
 } // namespace imeth

include/imeth/base/hexadecimal.hpp

@@ -5,22 +5,22 @@ namespace imeth {
 class Hexadecimal {
 public:
     // Conversion
-    static std::string fromDecimal(int decimal);
-    static int toDecimal(const std::string& hex);
+    static std::string from_decimal(int decimal);
+    static int to_decimal(const std::string& hex);
 
     // Arithmetic operations
     static std::string add(const std::string& a, const std::string& b);
     static std::string subtract(const std::string& a, const std::string& b);
     static std::string multiply(const std::string& a, const std::string& b);
 
     // Utility
-    static bool isValid(const std::string& hex);
-    static std::string toUpperCase(const std::string& hex);
-    static std::string toLowerCase(const std::string& hex);
-    static std::string padLeft(const std::string& hex, size_t length);
+    static bool is_valid(const std::string& hex);
+    static std::string to_upper_case(const std::string& hex);
+    static std::string to_lower_case(const std::string& hex);
+    static std::string pad_left(const std::string& hex, size_t length);
 
 private:
-    static int charToDigit(char c);
-    static char digitToChar(int digit);
+    static int char_to_digit(char c);
+    static char digit_to_char(int digit);
 };
 } // namespace imeth

include/imeth/base/octal.hpp

@@ -4,16 +4,16 @@
 namespace imeth {
 namespace Octal {
     // Conversion
-    static std::string fromDecimal(int decimal);
-    static int toDecimal(const std::string& octal);
+    static std::string from_decimal(int decimal);
+    static int to_decimal(const std::string& octal);
 
     // Arithmetic operations
     static std::string add(const std::string& a, const std::string& b);
     static std::string subtract(const std::string& a, const std::string& b);
     static std::string multiply(const std::string& a, const std::string& b);
 
     // Utility
-    static bool isValid(const std::string& octal);
-    static std::string padLeft(const std::string& octal, size_t length);
+    static bool is_valid(const std::string& octal);
+    static std::string pad_left(const std::string& octal, size_t length);
 }; // namespace octal
 } // namespace imeth

src/base/base.cpp

@@ -8,14 +8,14 @@ namespace imeth {
 
 const std::string Base::DIGITS = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
 
-char Base::digitToChar(int digit) {
+char Base::digit_to_char(int digit) {
     if (digit < 0 || digit >= 36) {
         throw std::invalid_argument("Digit out of range");
     }
     return DIGITS[digit];
 }
 
-int Base::charToDigit(char c) {
+int Base::char_to_digit(char c) {
     c = std::toupper(c);
     if (c >= '0' && c <= '9') {
         return c - '0';
@@ -27,7 +27,7 @@ int Base::charToDigit(char c) {
 }
 
 // Convert decimal to any base
-std::string Base::decimalToBase(int decimal, const int base) {
+std::string Base::decimal_to_base(int decimal, const int base) {
     if (base < 2 || base > 36) {
         throw std::invalid_argument("Base must be between 2 and 36");
     }
@@ -40,32 +40,32 @@ std::string Base::decimalToBase(int decimal, const int base) {
     std::string result = "";
     while (decimal > 0) {
         int remainder = decimal % base;
-        result = digitToChar(remainder) + result;
+        result = digit_to_char(remainder) + result;
         decimal /= base;
     }
 
     if (negative) result = "-" + result;
     return result;
 }
 
-std::string Base::decimalToBinary(const int decimal) {
-    return decimalToBase(decimal, 2);
+std::string Base::decimal_to_binary(const int decimal) {
+    return decimal_to_base(decimal, 2);
 }
 
-std::string Base::decimalToTrinary(const int decimal) {
-    return decimalToBase(decimal, 3);
+std::string Base::decimal_to_trinary(const int decimal) {
+    return decimal_to_base(decimal, 3);
 }
 
-std::string Base::decimalToOctal(const int decimal) {
-    return decimalToBase(decimal, 8);
+std::string Base::decimal_to_octal(const int decimal) {
+    return decimal_to_base(decimal, 8);
 }
 
-std::string Base::decimalToHexadecimal(const int decimal) {
-    return decimalToBase(decimal, 16);
+std::string Base::decimal_to_hexadecimal(const int decimal) {
+    return decimal_to_base(decimal, 16);
 }
 
 // Convert from any base to decimal
-int Base::baseToDecimal(const std::string& number, int base) {
+int Base::base_to_decimal(const std::string& number, int base) {
     if (base < 2 || base > 36) {
         throw std::invalid_argument("Base must be between 2 and 36");
     }
@@ -82,7 +82,7 @@ int Base::baseToDecimal(const std::string& number, int base) {
 
     // Process from right to left
     for (int i = number.length() - 1; i >= static_cast<int>(start); --i) {
-        int digit = charToDigit(number[i]);
+        int digit = char_to_digit(number[i]);
         if (digit >= base) {
             throw std::invalid_argument("Invalid digit for base");
         }
@@ -93,49 +93,49 @@ int Base::baseToDecimal(const std::string& number, int base) {
     return negative ? -result : result;
 }
 
-int Base::binaryToDecimal(const std::string& binary) {
-    return baseToDecimal(binary, 2);
+int Base::binary_to_decimal(const std::string& binary) {
+    return base_to_decimal(binary, 2);
 }
 
-int Base::trinaryToDecimal(const std::string& trinary) {
-    return baseToDecimal(trinary, 3);
+int Base::trinary_to_decimal(const std::string& trinary) {
+    return base_to_decimal(trinary, 3);
 }
 
-int Base::octalToDecimal(const std::string& octal) {
-    return baseToDecimal(octal, 8);
+int Base::octal_to_decimal(const std::string& octal) {
+    return base_to_decimal(octal, 8);
 }
 
-int Base::hexadecimalToDecimal(const std::string& hex) {
-    return baseToDecimal(hex, 16);
+int Base::hexadecimal_to_decimal(const std::string& hex) {
+    return base_to_decimal(hex, 16);
 }
 
 // Direct conversion between bases
 std::string Base::convert(const std::string& number, const int fromBase, const int toBase) {
-    const int decimal = baseToDecimal(number, fromBase);
-    return decimalToBase(decimal, toBase);
+    const int decimal = base_to_decimal(number, fromBase);
+    return decimal_to_base(decimal, toBase);
 }
 
 // Arithmetic operations in different bases
-std::string Base::addInBase(const std::string& num1, const std::string& num2, const int base) {
-    const int dec1 = baseToDecimal(num1, base);
-    const int dec2 = baseToDecimal(num2, base);
-    return decimalToBase(dec1 + dec2, base);
+std::string Base::add_in_base(const std::string& num1, const std::string& num2, const int base) {
+    const int dec1 = base_to_decimal(num1, base);
+    const int dec2 = base_to_decimal(num2, base);
+    return decimal_to_base(dec1 + dec2, base);
 }
 
-std::string Base::subtractInBase(const std::string& num1, const std::string& num2, const int base) {
-    const int dec1 = baseToDecimal(num1, base);
-    const int dec2 = baseToDecimal(num2, base);
-    return decimalToBase(dec1 - dec2, base);
+std::string Base::subtract_in_base(const std::string& num1, const std::string& num2, const int base) {
+    const int dec1 = base_to_decimal(num1, base);
+    const int dec2 = base_to_decimal(num2, base);
+    return decimal_to_base(dec1 - dec2, base);
 }
 
-std::string Base::multiplyInBase(const std::string& num1, const std::string& num2, const int base) {
-    const int dec1 = baseToDecimal(num1, base);
-    const int dec2 = baseToDecimal(num2, base);
-    return decimalToBase(dec1 * dec2, base);
+std::string Base::multiply_in_base(const std::string& num1, const std::string& num2, const int base) {
+    const int dec1 = base_to_decimal(num1, base);
+    const int dec2 = base_to_decimal(num2, base);
+    return decimal_to_base(dec1 * dec2, base);
 }
 
 // Utility functions
-bool Base::isValidInBase(const std::string& number, const int base) {
+bool Base::is_valid_in_base(const std::string& number, const int base) {
     if (number.empty() || base < 2 || base > 36) {
         return false;
     }
@@ -144,7 +144,7 @@ bool Base::isValidInBase(const std::string& number, const int base) {
 
     for (size_t i = start; i < number.length(); ++i) {
         try {
-            int digit = charToDigit(number[i]);
+            int digit = char_to_digit(number[i]);
             if (digit >= base) {
                 return false;
             }
@@ -156,7 +156,7 @@ bool Base::isValidInBase(const std::string& number, const int base) {
     return true;
 }
 
-std::string Base::toUpperCase(const std::string& str) {
+std::string Base::to_upper_case(const std::string& str) {
     std::string result = str;
     std::ranges::transform(result, result.begin(), ::toupper);
     return result;