[libc][math] Added atanf function.

[orex]

Summary

Performance by core-math (core-math/glibc 2.31/current llvm-14):
28.879/20.843/20.15

The revision should be applied on top of D132811.

[zimmermann6]

ok for me, I get slightly different figures on a AMD EPYC 7282:

zimmerma@biscotte:~/svn/core-math$ LIBM=/localdisk/zimmerma/llvm-project/build/projects/libc/lib/libllvmlibc.a CORE_MATH_PERF_MODE=rdtsc ./perf.sh atanf
GNU libc version: 2.34
GNU libc release: stable
17.539
31.797
26.903

[lntue]

libc/src/__support/FPUtil/FPBits.h

200

Please add the same function for x86_64/LongDoubleBits

libc/src/math/generic/atanf.cpp

24

Are these constants affected by rounding modes? Also it would be better to define this constant ourselves in some our own header, not relying on the constants defined in math.h.

29

Add comment about its hexadecimal float value.

31

Add comment about its hexadecimal float value.

37

Add comment about its hexadecimal float value.

41

Add comment about its hexadecimal float value.

44

Add comment about its hexadecimal float value.

[orex]

Review fixes.

[lntue]

libc/src/math/generic/atanf.cpp

13

Update this header file.

libc/config/darwin/arm/entrypoints.txt

set(TARGET_LIBM_ENTRYPOINTS
     libc.src.fenv.fesetenv
     libc.src.fenv.fesetexceptflag
     libc.src.fenv.fesetround
     libc.src.fenv.feraiseexcept
     libc.src.fenv.fetestexcept
     libc.src.fenv.feupdateenv
 
     # math.h entrypoints
+    libc.src.math.atanf
     libc.src.math.atanhf
     libc.src.math.copysign
     libc.src.math.copysignf
     libc.src.math.copysignl
     libc.src.math.ceil
     libc.src.math.ceilf
     libc.src.math.ceill
     libc.src.math.coshf

libc/config/linux/aarch64/entrypoints.txt

set(TARGET_LIBM_ENTRYPOINTS
     libc.src.fenv.fesetenv
     libc.src.fenv.fesetexceptflag
     libc.src.fenv.fesetround
     libc.src.fenv.feraiseexcept
     libc.src.fenv.fetestexcept
     libc.src.fenv.feupdateenv
 
     # math.h entrypoints
+    libc.src.math.atanf
     libc.src.math.atanhf    
     libc.src.math.copysign
     libc.src.math.copysignf
     libc.src.math.copysignl
     libc.src.math.ceil
     libc.src.math.ceilf
     libc.src.math.ceill
     libc.src.math.coshf

libc/config/linux/x86_64/entrypoints.txt

set(TARGET_LIBM_ENTRYPOINTS
     libc.src.fenv.fesetenv
     libc.src.fenv.fesetexceptflag
     libc.src.fenv.fesetround
     libc.src.fenv.feraiseexcept
     libc.src.fenv.fetestexcept
     libc.src.fenv.feupdateenv
 
     # math.h entrypoints
-    libc.src.math.atanhf    
+    libc.src.math.atanf
+    libc.src.math.atanhf
     libc.src.math.copysign
     libc.src.math.copysignf
     libc.src.math.copysignl
     libc.src.math.ceil
     libc.src.math.ceilf
     libc.src.math.ceill
     libc.src.math.cos
     libc.src.math.coshf

libc/config/windows/entrypoints.txt

set(TARGET_LIBM_ENTRYPOINTS
     libc.src.fenv.fesetenv
     libc.src.fenv.fesetexceptflag
     libc.src.fenv.fesetround
     libc.src.fenv.feraiseexcept
     libc.src.fenv.fetestexcept
     libc.src.fenv.feupdateenv
 
     # math.h entrypoints
-    libc.src.math.atanh
+    libc.src.math.atanf    
+    libc.src.math.atanhf
     libc.src.math.copysign
     libc.src.math.copysignf
     libc.src.math.copysignl
     libc.src.math.ceil
     libc.src.math.ceilf
     libc.src.math.ceill
     libc.src.math.cos
     libc.src.math.cosf

libc/spec/stdc.td

HeaderSpec Math = HeaderSpec<
           FunctionSpec<"nextafterf", RetValSpec<FloatType>, [ArgSpec<FloatType>, ArgSpec<FloatType>]>,
           FunctionSpec<"nextafter", RetValSpec<DoubleType>, [ArgSpec<DoubleType>, ArgSpec<DoubleType>]>,
           FunctionSpec<"nextafterl", RetValSpec<LongDoubleType>, [ArgSpec<LongDoubleType>, ArgSpec<LongDoubleType>]>,
 
           FunctionSpec<"coshf", RetValSpec<FloatType>, [ArgSpec<FloatType>]>,
           FunctionSpec<"sinhf", RetValSpec<FloatType>, [ArgSpec<FloatType>]>,
           FunctionSpec<"tanhf", RetValSpec<FloatType>, [ArgSpec<FloatType>]>,
           
-          FunctionSpec<"atanhf", RetValSpec<FloatType>, [ArgSpec<FloatType>]>,          
+          FunctionSpec<"atanf", RetValSpec<FloatType>, [ArgSpec<FloatType>]>,
+          
+          FunctionSpec<"atanhf", RetValSpec<FloatType>, [ArgSpec<FloatType>]>,
       ]
   >;
 
   HeaderSpec StdIO = HeaderSpec<
       "stdio.h",
       [
           Macro<"stderr">,
           Macro<"stdout">,

libc/src/__support/FPUtil/FPBits.h

if (likely(ep >= 0)) {
       // Implicit number bit will be removed by mask
       result.set_mantissa(number);
       result.set_unbiased_exponent(ep + 1);
     } else {
       result.set_mantissa(number >> -ep);
     }
     return result;
   }
+
+  inline static FPBits<T> create_value(bool sign, UIntType unbiased_exp,
+                                       UIntType mantissa) {
+    FPBits<T> result;
+    result.set_sign(sign);
+    result.set_unbiased_exponent(unbiased_exp);
+    result.set_mantissa(mantissa);
+    return result;
+  }
 };
 
 } // namespace fputil
 } // namespace __llvm_libc
 
 #ifdef SPECIAL_X86_LONG_DOUBLE
 #include "x86_64/LongDoubleBits.h"
 #endif
 
 #endif // LLVM_LIBC_SRC_SUPPORT_FPUTIL_FP_BITS_H

libc/src/math/CMakeLists.txt

HDRS
     fma.h
   DEPENDS
     libc.src.__support.FPUtil.fputil
     libc.src.__support.FPUtil.fma
   COMPILE_OPTIONS
     -O3
 )
 
+add_math_entrypoint_object(atanf)
 add_math_entrypoint_object(atanhf)
 
 add_math_entrypoint_object(ceil)
 add_math_entrypoint_object(ceilf)
 add_math_entrypoint_object(ceill)
 
 add_math_entrypoint_object(copysign)
 add_math_entrypoint_object(copysignf)

libc/src/math/atanf.h

+//===-- Implementation header for atanf -------------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIBC_SRC_MATH_ATANF_H
+#define LLVM_LIBC_SRC_MATH_ATANF_H
+
+namespace __llvm_libc {
+
+float atanf(float x);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_MATH_ATANF_H

libc/src/math/generic/CMakeLists.txt

DEPENDS
     libc.src.__support.FPUtil.multiply_add
     libc.src.__support.FPUtil.nearest_integer
     libc.src.__support.FPUtil.polyeval
     libc.include.math
   COMPILE_OPTIONS
     -O3
 )
 
+add_entrypoint_object(
+  atanf
+  SRCS
+    atanf.cpp
+  HDRS
+    ../atanf.h
+  DEPENDS
+    .supfuncf
+    libc.src.__support.FPUtil.fputil
+    libc.src.__support.FPUtil.multiply_add
+    libc.src.__support.FPUtil.nearest_integer
+    libc.src.__support.FPUtil.polyeval
+    libc.include.math
+  COMPILE_OPTIONS
+    -O3
+)
+

libc/src/math/generic/atanf.cpp

+//===-- Single-precision atan function ------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "src/math/atanf.h"
+#include "math_utils.h"
+#include "src/__support/FPUtil/FPBits.h"
+#include "src/math/generic/supfuncf.h"
+
+namespace __llvm_libc {
+
+LLVM_LIBC_FUNCTION(float, atanf, (float x)) {
+  using FPBits = typename fputil::FPBits<float>;
+  FPBits xbits(x);
+  bool sign = xbits.get_sign();
+  xbits.set_sign(false);
+
+  if (unlikely(xbits.is_inf_or_nan())) {
+    if (xbits.is_inf())
+      return opt_barrier(sign ? -M_PI_2 : M_PI_2);
+    else
+      return x + 1.0f;
+  }
+
+  if (unlikely(xbits.uintval() == 0x3d8d6b23U)) {
+    if (fputil::get_round() == FE_TONEAREST) {
+      FPBits br(0x3d8d31c3U);
+      br.set_sign(sign);
+      return br.get_val();
+    }
+  }
+
+  if (unlikely(xbits.uintval() == 0x3feefcfbU)) {
+    int rounding_mode = fputil::get_round();
+    if (sign) {
+      if (rounding_mode == FE_DOWNWARD)
+        return FPBits(0xbf8a1f63U).get_val();
+    } else {
+      if (rounding_mode == FE_UPWARD)
+        return FPBits(0x3f8a1f63U).get_val();
+    }
+  }
+
+  return atan_eval(x);
+}
+
+} // namespace __llvm_libc

libc/src/math/generic/supfuncf.h

struct exe_eval_result_t {
   // where
   //   MULT_POWER2 template parameter;
   //   mult_exp = 2^e;
   //   r in range [~-0.3, ~0.41]
   double mult_exp;
   double r;
 };
 
+// atan table size
+constexpr int ATAN_T_BITS = 4;
+constexpr int ATAN_T_SIZE = 1 << ATAN_T_BITS;
+
+// N[Table[ArcTan[x], {x, 1/8, 8/8, 1/8}], 40]
+extern const double ATAN_T[ATAN_T_SIZE];
+extern const double ATAN_K[5];
+
 // The function correctly calculates exp value with at least float precision
 // in range not narrow than [-log(2^-150), 90]
 template <int MULT_POWER2 = 0>
 inline static exe_eval_result_t exp_eval(double x) {
   double ps_dbl = fputil::nearest_integer(LN2_INV * x);
   // Negative sign due to multiply_add optimization
   double mult_e1, ml;
   {
inline static double log2_eval(double x) {
   return result;
 }
 
 // x should be positive, normal finite value
 inline static double log_eval(double x) {
   return log2_eval(x) * 0x1.62e42fefa39efp-1;
 }
 
+// The main idea of the function is to use formula
+// atan(u) + atan(v) = atan((u+v)/(1-uv))
+
+// x should be positive, normal finite value
+inline static double atan_eval(double x) {
+  using FPB = fputil::FPBits<double>;
+  // Added some small value to umin and umax mantissa to avoid possible rounding
+  // errors.
+  FPB::UIntType umin =
+      FPB::create_value(false, FPB::EXPONENT_BIAS - ATAN_T_BITS - 1,
+                        0x100000000000UL)
+          .uintval();
+  FPB::UIntType umax =
+      FPB::create_value(false, FPB::EXPONENT_BIAS + ATAN_T_BITS,
+                        0xF000000000000UL)
+          .uintval();
+
+  FPB bs(x);
+  bool sign = bs.get_sign();
+  auto x_abs = bs.uintval() & FPB::FloatProp::EXP_MANT_MASK;
+
+  if (x_abs <= umin) {
+    double pe = __llvm_libc::fputil::polyeval(x * x, 0.0, ATAN_K[1], ATAN_K[2],
+                                              ATAN_K[3], ATAN_K[4]);
+    return fputil::multiply_add(pe, x, x);
+  }
+
+  if (x_abs >= umax) {
+    double one_over_x_m = -1.0 / x;
+    double one_over_x2 = one_over_x_m * one_over_x_m;
+    double pe = __llvm_libc::fputil::polyeval(one_over_x2, ATAN_K[0], ATAN_K[1],
+                                              ATAN_K[2], ATAN_K[3]);
+    return fputil::multiply_add(pe, one_over_x_m, sign ? (-M_PI_2) : (M_PI_2));
+  }
+
+  double pos_x = FPB(x_abs).get_val();
+  bool one_over_x = pos_x > 1.0;
+  if (one_over_x) {
+    pos_x = 1.0 / pos_x;
+  }
+
+  double near_x = fputil::nearest_integer(pos_x * ATAN_T_SIZE);
+  int val = static_cast<int>(near_x);
+  near_x *= 1.0 / ATAN_T_SIZE;
+
+  double v = (pos_x - near_x) / fputil::multiply_add(near_x, pos_x, 1.0);
+  double v2 = v * v;
+  double pe = __llvm_libc::fputil::polyeval(v2, ATAN_K[0], ATAN_K[1], ATAN_K[2],
+                                            ATAN_K[3], ATAN_K[4]);
+  double result;
+  if (one_over_x)
+    result = M_PI_2 - fputil::multiply_add(pe, v, ATAN_T[val - 1]);
+  else
+    result = fputil::multiply_add(pe, v, ATAN_T[val - 1]);
+  return sign ? -result : result;
+}
+
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_MATH_GENERIC_EXPLOGXF_H

libc/src/math/generic/supfuncf.cpp

 alignas(64) const
     double K_LOG2_ODD[4] = {0x1.ec709dc3a03fdp-2, 0x1.2776c50ef9bfep-2,
                             0x1.a61762a7aded9p-3, 0x1.484b13d7c02a9p-3};
 
 alignas(64) const
     double K_LOG2_EVEN[4] = {-0x1.71547652b82fep-1, -0x1.71547652b82fep-2,
                              -0x1.ec709dc3a03fdp-3, -0x1.2776c50ef9bfep-3};
 
+// N[Table[ArcTan[x], {x, 1/16, 16/16, 1/16}], 40]
+alignas(64) const double ATAN_T[ATAN_T_SIZE] = {
+    0x1.ff55bb72cfdeap-5, 0x1.fd5ba9aac2f6ep-4, 0x1.7b97b4bce5b02p-3,
+    0x1.f5b75f92c80ddp-3, 0x1.362773707ebccp-2, 0x1.6f61941e4def1p-2,
+    0x1.a64eec3cc23fdp-2, 0x1.dac670561bb4fp-2, 0x1.0657e94db30d0p-1,
+    0x1.1e00babdefeb4p-1, 0x1.345f01cce37bbp-1, 0x1.4978fa3269ee1p-1,
+    0x1.5d58987169b18p-1, 0x1.700a7c5784634p-1, 0x1.819d0b7158a4dp-1,
+    0x1.921fb54442d18p-1};
+
+// for(int i = 0; i < 5; i++)
+//     printf("%.13a,\n", (-2 * (i % 2) + 1) * 1.0 / (2 * i + 1));
+alignas(64) const double ATAN_K[5] = {
+    0x1.0000000000000p+0, -0x1.5555555555555p-2, 0x1.999999999999ap-3,
+    -0x1.2492492492492p-3, 0x1.c71c71c71c71cp-4};
+
 } // namespace __llvm_libc

libc/test/src/math/CMakeLists.txt

SUITE
     libc_math_unittests
   SRCS
     atanhf_test.cpp
   DEPENDS
     libc.src.math.atanhf
     libc.src.__support.FPUtil.fputil
 )
 
+add_fp_unittest(
+  atanf_test
+  NEED_MPFR
+  SUITE
+    libc_math_unittests
+  SRCS
+    atanf_test.cpp
+  DEPENDS
+    libc.src.math.atanf
+    libc.src.__support.FPUtil.fputil
+)
+
 add_subdirectory(generic)
 add_subdirectory(exhaustive)
 add_subdirectory(differential_testing)

libc/test/src/math/atanf_test.cpp

+//===-- Unittests for atanf -----------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "src/__support/FPUtil/FPBits.h"
+#include "src/math/atanf.h"
+#include "utils/MPFRWrapper/MPFRUtils.h"
+#include "utils/UnitTest/FPMatcher.h"
+#include "utils/UnitTest/Test.h"
+#include <math.h>
+
+#include <errno.h>
+#include <stdint.h>
+
+#include <initializer_list>
+
+using FPBits = __llvm_libc::fputil::FPBits<float>;
+
+namespace mpfr = __llvm_libc::testing::mpfr;
+
+DECLARE_SPECIAL_CONSTANTS(float)
+
+TEST(LlvmLibcAtanfTest, SpecialNumbers) {
+  errno = 0;
+  __llvm_libc::fputil::clear_except(FE_ALL_EXCEPT);
+  EXPECT_FP_EQ(aNaN, __llvm_libc::atanf(aNaN));
+  EXPECT_FP_EXCEPTION(FE_INVALID);
+  EXPECT_MATH_ERRNO(0);
+
+  __llvm_libc::fputil::clear_except(FE_ALL_EXCEPT);
+  EXPECT_FP_EQ(0.0f, __llvm_libc::atanf(0.0f));
+  EXPECT_FP_EXCEPTION(0);
+  EXPECT_MATH_ERRNO(0);
+
+  __llvm_libc::fputil::clear_except(FE_ALL_EXCEPT);
+  EXPECT_FP_EQ(-0.0f, __llvm_libc::atanf(-0.0f));
+  EXPECT_FP_EXCEPTION(0);
+  EXPECT_MATH_ERRNO(0);
+}
+
+TEST(LlvmLibcAtanfTest, InFloatRange) {
+  constexpr uint32_t COUNT = 1000000;
+  const uint32_t STEP = FPBits(inf).uintval() / COUNT;
+  for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
+    float x = float(FPBits(v));
+    EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Atan, x,
+                                   __llvm_libc::atanf(x), 0.5);
+    EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Atan, -x,
+                                   __llvm_libc::atanf(-x), 0.5);
+  }
+}
+
+// For small values, tanh(x) is x.
+TEST(LlvmLibcAtanfTest, SpecialValues) {
+  for (uint32_t v : {0x3d8d6b23U, 0x3feefcfbU, 0xbd8d6b23U, 0xbfeefcfbU,
+                     0x7F800000U, 0xFF800000U}) {
+    float x = float(FPBits(v));
+    EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Atan, x,
+                                   __llvm_libc::atanf(x), 0.5);
+  }
+}

libc/test/src/math/exhaustive/CMakeLists.txt

add_fp_unittest(
   DEPENDS
     .exhaustive_test
     libc.include.math
     libc.src.math.atanhf
     libc.src.__support.FPUtil.fputil
   LINK_LIBRARIES
     -lpthread
 )
+
+add_fp_unittest(
+  atanf_test
+  NO_RUN_POSTBUILD
+  NEED_MPFR
+  SUITE
+    libc_math_exhaustive_tests
+  SRCS
+    atanf_test.cpp
+  DEPENDS
+    .exhaustive_test
+    libc.include.math
+    libc.src.math.atanf
+    libc.src.__support.FPUtil.fputil
+  LINK_LIBRARIES
+    -lpthread
+)
+

libc/test/src/math/exhaustive/atanf_test.cpp

+//===-- Exhaustive test for atanf -----------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "exhaustive_test.h"
+#include "src/__support/FPUtil/FPBits.h"
+#include "src/math/atanf.h"
+#include "utils/MPFRWrapper/MPFRUtils.h"
+
+#include <thread>
+
+using FPBits = __llvm_libc::fputil::FPBits<float>;
+
+namespace mpfr = __llvm_libc::testing::mpfr;
+
+struct LlvmLibcAtanfExhaustiveTest : public LlvmLibcExhaustiveTest<uint32_t> {
+  bool check(uint32_t start, uint32_t stop,
+             mpfr::RoundingMode rounding) override {
+    mpfr::ForceRoundingMode r(rounding);
+    uint32_t bits = start;
+    bool result = true;
+    do {
+      FPBits xbits(bits);
+      float x = float(xbits);
+      result &= EXPECT_MPFR_MATCH(mpfr::Operation::Atan, x,
+                                  __llvm_libc::atanf(x), 0.5, rounding);
+    } while (bits++ < stop);
+    return result;
+  }
+};
+
+static const int NUM_THREADS = std::thread::hardware_concurrency();
+
+// Range: [0, 1.0];
+static const uint32_t POS_START = 0x0000'0000U;
+static const uint32_t POS_STOP = FPBits::inf().uintval();
+
+TEST_F(LlvmLibcAtanfExhaustiveTest, PostiveRangeRoundNearestTieToEven) {
+  test_full_range(POS_START, POS_STOP, mpfr::RoundingMode::Nearest);
+}
+
+TEST_F(LlvmLibcAtanfExhaustiveTest, PostiveRangeRoundUp) {
+  test_full_range(POS_START, POS_STOP, mpfr::RoundingMode::Upward);
+}
+
+TEST_F(LlvmLibcAtanfExhaustiveTest, PostiveRangeRoundDown) {
+  test_full_range(POS_START, POS_STOP, mpfr::RoundingMode::Downward);
+}
+
+TEST_F(LlvmLibcAtanfExhaustiveTest, PostiveRangeRoundTowardZero) {
+  test_full_range(POS_START, POS_STOP, mpfr::RoundingMode::TowardZero);
+}
+
+// Range: [-1.0, 0];
+static const uint32_t NEG_START = 0x8000'0000U;
+static const uint32_t NEG_STOP = FPBits::neg_inf().uintval();
+
+TEST_F(LlvmLibcAtanfExhaustiveTest, NegativeRangeRoundNearestTieToEven) {
+  test_full_range(NEG_START, NEG_STOP, mpfr::RoundingMode::Nearest);
+}
+
+TEST_F(LlvmLibcAtanfExhaustiveTest, NegativeRangeRoundUp) {
+  test_full_range(NEG_START, NEG_STOP, mpfr::RoundingMode::Upward);
+}
+
+TEST_F(LlvmLibcAtanfExhaustiveTest, NegativeRangeRoundDown) {
+  test_full_range(NEG_START, NEG_STOP, mpfr::RoundingMode::Downward);
+}
+
+TEST_F(LlvmLibcAtanfExhaustiveTest, NegativeRangeRoundTowardZero) {
+  test_full_range(NEG_START, NEG_STOP, mpfr::RoundingMode::TowardZero);
+}

libc/test/src/math/supfuncf_test.cpp

#define CHECK_DATA(start, stop, mfp_op, f, f_check, count, prec)               \
   {                                                                            \
     uint64_t ustart = FPBits(start).uintval();                                 \
     uint64_t ustop = FPBits(stop).uintval();                                   \
     for (uint64_t i = 0;; ++i) {                                               \
       uint64_t v = ustart + (ustop - ustart) * i / count;                      \
       if (v > ustop)                                                           \
         break;                                                                 \
       float x = FPBits(uint32_t(v)).get_val();                                 \
-      if ((f_check)(x))                                                        \
+      if ((f_check)(x)) {                                                      \
         EXPECT_MPFR_MATCH_ALL_ROUNDING(mfp_op, x, static_cast<float>((f)(x)),  \
                                        (prec));                                \
-    }                                                                          \
+      }                                                                        \
+    }                                                                          \
   }
 
 TEST(LlvmLibcExpxfTest, InFloatRange) {
   auto fx = [](float x) -> float {
     auto result = __llvm_libc::exp_eval<-1>(x);
     return static_cast<float>(2 * result.mult_exp * result.r +
                               2 * result.mult_exp);
   };
TEST(LlvmLibcLog2xfTest, InFloatRange) {
   CHECK_DATA(0.0f, inf, mpfr::Operation::Log2, __llvm_libc::log2_eval, isnormal,
              def_count, def_prec);
 }
 
 TEST(LlvmLibcLogxfTest, InFloatRange) {
   CHECK_DATA(0.0f, inf, mpfr::Operation::Log, __llvm_libc::log_eval, isnormal,
              def_count, def_prec);
 }
+
+TEST(LlvmLibcAtanfPosTest, InFloatRange) {
+  CHECK_DATA(0.0f, inf, mpfr::Operation::Atan, __llvm_libc::atan_eval, isfinite,
+             def_count, def_prec);
+}
+
+TEST(LlvmLibcAtanfNegTest, InFloatRange) {
+  CHECK_DATA(-0.0f, neg_inf, mpfr::Operation::Atan, __llvm_libc::atan_eval,
+             isfinite, def_count, def_prec);
+}

libc/utils/MPFRWrapper/MPFRUtils.h

 namespace mpfr {
 
 enum class Operation : int {
   // Operations with take a single floating point number as input
   // and produce a single floating point number as output. The input
   // and output floating point numbers are of the same kind.
   BeginUnaryOperationsSingleOutput,
   Abs,
+  Atan,
   Atanh,
   Ceil,
   Cos,
   Cosh,
   Exp,
   Exp2,
   Expm1,
   Floor,

libc/utils/MPFRWrapper/MPFRUtils.cpp

public:
   }
 
   MPFRNumber abs() const {
     MPFRNumber result(*this);
     mpfr_abs(result.value, value, mpfr_rounding);
     return result;
   }
 
+  MPFRNumber atan() const {
+    MPFRNumber result(*this);
+    mpfr_atan(result.value, value, mpfr_rounding);
+    return result;
+  }
+
   MPFRNumber atanh() const {
     MPFRNumber result(*this);
     mpfr_atanh(result.value, value, mpfr_rounding);
     return result;
   }
 
   MPFRNumber ceil() const {
     MPFRNumber result(*this);

 template <typename InputType>
 cpp::enable_if_t<cpp::is_floating_point_v<InputType>, MPFRNumber>
 unary_operation(Operation op, InputType input, unsigned int precision,
                 RoundingMode rounding) {
   MPFRNumber mpfrInput(input, precision, rounding);
   switch (op) {
   case Operation::Abs:
     return mpfrInput.abs();
+  case Operation::Atan:
+    return mpfrInput.atan();
   case Operation::Atanh:
     return mpfrInput.atanh();
   case Operation::Ceil:
     return mpfrInput.ceil();
   case Operation::Cos:
     return mpfrInput.cos();
   case Operation::Cosh:
     return mpfrInput.cosh();