[decimal] Implement tan(), cot(), csc(), sec() for BigDecimal (#99)

This pull request enhances the `BigDecimal` module by adding new
trigonometric functions, improving precision handling, and updating test
cases to ensure correctness. The most important changes include the
addition of tangent, cotangent, cosecant, and secant functions, updates
to the `sin` and `cos` functions for zero handling, and the inclusion of
comprehensive test cases for the new functionality.

### Enhancements to `BigDecimal` functionality:
* Added new trigonometric functions: `tan`, `cot`, `csc`, and `sec` to
the `BigDecimal` struct, enabling calculations for tangent, cotangent,
cosecant, and secant with arbitrary precision.
[[1]](diffhunk://#diff-be2f9b2702fd15952546e17fe94a64c22902a0e4678bfd9cb925269647923db4R781-R800)
[[2]](diffhunk://#diff-c958e120b7d4b4345780398bc974ce25453a40ef0edc4a7b1499844d3164640cR298-R461)
* Improved handling of zero values in `sin` and `cos` functions to use
`BigDecimal(BigUInt.ZERO)` and `BigDecimal(BigUInt.ONE)` for better
precision and consistency.
[[1]](diffhunk://#diff-c958e120b7d4b4345780398bc974ce25453a40ef0edc4a7b1499844d3164640cL59-R60)
[[2]](diffhunk://#diff-c958e120b7d4b4345780398bc974ce25453a40ef0edc4a7b1499844d3164640cL176-R175)
[[3]](diffhunk://#diff-c958e120b7d4b4345780398bc974ce25453a40ef0edc4a7b1499844d3164640cL231-R228)

### Updates to test cases:
* Added test cases for new trigonometric functions (`tan`, `cot`, `csc`,
and `sec`) to the TOML test data file, covering edge cases and typical
values.
* Updated the `run_test` function to directly compare `BigDecimal`
objects instead of converting them to strings for improved accuracy in
assertions.
* Expanded the `test_bigdecimal_trigonometric` function to include tests
for `cos`, `tan`, and `cot` functions alongside existing tests for `sin`
and `arctan`.

### Codebase improvements:
* Refactored import statements in `trigonometric.mojo` to include
`decimojo.bigdecimal.constants`, ensuring access to constants like π for
trigonometric calculations.

Author: forfudan

src/decimojo/bigdecimal/bigdecimal.mojo

@@ -35,7 +35,13 @@ alias BDec = BigDecimal
 
 @value
 struct BigDecimal(
-    Absable, Comparable, IntableRaising, Roundable, Stringable, Writable
+    Absable,
+    Comparable,
+    FloatableRaising,
+    IntableRaising,
+    Roundable,
+    Stringable,
+    Writable,
 ):
     """Represents a arbitrary-precision decimal.
 
@@ -772,6 +778,26 @@ struct BigDecimal(
         """Returns the cosine of the BigDecimal number."""
         return decimojo.bigdecimal.trigonometric.cos(self, precision)
 
+    @always_inline
+    fn tan(self, precision: Int = 28) raises -> Self:
+        """Returns the tangent of the BigDecimal number."""
+        return decimojo.bigdecimal.trigonometric.tan(self, precision)
+
+    @always_inline
+    fn cot(self, precision: Int = 28) raises -> Self:
+        """Returns the cotangent of the BigDecimal number."""
+        return decimojo.bigdecimal.trigonometric.cot(self, precision)
+
+    @always_inline
+    fn csc(self, precision: Int = 28) raises -> Self:
+        """Returns the cosecant of the BigDecimal number."""
+        return decimojo.bigdecimal.trigonometric.csc(self, precision)
+
+    @always_inline
+    fn sec(self, precision: Int = 28) raises -> Self:
+        """Returns the secant of the BigDecimal number."""
+        return decimojo.bigdecimal.trigonometric.sec(self, precision)
+
     @always_inline
     fn arctan(self, precision: Int = 28) raises -> Self:
         """Returns the arctangent of the BigDecimal number."""

src/decimojo/bigdecimal/trigonometric.mojo

@@ -23,6 +23,7 @@ import time
 from decimojo.bigdecimal.bigdecimal import BigDecimal
 from decimojo.rounding_mode import RoundingMode
 import decimojo.utility
+import decimojo.bigdecimal.constants
 
 
 # ===----------------------------------------------------------------------=== #
@@ -56,9 +57,7 @@ fn sin(x: BigDecimal, precision: Int) raises -> BigDecimal:
     var result: BigDecimal
 
     if x.is_zero():
-        return BigDecimal.from_raw_components(
-            UInt32(0), scale=precision, sign=x.sign
-        )
+        return BigDecimal(BigUInt.ZERO)
 
     var bdec_2 = BigDecimal.from_raw_components(UInt32(2), scale=0, sign=False)
     var bdec_4 = BigDecimal.from_raw_components(UInt32(4), scale=0, sign=False)
@@ -173,9 +172,7 @@ fn sin_taylor_series(
     var working_precision = minimum_precision + BUFFER_DIGITS
 
     if x.is_zero():
-        return BigDecimal.from_raw_components(
-            UInt32(0), scale=minimum_precision, sign=x.sign
-        )
+        return BigDecimal(BigUInt.ZERO)
 
     var term = x  # x^n / n!
     var result = x
@@ -228,9 +225,7 @@ fn cos(x: BigDecimal, precision: Int) raises -> BigDecimal:
     var working_precision = precision + BUFFER_DIGITS
 
     if x.is_zero():
-        return BigDecimal.from_raw_components(
-            UInt32(1), scale=precision, sign=x.sign
-        )
+        return BigDecimal(BigUInt.ONE)
 
     # cos(x) = sin(π/2 - x)
     var pi = decimojo.bigdecimal.constants.pi(precision=working_precision)
@@ -300,6 +295,170 @@ fn cos_taylor_series(
     return result^
 
 
+fn tan(x: BigDecimal, precision: Int) raises -> BigDecimal:
+    """Calculates tangent (tan) of the number.
+
+    Args:
+        x: The input number in radians.
+        precision: The desired precision of the result.
+
+    Returns:
+        The tangent of x with the specified precision.
+
+    Notes:
+
+    This function calculates tan(x) = sin(x) / cos(x).
+    """
+    return tan_cot(x, precision, is_tan=True)
+
+
+fn cot(x: BigDecimal, precision: Int) raises -> BigDecimal:
+    """Calculates cotangent (cot) of the number.
+
+    Args:
+        x: The input number in radians.
+        precision: The desired precision of the result.
+
+    Returns:
+        The cotangent of x with the specified precision.
+
+    Notes:
+
+    This function calculates cot(x) = cos(x) / sin(x).
+    """
+    return tan_cot(x, precision, is_tan=False)
+
+
+fn tan_cot(x: BigDecimal, precision: Int, is_tan: Bool) raises -> BigDecimal:
+    """Calculates tangent (tan) or cotangent (cot) of the number.
+
+    Args:
+        x: The input number in radians.
+        precision: The desired precision of the result.
+        is_tan: If True, calculates tangent; if False, calculates cotangent.
+
+    Returns:
+        The cotangent of x with the specified precision.
+
+    Notes:
+
+    This function calculates tan(x) = cos(x) / sin(x) or
+    cot(x) = sin(x) / cos(x) depending on the is_tan flag.
+    """
+
+    alias BUFFER_DIGITS = 99
+    var working_precision_pi = precision + 2 * BUFFER_DIGITS
+    var working_precision = precision + BUFFER_DIGITS
+
+    if x.is_zero():
+        if is_tan:
+            return BigDecimal(BigUInt.ZERO)
+        else:
+            # cot(0) is undefined, but we return 0 for consistency
+            # since tan(0) is defined as 0.
+            # This is a design choice, not a mathematical one.
+            # In practice, cot(0) should raise an error.
+            raise Error(
+                "bigdecimal.trigonometric.tan_cot: cot(nπ) is undefined."
+            )
+
+    var pi = decimojo.bigdecimal.constants.pi(precision=working_precision_pi)
+    var bdec_2 = BigDecimal.from_raw_components(UInt32(2), scale=0, sign=False)
+    var two_pi = bdec_2 * pi
+    var pi_div_2 = pi.true_divide(bdec_2, precision=working_precision_pi)
+
+    var x_reduced = x
+    # First reduce to (-π, π) range
+    if x_reduced.compare_absolute(pi) > 0:
+        x_reduced = x_reduced % two_pi
+        # Adjust to (-π, π) range
+        if x_reduced.compare_absolute(pi) > 0:
+            if x_reduced.sign:
+                x_reduced += two_pi
+            else:
+                x_reduced -= two_pi
+
+    # Now reduce to (-π/2, π/2) using tan(x + π) = tan(x)
+    if x_reduced.compare_absolute(pi_div_2) > 0:
+        if x_reduced.sign:
+            x_reduced += pi
+        else:
+            x_reduced -= pi
+
+    # Calculate
+    # tan(x) = sin(x) / cos(x)
+    # cot(x) = cos(x) / sin(x)
+    var sin_x: BigDecimal = sin(x_reduced, precision=working_precision)
+    var cos_x: BigDecimal = cos(x_reduced, precision=working_precision)
+    if is_tan:
+        result: BigDecimal = sin_x.true_divide(
+            cos_x, precision=working_precision
+        )
+    else:
+        result: BigDecimal = cos_x.true_divide(
+            sin_x, precision=working_precision
+        )
+
+    result.round_to_precision(
+        precision,
+        RoundingMode.ROUND_HALF_EVEN,
+        remove_extra_digit_due_to_rounding=True,
+        fill_zeros_to_precision=False,
+    )
+
+    return result^
+
+
+fn csc(x: BigDecimal, precision: Int) raises -> BigDecimal:
+    """Calculates cosecant (csc) of the number.
+
+    Args:
+        x: The input number in radians.
+        precision: The desired precision of the result.
+
+    Returns:
+        The cosecant of x with the specified precision.
+
+    Notes:
+
+    This function calculates csc(x) = 1 / sin(x).
+    """
+    if x.is_zero():
+        raise Error("bigdecimal.trigonometric.csc: csc(nπ) is undefined.")
+
+    alias BUFFER_DIGITS = 9
+    var working_precision = precision + BUFFER_DIGITS
+
+    var sin_x = sin(x, precision=working_precision)
+
+    return BigDecimal(BigUInt.ONE).true_divide(sin_x, precision=precision)
+
+
+fn sec(x: BigDecimal, precision: Int) raises -> BigDecimal:
+    """Calculates secant (sec) of the number.
+
+    Args:
+        x: The input number in radians.
+        precision: The desired precision of the result.
+
+    Returns:
+        The secant of x with the specified precision.
+
+    Notes:
+
+    This function calculates sec(x) = 1 / cos(x).
+    """
+    if x.is_zero():
+        return BigDecimal(BigUInt.ONE)
+
+    alias BUFFER_DIGITS = 9
+    var working_precision = precision + BUFFER_DIGITS
+
+    var cos_x = cos(x, precision=working_precision)
+
+    return BigDecimal(BigUInt.ONE).true_divide(cos_x, precision=precision)
+
+
 # ===----------------------------------------------------------------------=== #
 # Inverse trigonometric functions
 # ===----------------------------------------------------------------------=== #

tests/bigdecimal/test_bigdecimal_trigonometric.mojo

@@ -21,8 +21,8 @@ fn run_test[
     for test_case in test_cases:
         var result = func(BDec(test_case.a), 50)
         testing.assert_equal(
-            lhs=String(result),
-            rhs=test_case.expected,
+            lhs=result,
+            rhs=BDec(test_case.expected),
             msg=test_case.description,
         )
 
@@ -31,16 +31,31 @@ fn test_bigdecimal_trignometric() raises:
     # Load test cases from TOML file
     var toml = parse_file(file_path)
 
-    run_test[func = decimojo.bigdecimal.trigonometric.arctan](
-        toml,
-        "arctan_tests",
-        "arctan",
-    )
     run_test[func = decimojo.bigdecimal.trigonometric.sin](
         toml,
         "sin_tests",
         "sin",
     )
+    run_test[func = decimojo.bigdecimal.trigonometric.cos](
+        toml,
+        "cos_tests",
+        "cos",
+    )
+    run_test[func = decimojo.bigdecimal.trigonometric.tan](
+        toml,
+        "tan_tests",
+        "tan",
+    )
+    run_test[func = decimojo.bigdecimal.trigonometric.cot](
+        toml,
+        "cot_tests",
+        "cot",
+    )
+    run_test[func = decimojo.bigdecimal.trigonometric.arctan](
+        toml,
+        "arctan_tests",
+        "arctan",
+    )
 
 
 fn main() raises: