Allow faster decimal power

- Faster decimal power through `exp` and `ln`
- More accurate `exp` by fixing a rounding bug
- [DEV] Allow building all tests with `make tests`
- Allow `decimal` option in `power`

Author: ZCG-coder

include/fn/calc.hpp

@@ -163,9 +163,10 @@ namespace steppable::__internals::calc
      * @param[in] _number The string representation of the number.
      * @param[in] raiseTo The string representation of the power to raise the number to.
      * @param[in] steps The number of steps to perform the power operation.
+     * @param[in] decimals The number of decimals to output from the power operation.
      * @return The result of the power operation as a string.
      */
-    std::string power(const std::string& _number, const std::string& raiseTo, int steps = 2);
+    std::string power(const std::string& _number, const std::string& raiseTo, int steps = 2, int decimals = 8);
 
     /**
      * @brief Calculates e^x. Shorthand of power(x, E, 0);

res/translations/en-US/power.stp_localized

@@ -68,8 +68,8 @@ namespace steppable::__internals::calc
         checkDecimalArg(&decimals);
 
         const auto& twoX = multiply(x, "2", 0, decimals + 2);
-        const auto& eTwoX = roundOff(power(static_cast<std::string>(constants::E), twoX, 0), decimals + 2);
-        const auto& eX = roundOff(power(static_cast<std::string>(constants::E), x, 0), decimals + 2);
+        const auto& eTwoX = exp(twoX, decimals + 2);
+        const auto& eX = exp(x, decimals + 2);
 
         const auto& numerator = add(eTwoX, "1", 0);
         const auto& denominator = multiply("2", eX, 0, decimals + 2);

res/translations/power.stp_strings

@@ -65,10 +65,10 @@ namespace steppable::__internals::calc
         // ln(x) = ----------------------- = --------------
         //               2                     2
         //              x  + 4x + 1           x  + 4x + 1
-        const auto& x2 = power(x, "2", 0);
+        const auto& x2 = multiply(x, x, 0, static_cast<int>(decimals) + 2);
         const auto& x2Minus1 = subtract(x2, "1", 0);
-        const auto& numerator = multiply("3", x2Minus1, 0, static_cast<int>(decimals));
-        const auto& fourX = multiply(x, "4", 0, static_cast<int>(decimals));
+        const auto& numerator = multiply("3", x2Minus1, 0, static_cast<int>(decimals) + 2);
+        const auto& fourX = multiply(x, "4", 0, static_cast<int>(decimals) + 2);
 
         auto denominator = add(x2, fourX, 0);
         denominator = add(denominator, "1", 0);
@@ -84,7 +84,7 @@ namespace steppable::__internals::calc
         //          n + 1
 
         const auto& epsilon = "0." + std::string(_decimals + 1, '0') + "1";
-        auto yn = divide(numerator, denominator, 0, static_cast<int>(decimals));
+        auto yn = divide(numerator, denominator, 0, static_cast<int>(decimals) + 2);
         auto yn1 = yn;
 
         auto error = abs(subtract(yn, yn1, 0), 0);

res/translations/zh-HK/power.stp_localized

@@ -59,23 +59,20 @@ namespace steppable::prettyPrint::printers
 
 namespace steppable::__internals::calc
 {
-    std::string power(const std::string& _number, const std::string& _raiseTo, const int steps)
+    std::string power(const std::string& _number, const std::string& _raiseTo, const int steps, const int decimals)
     {
         std::string raiseTo = static_cast<std::string>(_raiseTo);
         std::string number = static_cast<std::string>(_number);
 
         if (isDecimal(raiseTo))
         {
             // Raising to decimal power.
-            // Steps:
-            // 1. Convert the decimal to a fraction.
-            // 2. Raise the number to the numerator of the fraction.
-            // 3. Take the root of the number to the denominator of the fraction.
-            const auto& fraction = Fraction(raiseTo);
-            const auto& [top, bottom] = fraction.asArray();
-            const auto& powerResult = power(_number, top, 0);
-            const auto rootResult = root(powerResult, bottom, 8);
-            return reportPowerRoot(number, raiseTo, fraction, rootResult, steps);
+            //  b    b ln(a)
+            // a  = e
+            const auto lnNumber = ln(_number, decimals + 2);
+            const auto bLnNumber = multiply(lnNumber, raiseTo, 0, decimals + 2);
+            // return reportPowerRoot(number, raiseTo, fraction, rootResult, steps);
+            return exp(bLnNumber, decimals);
         }
 
         // Here, we attempt to give a quick answer, instead of doing pointless iterations.
@@ -118,26 +115,21 @@ namespace steppable::__internals::calc
             raiseTo = raiseTo.substr(1);
             negativePower = true;
         }
-        return reportPower(number, raiseTo, numberTrailingZeros, negativePower, steps);
+        return reportPower(number, raiseTo, numberTrailingZeros, negativePower, steps, decimals);
     }
 
     std::string exp(const std::string& x, const size_t decimals)
     {
-        if (compare(x, "20", 0) == "0")
+        constexpr size_t iter = 50;
+        std::string sum = "1";
+        std::string term = "1";
+        for (size_t i = 1; i < iter; i++)
         {
-            constexpr size_t iter = 200;
-            std::string sum = "1";
-            std::string term = "1";
-            for (size_t i = 1; i < iter; i++)
-            {
-                std::string frac = divide(x, std::to_string(i), 0, static_cast<int>(decimals));
-                term = multiply(term, frac, 0, static_cast<int>(decimals));
-                sum = add(sum, term, 0);
-            }
-            return sum;
+            std::string frac = divide(x, std::to_string(i), 0, static_cast<int>(decimals) + 2);
+            term = multiply(term, frac, 0, static_cast<int>(decimals) + 2);
+            sum = add(sum, term, 0);
         }
-
-        return power(exp(divide(x, "4", 0, static_cast<int>(decimals))), "4", 0);
+        return roundOff(sum, decimals);
     }
 } // namespace steppable::__internals::calc
 
@@ -149,14 +141,22 @@ int main(const int _argc, const char* _argv[])
     program.addPosArg('a', $("power", "4252ac37-a36b-4605-9ec1-d69e70b91b46"));
     program.addPosArg('b', $("power", "1fefffaf-7731-430b-989f-42e74017a2eb"));
     program.addKeywordArg("steps", 2, $("power", "cb935566-6125-49ce-9ebc-e157410a3005"));
+    program.addKeywordArg("decimals", 2, $("power", "03c15572-a5aa-4b1c-a705-105770999741"));
     program.addSwitch("profile", false, $("power", "e5d48237-e161-494d-940b-e2457411fcfb"));
     program.parseArgs();
 
     int steps = program.getKeywordArgument("steps");
+    int decimals = program.getKeywordArgument("decimals");
     bool profile = program.getSwitch("profile");
     const auto& aStr = program.getPosArg(0);
     const auto& bStr = program.getPosArg(1);
 
+    if (steps == 475)
+    {
+        std::cout << steppable::__internals::calc::exp(aStr, decimals) << std::endl;
+        return 0;
+    }
+
     if (profile)
     {
         TIC(Power)

src/calc/hyp/hyp.cpp

@@ -34,6 +34,7 @@
 #include "fn/calc.hpp"
 #include "fraction.hpp"
 #include "getString.hpp"
+#include "rounding.hpp"
 #include "symbols.hpp"
 #include "util.hpp"
 
@@ -71,7 +72,8 @@ std::string reportPower(const std::string& _number,
                         const std::string& raiseTo,
                         const size_t numberTrailingZeros,
                         const bool negativePower,
-                        const int steps)
+                        const int steps,
+                        const int decimals)
 {
     std::stringstream ss;
     auto result = "1"s;
@@ -91,9 +93,9 @@ std::string reportPower(const std::string& _number,
 
     loop(raiseTo, [&](const auto& i) {
         if (not negativePower)
-            result = multiply(result, _number, 0);
+            result = multiply(result, _number, 0, decimals + 1);
         else
-            result = divide("1", result, 0);
+            result = divide("1", result, 0, decimals + 1);
         auto currentPower = add(i, "1", 0);
         if (steps == 2)
         {
@@ -110,14 +112,15 @@ std::string reportPower(const std::string& _number,
 
 finish:
     result = numUtils::standardizeNumber(result);
+    result = numUtils::roundOff(result, decimals);
 
     if (negativePower)
     {
         if (steps == 2)
-            ss << BECAUSE << " " << divide("1", result, 1) << '\n';
+            ss << BECAUSE << " " << divide("1", result, 1, decimals) << '\n';
         else if (steps == 1)
         {
-            const auto& divisionResult = divide("1", result, 0);
+            const auto& divisionResult = divide("1", result, 0, decimals);
             ss << _number << makeSuperscript('-') << makeSuperscript(static_cast<std::string>(raiseTo)) << " = "
                << divisionResult;
         }
@@ -130,7 +133,7 @@ std::string reportPower(const std::string& _number,
     else if (steps == 0)
         ss << result;
 
-    loop(multiply(raiseTo, std::to_string(numberTrailingZeros), 0), [&](const auto& _) { ss << "0"; });
+    loop(multiply(raiseTo, std::to_string(numberTrailingZeros), 0, 0), [&](const auto& _) { ss << "0"; });
 
     return ss.str();
 }

src/calc/log/log.cpp

@@ -62,4 +62,5 @@ std::string reportPower(const std::string& _number,
                         const std::string& raiseTo,
                         size_t numberTrailingZeros,
                         bool negativePower,
-                        int steps);
+                        int steps,
+                        int decimals);

src/calc/power/power.cpp

@@ -133,7 +133,8 @@ namespace steppable::__internals::calc
         auto result = _cos(standardizeNumber(divide(x, "4", 0, decimals + 1)), decimals + 2);
         auto result2 = roundOff(multiply(result, result, 0, decimals + 2), static_cast<long>(decimals) + 2);
         // return 8 * C2 * (C2 - 1) + 1;
-        return standardizeNumber(add(multiply("8", multiply(result2, subtract(result2, "1", 0), 0, decimals), 0), "1", 0));
+        return standardizeNumber(
+            add(multiply("8", multiply(result2, subtract(result2, "1", 0), 0, decimals), 0), "1", 0));
     }
 
     std::string cos(const std::string& x, const int decimals, const int mode)
@@ -320,7 +321,7 @@ namespace steppable::__internals::calc
         {
             isReduced = true;
             // Reduce x to a small number
-            x = divide("1", x, 0, decimals * 2);
+            x = divide("1", x, 0, decimals + 2);
         }
         // Otherwise, use integration.
         //                      1                       / x
@@ -329,11 +330,11 @@ namespace steppable::__internals::calc
         //  dx                 x + 1                    |      2
         //                                              / 0   t  + 1
         auto fx = [&](const std::string& y) {
-            const auto& y2 = power(y, "2", 0);
+            const auto& y2 = multiply(y, y, 0);
             const auto& denominator = add(y2, "1", 0);
-            return divide("1", denominator, 0, decimals + 1);
+            return divide("1", denominator, 0, decimals * 2);
         };
-        auto result = calculus::romberg(fx, "0", x, 10, decimals + 1);
+        auto result = calculus::romberg(fx, "0", x, 10, decimals + 2);
         if (isReduced)
         {
             // If x was reduced, use the identity

src/calc/power/powerReport.cpp

@@ -72,6 +72,9 @@ namespace steppable::__internals::numUtils
         auto decimal = splitNumberArray[1];
         bool isNegative = splitNumberResult.aIsNegative;
 
+        if (decimal.length() < digits)
+            return _number;
+
         // Preserve one digit after the rounded digit
         decimal = decimal.substr(0, digits + 1);
         // Modify the integer part if the digit is greater than 5

src/calc/power/powerReport.hpp

@@ -28,3 +28,6 @@ FOREACH(ITEM IN LISTS TEST_TARGETS)
     ADD_TEST(NAME ${ITEM} COMMAND ${CMAKE_BINARY_DIR}/tests/${ITEM})
     MESSAGE(TRACE "Added test case: ${ITEM}: ${ITEM}.cpp")
 ENDFOREACH()
+
+ADD_CUSTOM_TARGET(tests)
+ADD_DEPENDENCIES(tests ${TEST_TARGETS})

src/calc/trig/trig.cpp

@@ -37,31 +37,31 @@ using namespace steppable::__internals::calc;
 SECTION(Power)
 const std::string number = "47";
 const std::string raiseTo = "10";
-const auto& result = power(number, raiseTo, 0);
+const auto& result = power(number, raiseTo, 0, 8);
 
 _.assertIsEqual(result, "52599132235830049");
 SECTION_END()
 
 SECTION(Power with Decimals)
 const std::string number = "47.5";
 const std::string raiseTo = "10";
-const auto& result = power(number, raiseTo, 0);
+const auto& result = power(number, raiseTo, 0, 8);
 
-_.assertIsEqual(result, "58470404222497940.0634765625");
+_.assertIsEqual(result, "58470404222497940.06347656");
 SECTION_END()
 
 SECTION(Power with Decimals)
 const std::string number = "0.5";
 const std::string raiseTo = "10";
-const auto& result = power(number, raiseTo, 0);
+const auto& result = power(number, raiseTo, 0, 8);
 
-_.assertIsEqual(result, "0.0009765625");
+_.assertIsEqual(result, "0.00097656");
 SECTION_END()
 
 SECTION(Power with Decimal Exponents)
 const std::string number = "4";
 const std::string raiseTo = "0.5";
-const auto& result = power(number, raiseTo, 0);
+const auto& result = power(number, raiseTo, 0, 2);
 
 _.assertIsEqual(numUtils::roundOff(result), "2");
 SECTION_END()