- Created exhaustive test for rsqrt in libc/test/src/math/exhaustive/

- Created unit test template for rsqrt functions that can be called in the future by other precision functions
- Changed range of values for unit-test to match the libc/test/src/math/SqrtTest.h
- Changed the comments in rsqrtf.h, removed unnecessary code in the comments

Author: amemov

libc/src/__support/math/rsqrtf.h

@@ -58,20 +58,10 @@ LIBC_INLINE static constexpr float rsqrtf(float x) {
     return FPBits::zero().get_val();
   }
 
-  // TODO: add integer based implementation when LIBC_TARGET_CPU_HAS_FPU_FLOAT
-  // is not defined
+  // TODO: add float based approximation when
+  // LIBC_TARGET_CPU_HAS_FPU_DOUBLE is not defined
   double result = 1.0f / fputil::sqrt<double>(fputil::cast<double>(x));
 
-  // Targeted post-corrections to ensure correct rounding in half for specific
-  // mantissa patterns
-  /*
-  const uint32_t half_mantissa = x_abs & 0x3ff;
-  if (LIBC_UNLIKELY(half_mantissa == 0x011F)) {
-    result = fputil::multiply_add(result, 0x1.0p-21f, result);
-  } else if (LIBC_UNLIKELY(half_mantissa == 0x0313)) {
-    result = fputil::multiply_add(result, -0x1.0p-21f, result);
-  }*/
-
   return fputil::cast<float>(result);
 }
 

libc/test/src/math/RsqrtTest.h

@@ -0,0 +1,74 @@
+//===-- Utility class to test rsqrt -----------------------------*- 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_TEST_SRC_MATH_RSQRTTEST_H
+#define LLVM_LIBC_TEST_SRC_MATH_RSQRTTEST_H
+
+#include "test/UnitTest/FEnvSafeTest.h"
+#include "test/UnitTest/FPMatcher.h"
+#include "test/UnitTest/Test.h"
+#include "utils/MPFRWrapper/MPFRUtils.h"
+
+namespace mpfr = LIBC_NAMESPACE::testing::mpfr;
+
+template <typename OutType, typename InType = OutType>
+class RsqrtTest : public LIBC_NAMESPACE::testing::FEnvSafeTest {
+
+  DECLARE_SPECIAL_CONSTANTS(InType)
+
+  static constexpr StorageType HIDDEN_BIT =
+      StorageType(1) << LIBC_NAMESPACE::fputil::FPBits<InType>::FRACTION_LEN;
+
+public:
+  using RsqrtFunc = OutType (*)(InType);
+
+  // Subnormal inputs: probe both power-of-two mantissas and an even sampling
+  // across the subnormal range.
+  void test_denormal_values(RsqrtFunc func) {
+    // Powers of two in the subnormal mantissa space.
+    for (StorageType mant = 1; mant < HIDDEN_BIT; mant <<= 1) {
+      FPBits denormal(zero);
+      denormal.set_mantissa(mant);
+      InType x = denormal.get_val();
+      ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Rsqrt, x, func(x), 0.5);
+    }
+
+    // Even sampling across all subnormals.
+    constexpr StorageType COUNT = 200'001;
+    constexpr StorageType STEP = HIDDEN_BIT / COUNT;
+    for (StorageType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
+      InType x = FPBits(i).get_val();
+      ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Rsqrt, x, func(x), 0.5);
+    }
+  }
+
+  // Positive normal range sampling: skip NaNs and negative values.
+  void test_normal_range(RsqrtFunc func) {
+    constexpr StorageType COUNT = 200'001;
+    constexpr StorageType STEP = STORAGE_MAX / COUNT;
+    for (StorageType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
+      FPBits x_bits(v);
+      InType x = x_bits.get_val();
+      if (x_bits.is_nan() || (x < static_cast<InType>(0)))
+        continue;
+      ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Rsqrt, x, func(x), 0.5);
+    }
+  }
+};
+
+#define LIST_RSQRT_TESTS(T, func)                                              \
+  using LlvmLibcRsqrtTest = RsqrtTest<T, T>;                                   \
+  TEST_F(LlvmLibcRsqrtTest, DenormalValues) { test_denormal_values(&func); }   \
+  TEST_F(LlvmLibcRsqrtTest, NormalRange) { test_normal_range(&func); }
+
+#define LIST_NARROWING_RSQRT_TESTS(OutType, InType, func)                      \
+  using LlvmLibcRsqrtTest = RsqrtTest<OutType, InType>;                        \
+  TEST_F(LlvmLibcRsqrtTest, DenormalValues) { test_denormal_values(&func); }   \
+  TEST_F(LlvmLibcRsqrtTest, NormalRange) { test_normal_range(&func); }
+
+#endif // LLVM_LIBC_TEST_SRC_MATH_RSQRTTEST_H

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

@@ -26,6 +26,22 @@ add_fp_unittest(
     -lpthread
 )
 
+add_fp_unittest(
+  rsqrtf_test
+  NO_RUN_POSTBUILD
+  NEED_MPFR
+  SUITE
+    libc_math_exhaustive_tests
+  SRCS
+    rsqrtf_test.cpp
+  DEPENDS
+    .exhaustive_test
+    libc.src.math.rsqrtf
+    libc.src.__support.FPUtil.fp_bits
+  LINK_LIBRARIES
+    -lpthread
+)
+
 add_fp_unittest(
   sinf_test
   NO_RUN_POSTBUILD

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

@@ -0,0 +1,27 @@
+//===-- Exhaustive test for rsqrtf ----------------------------------------===//
+//
+// 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/math/rsqrtf.h"
+#include "utils/MPFRWrapper/MPFRUtils.h"
+
+using LlvmLibcRsqrtfTest = LIBC_NAMESPACE::testing::FPTest<float>;
+
+using LlvmLibcRsqrtfExhaustiveTest =
+    LlvmLibcUnaryOpExhaustiveMathTest<float, mpfr::Operation::Rsqrt,
+                                      LIBC_NAMESPACE::rsqrtf>;
+
+namespace mpfr = LIBC_NAMESPACE::testing::mpfr;
+
+// Range: [0, Inf]
+static constexpr uint32_t POS_START = 0x0000'0000U;
+static constexpr uint32_t POS_STOP = 0x7f80'0000U;
+
+TEST_F(LlvmLibcRsqrtfExhaustiveTest, PositiveRange) {
+  test_full_range_all_roundings(POS_START, POS_STOP);
+}

libc/test/src/math/rsqrtf_test.cpp

@@ -1,41 +1,12 @@
-//===-- Exhaustive test for rsqrtf ----------------------------------------===//
-//
+//===-- Unittests for rsqrtf ----------------------------------------------===//
 // 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/rsqrtf.h"
-#include "test/UnitTest/FPMatcher.h"
-#include "test/UnitTest/Test.h"
-#include "utils/MPFRWrapper/MPFRUtils.h"
-
-using LlvmLibcRsqrtfTest = LIBC_NAMESPACE::testing::FPTest<float>;
-
-namespace mpfr = LIBC_NAMESPACE::testing::mpfr;
+#include "RsqrtTest.h"
 
-// Range: [0, Inf]
-static constexpr uint32_t POS_START = 0x00000000u;
-static constexpr uint32_t POS_STOP = 0x7F800000u;
-
-// Range: [-Inf, 0)
-// rsqrt(-0.0) is -inf, not the same for mpfr.
-static constexpr uint32_t NEG_START = 0x80000001u;
-static constexpr uint32_t NEG_STOP = 0xFF800000u;
-
-TEST_F(LlvmLibcRsqrtfTest, PositiveRange) {
-  for (uint32_t v = POS_START; v <= POS_STOP; ++v) {
-    float x = FPBits(v).get_val();
-    EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Rsqrt, x,
-                                   LIBC_NAMESPACE::rsqrtf(x), 0.5);
-  }
-}
+#include "src/math/rsqrtf.h"
 
-TEST_F(LlvmLibcRsqrtfTest, NegativeRange) {
-  for (uint32_t v = NEG_START; v <= NEG_STOP; ++v) {
-    float x = FPBits(v).get_val();
-    EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Rsqrt, x,
-                                   LIBC_NAMESPACE::rsqrtf(x), 0.5);
-  }
-}
+LIST_RSQRT_TESTS(float, LIBC_NAMESPACE::rsqrtf)