Added tests.

Author: ZCG-coder

include/fn/basicArithm.hpp

@@ -304,6 +304,28 @@ namespace steppable::__internals::arithmetic
      */
     std::string cot(const std::string& x, int decimals, int mode = 0);
 
+    /**
+     * @brief Calculates the arc cosine of a number.
+     *
+     * @param x The number to calculate the arc cosine of.
+     * @param decimals The number of decimal places to round off to.
+     * @param mode The mode to calculate the arc cosine in. 0 = radians (default), 1 = degrees, 2 = gradians.
+     *
+     * @return The arc cosine of the number.
+     */
+    std::string acos(const std::string& x, int decimals, int mode = 0);
+
+    /**
+     * @brief Calculates the arc sine of a number.
+     *
+     * @param x The number to calculate the arc sine of.
+     * @param decimals The number of decimal places to round off to.
+     * @param mode The mode to calculate the arc sine in. 0 = radians (default), 1 = degrees, 2 = gradians.
+     *
+     * @return The arc sine of the number.
+     */
+    std::string asin(const std::string& x, int decimals, int mode = 0);
+
     /**
      * @brief Calculates the arc tangent of a number.
      *
@@ -315,6 +337,39 @@ namespace steppable::__internals::arithmetic
      */
     std::string atan(const std::string& x, int decimals, int mode = 0);
 
+    /**
+     * @brief Calculates the arc secant of a number.
+     *
+     * @param x The number to calculate the arc secant of.
+     * @param decimals The number of decimal places to round off to.
+     * @param mode The mode to calculate the arc secant in. 0 = radians (default), 1 = degrees, 2 = gradians.
+     *
+     * @return The arc secant of the number.
+     */
+    std::string asec(const std::string& x, int decimals, int mode = 0);
+
+    /**
+     * @brief Calculates the arc cosecant of a number.
+     *
+     * @param x The number to calculate the arc cosecant of.
+     * @param decimals The number of decimal places to round off to.
+     * @param mode The mode to calculate the arc cosecant in. 0 = radians (default), 1 = degrees, 2 = gradians.
+     *
+     * @return The arc cosecant of the number.
+     */
+    std::string acsc(const std::string& x, int decimals, int mode = 0);
+
+    /**
+     * @brief Calculates the arc cotangent of a number.
+     *
+     * @param x The number to calculate the arc cotangent of.
+     * @param decimals The number of decimal places to round off to.
+     * @param mode The mode to calculate the arc cotangent in. 0 = radians (default), 1 = degrees, 2 = gradians.
+     *
+     * @return The arc cotangent of the number.
+     */
+    std::string acot(const std::string& x, int decimals, int mode = 0);
+
     /**
      * @brief Executes a given predicate function a specified number of times.
      *

src/root/root.cpp

@@ -171,6 +171,8 @@ namespace steppable::__internals::arithmetic
 
     std::string root(const std::string& _number, const std::string& base, const size_t _decimals)
     {
+        if (isZeroString(_number))
+            return "0";
         if (isInteger(_number))
         {
             auto result = rootSurd(_number, base);

src/trig/trig.cpp

@@ -325,13 +325,22 @@ namespace steppable::__internals::arithmetic
 
     std::string asin(const std::string& x, const int decimals, const int mode)
     {
-        if (compare(abs(x, 0), "1", 0) != "0")
+        if (compare(abs(x, 0), "1", 0) == "1")
+        {
             error("trig::asin"s, "Arc sine is not defined here."s);
+            return "Infinity";
+        }
+        if (compare(abs(x, 0), "0", 0) == "2")
+            return "0";
 
         auto x2 = power(x, "2", 0);
         auto x3 = multiply(x2, x, 0);
         auto x5 = multiply(x3, x2, 0);
         auto x7 = multiply(x5, x2, 0);
+        std::string onePlusX;
+        std::string oneMinusX;
+        std::string sqrtOnePlusX;
+        std::string sqrtOneMinusX;
         std::string result;
 
         // For x <= 0.5, use Taylor series.
@@ -344,7 +353,7 @@ namespace steppable::__internals::arithmetic
             result = add(x, divide(x3, "6", 0), 0);
             result = add(result, divide(multiply(x5, "3", 0), "40", 0), 0);
             result = add(result, divide(multiply(x7, "5", 0), "112", 0), 0);
-            return roundOff(result, decimals);
+            goto out; // NOLINT(cppcoreguidelines-avoid-goto)
         }
 
         // Othman, S. B.; Bagul, Y. J. An Innovative Method for Approximating Arcsine Function. Preprints 2022,
@@ -356,16 +365,17 @@ namespace steppable::__internals::arithmetic
         //                              /-----|     /-----|           5        3
         //           = 1.021548218 * (\/ 1 + x  − \/ 1 − x ) + (0.239x − 0.138x + 0.005x)
 
-        auto onePlusX = add("1", x, 0);
-        auto oneMinusX = subtract("1", x, 0);
-        auto sqrtOnePlusX = root(onePlusX, "2", static_cast<long>(decimals) * 2);
-        auto sqrtOneMinusX = root(oneMinusX, "2", static_cast<long>(decimals) * 2);
+        onePlusX = add("1", x, 0);
+        oneMinusX = subtract("1", x, 0);
+        sqrtOnePlusX = root(onePlusX, "2", static_cast<long>(decimals) * 2);
+        sqrtOneMinusX = root(oneMinusX, "2", static_cast<long>(decimals) * 2);
 
         result = multiply("1.021548218", subtract(sqrtOnePlusX, sqrtOneMinusX, 0), 0);
         result = add(result,
                      add(multiply("0.239", x5, 0), subtract(multiply("0.138", x3, 0), multiply("0.005", x, 0), 0), 0),
                      0);
 
+    out:
         switch (mode)
         {
         case 1:
@@ -378,7 +388,7 @@ namespace steppable::__internals::arithmetic
             break;
         }
 
-        return result;
+        return roundOff(result, decimals);
     }
 
     std::string acos(const std::string& x, const int decimals, const int mode)
@@ -404,8 +414,11 @@ namespace steppable::__internals::arithmetic
 
     std::string asec(const std::string& x, const int decimals, const int mode)
     {
-        if (compare(abs(x, 0), "1", 0) != "0")
+        if (compare(abs(x, 0), "1", 0) == "1")
+        {
             error("trig::asec"s, "Arc secant is not defined here."s);
+            return "Infinity";
+        }
 
         //                 1
         // asec(x) = acos(---)
@@ -416,7 +429,10 @@ namespace steppable::__internals::arithmetic
     std::string acsc(const std::string& x, const int decimals, const int mode)
     {
         if (compare(abs(x, 0), "1", 0) != "0")
+        {
             error("trig::acsc"s, "Arc cosecant is not defined here."s);
+            return "Infinity";
+        }
 
         //                 1
         // acsc(x) = asin(---)
@@ -427,7 +443,10 @@ namespace steppable::__internals::arithmetic
     std::string acot(const std::string& x, const int decimals, const int mode)
     {
         if (compare(abs(x, 0), "1", 0) != "0")
+        {
             error("trig::acot"s, "Arc cotangent is not defined here."s);
+            return "Infinity";
+        }
 
         //                 1
         // acot(x) = atan(---)

tests/testTrig.cpp

@@ -21,6 +21,7 @@
  **************************************************************************************************/
 
 #include "colors.hpp"
+#include "fn/basicArithm.hpp"
 #include "output.hpp"
 #include "testing.hpp"
 #include "util.hpp"
@@ -29,4 +30,24 @@
 #include <iostream>
 
 TEST_START()
+using namespace steppable::__internals::arithmetic;
+
+// We can just test the basics of the trigonometric functions, as the rest are based on them.
+SECTION(Test sine and cosine)
+_.assertIsEqual(sin("30", 2, 1), "0.50");
+_.assertIsEqual(cos("60", 2, 1), "0.50");
+SECTION_END()
+
+SECTION(Test tangent)
+_.assertIsEqual(tan("45", 2, 1), "1.00");
+// Zero check test
+_.assertIsEqual(tan("90", 2, 1), "Infinity");
+SECTION_END()
+
+SECTION(Test arc sine)
+_.assertIsEqual(asin("0.5", 2, 1), "30.00");
+// Zero check test
+_.assertIsEqual(asin("0", 2, 1), "0");
+SECTION_END()
+
 TEST_END()