[libc] Reduce math tests runtime

[gchatelet]

change commit message

libc/test/src/math/CeilTest.h

void testFractions(CeilFunc func) {
     EXPECT_FP_EQ(T(-10.0), func(T(-10.65)));
     EXPECT_FP_EQ(T(1235.0), func(T(1234.38)));
     EXPECT_FP_EQ(T(-1234.0), func(T(-1234.38)));
     EXPECT_FP_EQ(T(1235.0), func(T(1234.96)));
     EXPECT_FP_EQ(T(-1234.0), func(T(-1234.96)));
   }
 
   void testRange(CeilFunc func) {
-    constexpr UIntType COUNT = 10000000;
+    constexpr UIntType COUNT = 100'000;
     constexpr UIntType STEP = UIntType(-1) / COUNT;
     for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
       T x = T(FPBits(v));
       if (isnan(x) || isinf(x))
         continue;
 
       ASSERT_MPFR_MATCH(mpfr::Operation::Ceil, x, func(x), 0.0);
     }

libc/test/src/math/CopySignTest.h

void testSpecialNumbers(CopySignFunc func) {
     EXPECT_FP_EQ(neg_inf, func(inf, -1.0));
     EXPECT_FP_EQ(inf, func(neg_inf, 1.0));
 
     EXPECT_FP_EQ(neg_zero, func(zero, -1.0));
     EXPECT_FP_EQ(zero, func(neg_zero, 1.0));
   }
 
   void testRange(CopySignFunc func) {
-    constexpr UIntType COUNT = 10000000;
+    constexpr UIntType COUNT = 100'000;
     constexpr UIntType STEP = UIntType(-1) / COUNT;
     for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
       T x = T(FPBits(v));
       if (isnan(x) || isinf(x))
         continue;
 
       double res1 = func(x, -x);
       ASSERT_FP_EQ(res1, -x);

libc/test/src/math/FAbsTest.h

void testSpecialNumbers(FabsFunc func) {
     EXPECT_FP_EQ(inf, func(inf));
     EXPECT_FP_EQ(inf, func(neg_inf));
 
     EXPECT_FP_EQ(zero, func(zero));
     EXPECT_FP_EQ(zero, func(neg_zero));
   }
 
   void testRange(FabsFunc func) {
-    constexpr UIntType COUNT = 10000000;
+    constexpr UIntType COUNT = 100'000;
     constexpr UIntType STEP = UIntType(-1) / COUNT;
     for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
       T x = T(FPBits(v));
       if (isnan(x) || isinf(x))
         continue;
       ASSERT_MPFR_MATCH(mpfr::Operation::Abs, x, func(x), 0.0);
     }
   }
 };
 
 #define LIST_FABS_TESTS(T, func)                                               \
   using LlvmLibcFAbsTest = FAbsTest<T>;                                        \
   TEST_F(LlvmLibcFAbsTest, SpecialNumbers) { testSpecialNumbers(&func); }      \
   TEST_F(LlvmLibcFAbsTest, Range) { testRange(&func); }

libc/test/src/math/FDimTest.h

public:
   void test_both_zero(FuncPtr func) {
     EXPECT_FP_EQ(zero, func(zero, zero));
     EXPECT_FP_EQ(zero, func(zero, neg_zero));
     EXPECT_FP_EQ(zero, func(neg_zero, zero));
     EXPECT_FP_EQ(zero, func(neg_zero, neg_zero));
   }
 
   void test_in_range(FuncPtr func) {
-    constexpr UIntType COUNT = 10000001;
+    constexpr UIntType COUNT = 100'001;
     constexpr UIntType STEP = UIntType(-1) / COUNT;
     for (UIntType i = 0, v = 0, w = UIntType(-1); i <= COUNT;
          ++i, v += STEP, w -= STEP) {
       T x = T(FPBits(v)), y = T(FPBits(w));
       if (isnan(x) || isinf(x))
         continue;
       if (isnan(y) || isinf(y))
         continue;

libc/test/src/math/FMaxTest.h

public:
   void testBothZero(FMaxFunc func) {
     EXPECT_FP_EQ(0.0, func(0.0, 0.0));
     EXPECT_FP_EQ(0.0, func(-0.0, 0.0));
     EXPECT_FP_EQ(0.0, func(0.0, -0.0));
     EXPECT_FP_EQ(-0.0, func(-0.0, -0.0));
   }
 
   void testRange(FMaxFunc func) {
-    constexpr UIntType COUNT = 10000001;
+    constexpr UIntType COUNT = 100'001;
     constexpr UIntType STEP = UIntType(-1) / COUNT;
     for (UIntType i = 0, v = 0, w = UIntType(-1); i <= COUNT;
          ++i, v += STEP, w -= STEP) {
       T x = T(FPBits(v)), y = T(FPBits(w));
       if (isnan(x) || isinf(x))
         continue;
       if (isnan(y) || isinf(y))
         continue;

libc/test/src/math/FMinTest.h

public:
   void testBothZero(FMinFunc func) {
     EXPECT_FP_EQ(0.0, func(0.0, 0.0));
     EXPECT_FP_EQ(-0.0, func(-0.0, 0.0));
     EXPECT_FP_EQ(-0.0, func(0.0, -0.0));
     EXPECT_FP_EQ(-0.0, func(-0.0, -0.0));
   }
 
   void testRange(FMinFunc func) {
-    constexpr UIntType COUNT = 10000001;
+    constexpr UIntType COUNT = 100'001;
     constexpr UIntType STEP = UIntType(-1) / COUNT;
     for (UIntType i = 0, v = 0, w = UIntType(-1); i <= COUNT;
          ++i, v += STEP, w -= STEP) {
       T x = T(FPBits(v)), y = T(FPBits(w));
       if (isnan(x) || isinf(x))
         continue;
       if (isnan(y) || isinf(y))
         continue;

libc/test/src/math/FloorTest.h

void testFractions(FloorFunc func) {
     EXPECT_FP_EQ(T(-11.0), func(T(-10.65)));
     EXPECT_FP_EQ(T(1234.0), func(T(1234.38)));
     EXPECT_FP_EQ(T(-1235.0), func(T(-1234.38)));
     EXPECT_FP_EQ(T(1234.0), func(T(1234.96)));
     EXPECT_FP_EQ(T(-1235.0), func(T(-1234.96)));
   }
 
   void testRange(FloorFunc func) {
-    constexpr UIntType COUNT = 10000000;
+    constexpr UIntType COUNT = 100'000;
     constexpr UIntType STEP = UIntType(-1) / COUNT;
     for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
       T x = T(FPBits(v));
       if (isnan(x) || isinf(x))
         continue;
 
       ASSERT_MPFR_MATCH(mpfr::Operation::Floor, x, func(x), 0.0);
     }

libc/test/src/math/FrexpTest.h

void testSomeIntegers(FrexpFunc func) {
     EXPECT_FP_EQ(T(0.78125), func(T(800.0), &exponent));
     EXPECT_EQ(exponent, 10);
     EXPECT_FP_EQ(T(-0.78125), func(T(-800.0), &exponent));
     EXPECT_EQ(exponent, 10);
   }
 
   void testRange(FrexpFunc func) {
     using UIntType = typename FPBits::UIntType;
-    constexpr UIntType COUNT = 10000000;
+    constexpr UIntType COUNT = 100'000;
     constexpr UIntType STEP = UIntType(-1) / COUNT;
     for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
       T x = static_cast<T>(FPBits(v));
       if (isnan(x) || isinf(x) || x == 0.0l)
         continue;
 
       mpfr::BinaryOutput<T> result;
       result.f = func(x, &result.i);

libc/test/src/math/ILogbTest.h

 #include "src/__support/FPUtil/ManipulationFunctions.h"
 #include "test/UnitTest/Test.h"
 #include <math.h>
 
 #include <limits.h>
 
 class LlvmLibcILogbTest : public __llvm_libc::testing::Test {
 public:
-  template <typename T> struct ILogbFunc { typedef int (*Func)(T); };
+  template <typename T> struct ILogbFunc {
+    typedef int (*Func)(T);
+  };
 
   template <typename T>
   void test_special_numbers(typename ILogbFunc<T>::Func func) {
     EXPECT_EQ(FP_ILOGB0, func(T(__llvm_libc::fputil::FPBits<T>::zero())));
     EXPECT_EQ(FP_ILOGB0, func(T(__llvm_libc::fputil::FPBits<T>::neg_zero())));
 
     EXPECT_EQ(FP_ILOGBNAN,
               func(T(__llvm_libc::fputil::FPBits<T>::build_quiet_nan(1))));
void test_some_integers(typename ILogbFunc<T>::Func func) {
     EXPECT_EQ(5, func(55.0));
     EXPECT_EQ(5, func(-55.0));
   }
 
   template <typename T>
   void test_subnormal_range(typename ILogbFunc<T>::Func func) {
     using FPBits = __llvm_libc::fputil::FPBits<T>;
     using UIntType = typename FPBits::UIntType;
-    constexpr UIntType COUNT = 1000001;
+    constexpr UIntType COUNT = 10'001;
     constexpr UIntType STEP =
         (FPBits::MAX_SUBNORMAL - FPBits::MIN_SUBNORMAL) / COUNT;
     for (UIntType v = FPBits::MIN_SUBNORMAL; v <= FPBits::MAX_SUBNORMAL;
          v += STEP) {
       T x = T(FPBits(v));
       if (isnan(x) || isinf(x) || x == 0.0)
         continue;
 
       int exponent;
       __llvm_libc::fputil::frexp(x, exponent);
       ASSERT_EQ(exponent, func(x) + 1);
     }
   }
 
   template <typename T>
   void test_normal_range(typename ILogbFunc<T>::Func func) {
     using FPBits = __llvm_libc::fputil::FPBits<T>;
     using UIntType = typename FPBits::UIntType;
-    constexpr UIntType COUNT = 1000001;
+    constexpr UIntType COUNT = 10'001;
     constexpr UIntType STEP = (FPBits::MAX_NORMAL - FPBits::MIN_NORMAL) / COUNT;
     for (UIntType v = FPBits::MIN_NORMAL; v <= FPBits::MAX_NORMAL; v += STEP) {
       T x = T(FPBits(v));
       if (isnan(x) || isinf(x) || x == 0.0)
         continue;
 
       int exponent;
       __llvm_libc::fputil::frexp(x, exponent);
       ASSERT_EQ(exponent, func(x) + 1);
     }
   }
 };
 
 #endif // LLVM_LIBC_TEST_SRC_MATH_ILOGBTEST_H

libc/test/src/math/LogbTest.h

void testSomeIntegers(LogbFunc func) {
     EXPECT_FP_EQ(T(4.0), func(T(-31.0)));
 
     EXPECT_FP_EQ(T(5.0), func(T(55.0)));
     EXPECT_FP_EQ(T(5.0), func(T(-55.0)));
   }
 
   void testRange(LogbFunc func) {
     using UIntType = typename FPBits::UIntType;
-    constexpr UIntType COUNT = 10000000;
+    constexpr UIntType COUNT = 100'000;
     constexpr UIntType STEP = UIntType(-1) / COUNT;
     for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
       T x = static_cast<T>(FPBits(v));
       if (isnan(x) || isinf(x) || x == 0.0l)
         continue;
 
       int exponent;
       __llvm_libc::fputil::frexp(x, exponent);

libc/test/src/math/ModfTest.h

void testFractions(ModfFunc func) {
     EXPECT_FP_EQ(T(0.125), func(T(100.125), &integral));
     EXPECT_FP_EQ(integral, T(100.0));
 
     EXPECT_FP_EQ(T(-0.125), func(T(-100.125), &integral));
     EXPECT_FP_EQ(integral, T(-100.0));
   }
 
   void testRange(ModfFunc func) {
-    constexpr UIntType COUNT = 10000000;
+    constexpr UIntType COUNT = 100'000;
     constexpr UIntType STEP = UIntType(-1) / COUNT;
     for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
       T x = T(FPBits(v));
       if (isnan(x) || isinf(x) || x == T(0.0))
         continue;
 
       T integral;
       T frac = func(x, &integral);

libc/test/src/math/RoundTest.h

void testFractions(RoundFunc func) {
     EXPECT_FP_EQ(T(-11.0), func(T(-10.65)));
     EXPECT_FP_EQ(T(1234.0), func(T(1234.38)));
     EXPECT_FP_EQ(T(-1234.0), func(T(-1234.38)));
     EXPECT_FP_EQ(T(1235.0), func(T(1234.96)));
     EXPECT_FP_EQ(T(-1235.0), func(T(-1234.96)));
   }
 
   void testRange(RoundFunc func) {
-    constexpr UIntType COUNT = 10000000;
+    constexpr UIntType COUNT = 100'000;
     constexpr UIntType STEP = UIntType(-1) / COUNT;
     for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
       T x = T(FPBits(v));
       if (isnan(x) || isinf(x))
         continue;
 
       ASSERT_MPFR_MATCH(mpfr::Operation::Round, x, func(x), 0.0);
     }

libc/test/src/math/TruncTest.h

void testFractions(TruncFunc func) {
     EXPECT_FP_EQ(T(-10.0), func(T(-10.65)));
     EXPECT_FP_EQ(T(1234.0), func(T(1234.38)));
     EXPECT_FP_EQ(T(-1234.0), func(T(-1234.38)));
     EXPECT_FP_EQ(T(1234.0), func(T(1234.96)));
     EXPECT_FP_EQ(T(-1234.0), func(T(-1234.96)));
   }
 
   void testRange(TruncFunc func) {
-    constexpr UIntType COUNT = 10000000;
+    constexpr UIntType COUNT = 100'000;
     constexpr UIntType STEP = UIntType(-1) / COUNT;
     for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
       T x = T(FPBits(v));
       if (isnan(x) || isinf(x))
         continue;
 
       ASSERT_MPFR_MATCH(mpfr::Operation::Trunc, x, func(x), 0.0);
     }

libc/test/src/math/acosf_test.cpp

TEST(LlvmLibcAcosfTest, SpecialNumbers) {
   EXPECT_FP_EQ(aNaN, __llvm_libc::acosf(inf));
   EXPECT_MATH_ERRNO(EDOM);
 
   EXPECT_FP_EQ(aNaN, __llvm_libc::acosf(neg_inf));
   EXPECT_MATH_ERRNO(EDOM);
 }
 
 TEST(LlvmLibcAcosfTest, InFloatRange) {
-  constexpr uint32_t COUNT = 1000000;
+  constexpr uint32_t COUNT = 100'000;
   constexpr uint32_t STEP = UINT32_MAX / COUNT;
   for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
     float x = float(FPBits(v));
     if (isnan(x) || isinf(x))
       continue;
     ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Acos, x,
                                    __llvm_libc::acosf(x), 0.5);
   }

libc/test/src/math/acoshf_test.cpp

TEST(LlvmLibcAcoshfTest, SpecialNumbers) {
   EXPECT_FP_EQ(inf, __llvm_libc::acoshf(inf));
   EXPECT_MATH_ERRNO(0);
 
   EXPECT_FP_EQ(aNaN, __llvm_libc::acoshf(neg_inf));
   EXPECT_MATH_ERRNO(EDOM);
 }
 
 TEST(LlvmLibcAcoshfTest, InFloatRange) {
-  constexpr uint32_t COUNT = 1000000;
+  constexpr uint32_t COUNT = 100'000;
   constexpr uint32_t STEP = UINT32_MAX / COUNT;
   for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
     float x = float(FPBits_t(v));
     if (isnan(x) || isinf(x))
       continue;
     ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Acosh, x,
                                    __llvm_libc::acoshf(x), 0.5);
   }

libc/test/src/math/asinf_test.cpp

TEST(LlvmLibcAsinfTest, SpecialNumbers) {
   EXPECT_FP_EQ(aNaN, __llvm_libc::asinf(inf));
   EXPECT_MATH_ERRNO(EDOM);
 
   EXPECT_FP_EQ(aNaN, __llvm_libc::asinf(neg_inf));
   EXPECT_MATH_ERRNO(EDOM);
 }
 
 TEST(LlvmLibcAsinfTest, InFloatRange) {
-  constexpr uint32_t COUNT = 1000000;
+  constexpr uint32_t COUNT = 100'000;
   constexpr uint32_t STEP = UINT32_MAX / COUNT;
   for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
     float x = float(FPBits(v));
     if (isnan(x) || isinf(x))
       continue;
     ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Asin, x,
                                    __llvm_libc::asinf(x), 0.5);
   }

libc/test/src/math/atanf_test.cpp

TEST(LlvmLibcAtanfTest, SpecialNumbers) {
 
   __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;
+  constexpr uint32_t COUNT = 100'000;
   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);
   }

libc/test/src/math/atanhf_test.cpp

TEST(LlvmLibcAtanhfTest, SpecialNumbers) {
 
   bt.set_sign(true);
   EXPECT_FP_EQ(aNaN, __llvm_libc::atanhf(neg_inf));
   EXPECT_FP_EXCEPTION(FE_INVALID);
   EXPECT_MATH_ERRNO(EDOM);
 }
 
 TEST(LlvmLibcAtanhfTest, InFloatRange) {
-  constexpr uint32_t COUNT = 1000000;
+  constexpr uint32_t COUNT = 100'000;
   const uint32_t STEP = FPBits(1.0f).uintval() / COUNT;
   for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
     float x = float(FPBits(v));
     ASSERT_MPFR_MATCH(mpfr::Operation::Atanh, x, __llvm_libc::atanhf(x), 0.5);
     ASSERT_MPFR_MATCH(mpfr::Operation::Atanh, -x, __llvm_libc::atanhf(-x), 0.5);
   }
 }
 

libc/test/src/math/cos_test.cpp

 #include <math.h>
 
 namespace mpfr = __llvm_libc::testing::mpfr;
 
 DECLARE_SPECIAL_CONSTANTS(double)
 
 TEST(LlvmLibccosTest, Range) {
   static constexpr double _2pi = 6.283185307179586;
-  constexpr UIntType COUNT = 10000000;
+  constexpr UIntType COUNT = 100'000;
   constexpr UIntType STEP = UIntType(-1) / COUNT;
   for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
     double x = double(FPBits(v));
     // TODO: Expand the range of testing after range reduction is implemented.
     if (isnan(x) || isinf(x) || x > _2pi || x < -_2pi)
       continue;
 
     ASSERT_MPFR_MATCH(mpfr::Operation::Cos, x, __llvm_libc::cos(x), 1.0);
   }
 }

libc/test/src/math/cosf_test.cpp

TEST(LlvmLibcCosfTest, SpecialNumbers) {
   EXPECT_FP_EQ(aNaN, __llvm_libc::cosf(inf));
   EXPECT_MATH_ERRNO(EDOM);
 
   EXPECT_FP_EQ(aNaN, __llvm_libc::cosf(neg_inf));
   EXPECT_MATH_ERRNO(EDOM);
 }
 
 TEST(LlvmLibcCosfTest, InFloatRange) {
-  constexpr uint32_t COUNT = 1000000;
+  constexpr uint32_t COUNT = 100'000;
   constexpr uint32_t STEP = UINT32_MAX / COUNT;
   for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
     float x = float(FPBits(v));
     if (isnan(x) || isinf(x))
       continue;
     ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Cos, x,
                                    __llvm_libc::cosf(x), 0.5);
   }

libc/test/src/math/coshf_test.cpp

TEST(LlvmLibcCoshfTest, Overflow) {
   EXPECT_MATH_ERRNO(ERANGE);
 
   EXPECT_FP_EQ_WITH_EXCEPTION(
       inf, __llvm_libc::coshf(float(FPBits(0x42d00008U))), FE_OVERFLOW);
   EXPECT_MATH_ERRNO(ERANGE);
 }
 
 TEST(LlvmLibcCoshfTest, InFloatRange) {
-  constexpr uint32_t COUNT = 1000000;
+  constexpr uint32_t COUNT = 100'000;
   constexpr uint32_t STEP = UINT32_MAX / COUNT;
   for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
     float x = float(FPBits(v));
     if (isnan(x) || isinf(x))
       continue;
     ASSERT_MPFR_MATCH(mpfr::Operation::Cosh, x, __llvm_libc::coshf(x), 0.5);
   }
 }

libc/test/src/math/exp10f_test.cpp

for (int i = 0; i < N; ++i) {
     EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp10, x,
                                    __llvm_libc::exp10f(x), 0.5);
     EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp10, -x,
                                    __llvm_libc::exp10f(-x), 0.5);
   }
 }
 
 TEST(LlvmLibcExp10fTest, InFloatRange) {
-  constexpr uint32_t COUNT = 1000000;
+  constexpr uint32_t COUNT = 100'000;
   constexpr uint32_t STEP = UINT32_MAX / COUNT;
   for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
     float x = float(FPBits(v));
     if (isnan(x) || isinf(x))
       continue;
     libc_errno = 0;
     float result = __llvm_libc::exp10f(x);
 

libc/test/src/math/exp2f_test.cpp

TEST(LlvmLibcExp2fTest, Underflow) {
 
   x = float(FPBits(0xc3165432U));
   EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp2, x,
                                  __llvm_libc::exp2f(x), 0.5);
   EXPECT_MATH_ERRNO(ERANGE);
 }
 
 TEST(LlvmLibcExp2fTest, InFloatRange) {
-  constexpr uint32_t COUNT = 1000000;
+  constexpr uint32_t COUNT = 100'000;
   constexpr uint32_t STEP = UINT32_MAX / COUNT;
   for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
     float x = float(FPBits(v));
     if (isnan(x) || isinf(x))
       continue;
     libc_errno = 0;
     float result = __llvm_libc::exp2f(x);
 

libc/test/src/math/expf_test.cpp

TEST(LlvmLibcExpfTest, Borderline) {
 
   x = float(FPBits(0xc236bd8cU));
   EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Exp, x, __llvm_libc::expf(x),
                                  0.5);
   EXPECT_MATH_ERRNO(0);
 }
 
 TEST(LlvmLibcExpfTest, InFloatRange) {
-  constexpr uint32_t COUNT = 1000000;
+  constexpr uint32_t COUNT = 100'000;
   constexpr uint32_t STEP = UINT32_MAX / COUNT;
   for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
     float x = float(FPBits(v));
     if (isnan(x) || isinf(x))
       continue;
     libc_errno = 0;
     float result = __llvm_libc::expf(x);
 

libc/test/src/math/expm1f_test.cpp

TEST(LlvmLibcExpm1fTest, Borderline) {
 
   x = float(FPBits(0xbdc1c6cbU));
   ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Expm1, x,
                                  __llvm_libc::expm1f(x), 0.5);
   EXPECT_MATH_ERRNO(0);
 }
 
 TEST(LlvmLibcExpm1fTest, InFloatRange) {
-  constexpr uint32_t COUNT = 1000000;
+  constexpr uint32_t COUNT = 100'000;
   constexpr uint32_t STEP = UINT32_MAX / COUNT;
   for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
     float x = float(FPBits(v));
     if (isnan(x) || isinf(x))
       continue;
     libc_errno = 0;
     float result = __llvm_libc::expm1f(x);
 

libc/test/src/math/log10f_test.cpp

TEST(LlvmLibcLog10fTest, TrickyInputs) {
   for (int i = 0; i < N; ++i) {
     float x = float(FPBits(INPUTS[i]));
     EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Log10, x,
                                    __llvm_libc::log10f(x), 0.5);
   }
 }
 
 TEST(LlvmLibcLog10fTest, InFloatRange) {
-  constexpr uint32_t COUNT = 1000000;
+  constexpr uint32_t COUNT = 100'000;
   constexpr uint32_t STEP = UINT32_MAX / COUNT;
   for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
     float x = float(FPBits(v));
     ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Log10, x,
                                    __llvm_libc::log10f(x), 0.5);
   }
 }

libc/test/src/math/log1pf_test.cpp

TEST(LlvmLibclog1pfTest, TrickyInputs) {
   for (int i = 0; i < N; ++i) {
     float x = float(FPBits(INPUTS[i]));
     EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Log1p, x,
                                    __llvm_libc::log1pf(x), 0.5);
   }
 }
 
 TEST(LlvmLibclog1pfTest, InFloatRange) {
-  constexpr uint32_t COUNT = 1000000;
+  constexpr uint32_t COUNT = 100'000;
   constexpr uint32_t STEP = UINT32_MAX / COUNT;
   for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
     float x = float(FPBits(v));
     if (isnan(x) || isinf(x))
       continue;
     libc_errno = 0;
     ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Log1p, x,
                                    __llvm_libc::log1pf(x), 0.5);
   }
 }

libc/test/src/math/log2f_test.cpp

TEST(LlvmLibcLog2fTest, TrickyInputs) {
   for (int i = 0; i < N; ++i) {
     float x = float(FPBits(INPUTS[i]));
     EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Log2, x,
                                    __llvm_libc::log2f(x), 0.5);
   }
 }
 
 TEST(LlvmLibcLog2fTest, InFloatRange) {
-  constexpr uint32_t COUNT = 1000000;
+  constexpr uint32_t COUNT = 100'000;
   constexpr uint32_t STEP = UINT32_MAX / COUNT;
   for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
     float x = float(FPBits(v));
     if (isnan(x) || isinf(x))
       continue;
     libc_errno = 0;
     float result = __llvm_libc::log2f(x);
     // If the computation resulted in an error or did not produce valid result

libc/test/src/math/logf_test.cpp

TEST(LlvmLibcLogfTest, TrickyInputs) {
   for (int i = 0; i < N; ++i) {
     float x = float(FPBits(INPUTS[i]));
     EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Log, x,
                                    __llvm_libc::logf(x), 0.5);
   }
 }
 
 TEST(LlvmLibcLogfTest, InFloatRange) {
-  constexpr uint32_t COUNT = 1000000;
+  constexpr uint32_t COUNT = 100'000;
   constexpr uint32_t STEP = UINT32_MAX / COUNT;
   for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
     float x = float(FPBits(v));
     if (isnan(x) || isinf(x))
       continue;
     ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Log, x,
                                    __llvm_libc::logf(x), 0.5);
   }
 }

libc/test/src/math/sin_test.cpp

 #include <math.h>
 
 namespace mpfr = __llvm_libc::testing::mpfr;
 
 DECLARE_SPECIAL_CONSTANTS(double)
 
 TEST(LlvmLibcSinTest, Range) {
   static constexpr double _2pi = 6.283185307179586;
-  constexpr UIntType COUNT = 10000000;
+  constexpr UIntType COUNT = 100'000;
   constexpr UIntType STEP = UIntType(-1) / COUNT;
   for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
     double x = double(FPBits(v));
     // TODO: Expand the range of testing after range reduction is implemented.
     if (isnan(x) || isinf(x) || x > _2pi || x < -_2pi)
       continue;
 
     ASSERT_MPFR_MATCH(mpfr::Operation::Sin, x, __llvm_libc::sin(x), 1.0);
   }
 }

libc/test/src/math/sinf_test.cpp

TEST(LlvmLibcSinfTest, SpecialNumbers) {
   EXPECT_FP_EQ(aNaN, __llvm_libc::sinf(inf));
   EXPECT_MATH_ERRNO(EDOM);
 
   EXPECT_FP_EQ(aNaN, __llvm_libc::sinf(neg_inf));
   EXPECT_MATH_ERRNO(EDOM);
 }
 
 TEST(LlvmLibcSinfTest, InFloatRange) {
-  constexpr uint32_t COUNT = 1000000;
+  constexpr uint32_t COUNT = 100'000;
   constexpr uint32_t STEP = UINT32_MAX / COUNT;
   for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
     float x = float(FPBits(v));
     if (isnan(x) || isinf(x))
       continue;
     ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Sin, x,
                                    __llvm_libc::sinf(x), 0.5);
   }

libc/test/src/math/sinhf_test.cpp

TEST(LlvmLibcSinhfTest, SpecialNumbers) {
   EXPECT_FP_EQ(inf, __llvm_libc::sinhf(inf));
   EXPECT_MATH_ERRNO(0);
 
   EXPECT_FP_EQ(neg_inf, __llvm_libc::sinhf(neg_inf));
   EXPECT_MATH_ERRNO(0);
 }
 
 TEST(LlvmLibcSinhfTest, InFloatRange) {
-  constexpr uint32_t COUNT = 1000000;
+  constexpr uint32_t COUNT = 100'000;
   constexpr uint32_t STEP = UINT32_MAX / COUNT;
   for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
     float x = float(FPBits(v));
     if (isnan(x) || isinf(x))
       continue;
     ASSERT_MPFR_MATCH(mpfr::Operation::Sinh, x, __llvm_libc::sinhf(x), 0.5);
   }
 }

libc/test/src/math/tan_test.cpp

 #include <math.h>
 
 namespace mpfr = __llvm_libc::testing::mpfr;
 
 DECLARE_SPECIAL_CONSTANTS(double)
 
 TEST(LlvmLibctanTest, Range) {
   static constexpr double _2pi = 6.283185307179586;
-  constexpr UIntType COUNT = 10000000;
+  constexpr UIntType COUNT = 100'000;
   constexpr UIntType STEP = UIntType(-1) / COUNT;
   for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
     double x = double(FPBits(v));
     // TODO: Expand the range of testing after range reduction is implemented.
     if (isnan(x) || isinf(x) || x > _2pi || x < -_2pi)
       continue;
 
     ASSERT_MPFR_MATCH(mpfr::Operation::Tan, x, __llvm_libc::tan(x), 1.0);
   }
 }

libc/test/src/math/tanf_test.cpp

TEST(LlvmLibcTanfTest, SpecialNumbers) {
   EXPECT_FP_EQ(aNaN, __llvm_libc::tanf(inf));
   EXPECT_MATH_ERRNO(EDOM);
 
   EXPECT_FP_EQ(aNaN, __llvm_libc::tanf(neg_inf));
   EXPECT_MATH_ERRNO(EDOM);
 }
 
 TEST(LlvmLibcTanfTest, InFloatRange) {
-  constexpr uint32_t COUNT = 1000000;
+  constexpr uint32_t COUNT = 100'000;
   constexpr uint32_t STEP = UINT32_MAX / COUNT;
   for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
     float x = float(FPBits(v));
     if (isnan(x) || isinf(x))
       continue;
     ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Tan, x,
                                    __llvm_libc::tanf(x), 0.5);
   }

libc/test/src/math/tanhf_test.cpp

TEST(LlvmLibcTanhfTest, SpecialNumbers) {
   EXPECT_FP_EQ(1.0f, __llvm_libc::tanhf(inf));
   EXPECT_MATH_ERRNO(0);
 
   EXPECT_FP_EQ(-1.0f, __llvm_libc::tanhf(neg_inf));
   EXPECT_MATH_ERRNO(0);
 }
 
 TEST(LlvmLibcTanhfTest, InFloatRange) {
-  constexpr uint32_t COUNT = 1000000;
+  constexpr uint32_t COUNT = 100'000;
   constexpr uint32_t STEP = UINT32_MAX / COUNT;
   for (uint32_t i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
     float x = float(FPBits(v));
     if (isnan(x) || isinf(x))
       continue;
     ASSERT_MPFR_MATCH(mpfr::Operation::Tanh, x, __llvm_libc::tanhf(x), 0.5);
   }
 }

libc/test/utils/FPUtil/x86_long_double_test.cpp

 using FPBits = __llvm_libc::fputil::FPBits<long double>;
 
 TEST(LlvmLibcX86LongDoubleTest, is_nan) {
   // In the nan checks below, we use the macro isnan from math.h to ensure that
   // a number is actually a NaN. The isnan macro resolves to the compiler
   // builtin function. Hence, matching LLVM-libc's notion of NaN with the
   // isnan result ensures that LLVM-libc's behavior matches the compiler's
   // behavior.
+  constexpr uint32_t COUNT = 100'000;
 
   FPBits bits(0.0l);
   bits.set_unbiased_exponent(FPBits::MAX_EXPONENT);
-  for (unsigned int i = 0; i < 1000000; ++i) {
+  for (unsigned int i = 0; i < COUNT; ++i) {
     // If exponent has the max value and the implicit bit is 0,
     // then the number is a NaN for all values of mantissa.
     bits.set_mantissa(i);
     long double nan = bits;
     ASSERT_NE(static_cast<int>(isnan(nan)), 0);
     ASSERT_TRUE(bits.is_nan());
   }
 
   bits.set_implicit_bit(1);
-  for (unsigned int i = 1; i < 1000000; ++i) {
+  for (unsigned int i = 1; i < COUNT; ++i) {
     // If exponent has the max value and the implicit bit is 1,
     // then the number is a NaN for all non-zero values of mantissa.
     // Note the initial value of |i| of 1 to avoid a zero mantissa.
     bits.set_mantissa(i);
     long double nan = bits;
     ASSERT_NE(static_cast<int>(isnan(nan)), 0);
     ASSERT_TRUE(bits.is_nan());
   }
 
   bits.set_unbiased_exponent(1);
   bits.set_implicit_bit(0);
-  for (unsigned int i = 0; i < 1000000; ++i) {
+  for (unsigned int i = 0; i < COUNT; ++i) {
     // If exponent is non-zero and also not max, and the implicit bit is 0,
     // then the number is a NaN for all values of mantissa.
     bits.set_mantissa(i);
     long double nan = bits;
     ASSERT_NE(static_cast<int>(isnan(nan)), 0);
     ASSERT_TRUE(bits.is_nan());
   }
 
   bits.set_unbiased_exponent(1);
   bits.set_implicit_bit(1);
-  for (unsigned int i = 0; i < 1000000; ++i) {
+  for (unsigned int i = 0; i < COUNT; ++i) {
     // If exponent is non-zero and also not max, and the implicit bit is 1,
     // then the number is normal value for all values of mantissa.
     bits.set_mantissa(i);
     long double valid = bits;
     ASSERT_EQ(static_cast<int>(isnan(valid)), 0);
     ASSERT_FALSE(bits.is_nan());
   }
 
   bits.set_unbiased_exponent(0);
   bits.set_implicit_bit(1);
-  for (unsigned int i = 0; i < 1000000; ++i) {
+  for (unsigned int i = 0; i < COUNT; ++i) {
     // If exponent is zero, then the number is a valid but denormal value.
     bits.set_mantissa(i);
     long double valid = bits;
     ASSERT_EQ(static_cast<int>(isnan(valid)), 0);
     ASSERT_FALSE(bits.is_nan());
   }
 
   bits.set_unbiased_exponent(0);
   bits.set_implicit_bit(0);
-  for (unsigned int i = 0; i < 1000000; ++i) {
+  for (unsigned int i = 0; i < COUNT; ++i) {
     // If exponent is zero, then the number is a valid but denormal value.
     bits.set_mantissa(i);
     long double valid = bits;
     ASSERT_EQ(static_cast<int>(isnan(valid)), 0);
     ASSERT_FALSE(bits.is_nan());
   }
 }