Fix power sign issue

Author: ZCG-coder

include/util.hpp

@@ -394,6 +394,22 @@ namespace steppable::__internals::numUtils
      * @return True if it is a power of 10, false otherwise.
      */
     bool isPowerOfTen(const std::string& number);
+
+    /**
+     * @brief Checks if a number is odd.
+     *
+     * @param number The number to be checked.
+     * @return True if the number is odd, false otherwise.
+     */
+    bool isOdd(const std::string& number);
+
+    /**
+     * @brief Checks if a number is even.
+     *
+     * @param number The number to be checked.
+     * @return True if the number is even, false otherwise.
+     */
+    bool isEven(const std::string& number);
 } // namespace steppable::__internals::numUtils
 
 /**

src/calc/power/power.cpp

@@ -98,9 +98,10 @@ namespace steppable::__internals::calc
 
         auto numberNoTrailingZeros = standardizeNumber(number);
         size_t numberTrailingZeros = 0;
+        auto result = splitNumber(number, "0", false, false, true, true);
         if (isInteger(number))
         {
-            number = splitNumber(number, "0", false, false, true).splitNumberArray[0];
+            number = result.splitNumberArray[0];
             numberNoTrailingZeros = removeTrailingZeros(number);
             numberTrailingZeros = number.length() - numberNoTrailingZeros.length();
         }
@@ -109,14 +110,15 @@ namespace steppable::__internals::calc
         // Remove the zeros to reduce the workload.
         number = numberNoTrailingZeros;
 
-        bool negative = false;
+        bool negativePower = false;
+
         if (compare(raiseTo, "0", 0) == "0")
         {
             // raiseTo is negative
             raiseTo = raiseTo.substr(1);
-            negative = true;
+            negativePower = true;
         }
-        return reportPower(number, raiseTo, numberTrailingZeros, negative, steps);
+        return reportPower(number, raiseTo, numberTrailingZeros, negativePower, steps);
     }
 
     std::string exp(const std::string& x, const size_t decimals)

src/calc/power/powerReport.cpp

@@ -70,18 +70,16 @@ std::string reportPowerRoot(const std::string& _number,
 std::string reportPower(const std::string& _number,
                         const std::string& raiseTo,
                         const size_t numberTrailingZeros,
-                        const bool negative,
+                        const bool negativePower,
                         const int steps)
 {
     std::stringstream ss;
-    const auto numberOrig = static_cast<std::string>(_number);
-
-    auto number = "1"s;
+    auto result = "1"s;
 
     // Here, we attempt to give a quick answer, instead of doing pointless iterations.
-    if (numberOrig == "1")
+    if (_number == "1")
         goto finish; // NOLINT(cppcoreguidelines-avoid-goto)
-    if (numberOrig == "0")
+    if (_number == "0")
     {
         if (steps == 2)
             // The number is 0, so the result is 0.
@@ -92,45 +90,45 @@ std::string reportPower(const std::string& _number,
     }
 
     loop(raiseTo, [&](const auto& i) {
-        if (not negative)
-            number = multiply(number, numberOrig, 0);
+        if (not negativePower)
+            result = multiply(result, _number, 0);
         else
-            number = divide("1", number, 0);
+            result = divide("1", result, 0);
         auto currentPower = add(i, "1", 0);
         if (steps == 2)
         {
-            if (not negative)
-                ss << BECAUSE << " " << multiply(number, numberOrig, 1) << '\n';
+            if (not negativePower)
+                ss << BECAUSE << " " << multiply(result, _number, 1) << '\n';
             else
-                ss << BECAUSE << " " << divide("1", number, 1) << '\n';
-            if (negative)
+                ss << BECAUSE << " " << divide("1", result, 1) << '\n';
+            if (negativePower)
                 currentPower = "-" + currentPower;
 
-            ss << printers::ppSuperscript(numberOrig, currentPower) << " = " << number << '\n';
+            ss << printers::ppSuperscript(_number, currentPower) << " = " << result << '\n';
         }
     });
 
 finish:
-    number = numUtils::standardizeNumber(number);
+    result = numUtils::standardizeNumber(result);
 
-    if (negative)
+    if (negativePower)
     {
         if (steps == 2)
-            ss << BECAUSE << " " << divide("1", number, 1) << '\n';
+            ss << BECAUSE << " " << divide("1", result, 1) << '\n';
         else if (steps == 1)
         {
-            const auto& divisionResult = divide("1", number, 0);
-            ss << numberOrig << makeSuperscript('-') << makeSuperscript(static_cast<std::string>(raiseTo)) << " = "
+            const auto& divisionResult = divide("1", result, 0);
+            ss << _number << makeSuperscript('-') << makeSuperscript(static_cast<std::string>(raiseTo)) << " = "
                << divisionResult;
         }
         else
-            ss << number;
+            ss << result;
     }
 
     if (steps >= 1)
-        ss << numberOrig << makeSuperscript(raiseTo) << " = " << number;
+        ss << _number << makeSuperscript(raiseTo) << " = " << result;
     else if (steps == 0)
-        ss << number;
+        ss << result;
 
     loop(multiply(raiseTo, std::to_string(numberTrailingZeros), 0), [&](const auto& _) { ss << "0"; });
 

src/calc/power/powerReport.hpp

@@ -53,13 +53,13 @@ std::string reportPowerRoot(const std::string& _number,
  *
  * @param[in] _number The number to raise to.
  * @param[in] raiseTo The power of the number.
- * @param[in] negative Whether the result should be negative.
+ * @param[in] negativePower Whether the result should be divided by 1.
  * @param[in] steps The steps to show.
  *
  * @return The formatted power report.
  */
 std::string reportPower(const std::string& _number,
                         const std::string& raiseTo,
                         size_t numberTrailingZeros,
-                        bool negative,
+                        bool negativePower,
                         int steps);

src/util.cpp

@@ -285,6 +285,27 @@ namespace steppable::__internals::numUtils
         number = number.substr(1, number.length() - 1);
         return not std::ranges::any_of(number, [](const auto& c) { return c != '0' and c != '.'; });
     }
+
+    bool isOdd(const std::string& number)
+    {
+        if (isDecimal(number))
+            return false; // Decimals cannot be classified.
+        if (isZeroString(number))
+            return false; // Zero is neither even nor odd.
+
+        const char lastDigit = number.back();
+        return (lastDigit - '0') % 2 == 1;
+    }
+
+    bool isEven(const std::string& number)
+    {
+        if (isDecimal(number))
+            return false; // Decimals cannot be classified.
+        if (isZeroString(number))
+            return false; // Zero is neither even nor odd.
+
+        return not isOdd(number);
+    }
 } // namespace steppable::__internals::numUtils
 
 namespace steppable::__internals::stringUtils