[libc] Reduce math tests runtime further

libc/test/src/math/FmaTest.h

void test_special_numbers(Func func) {
     T z = T(FPBits(FPBits::MAX_NORMAL));
     EXPECT_FP_EQ(func(T(1.75), z, -z), T(0.75) * z);
     // Exact cancellation.
     EXPECT_FP_EQ(func(T(3.0), T(5.0), -T(15.0)), T(0.0));
     EXPECT_FP_EQ(func(T(-3.0), T(5.0), T(15.0)), T(0.0));
   }
 
   void test_subnormal_range(Func func) {
-    constexpr UIntType COUNT = 1000001;
+    constexpr UIntType COUNT = 100'001;
     constexpr UIntType STEP =
         (FPBits::MAX_SUBNORMAL - FPBits::MIN_SUBNORMAL) / COUNT;
     for (UIntType v = FPBits::MIN_SUBNORMAL, w = FPBits::MAX_SUBNORMAL;
          v <= FPBits::MAX_SUBNORMAL && w >= FPBits::MIN_SUBNORMAL;
          v += STEP, w -= STEP) {
       T x = T(FPBits(get_random_bit_pattern())), y = T(FPBits(v)),
         z = T(FPBits(w));
       mpfr::TernaryInput<T> input{x, y, z};
       ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Fma, input, func(x, y, z),
                                      0.5);
     }
   }
 
   void test_normal_range(Func func) {
-    constexpr UIntType COUNT = 1000001;
+    constexpr UIntType COUNT = 100'001;
     constexpr UIntType STEP = (FPBits::MAX_NORMAL - FPBits::MIN_NORMAL) / COUNT;
     for (UIntType v = FPBits::MIN_NORMAL, w = FPBits::MAX_NORMAL;
          v <= FPBits::MAX_NORMAL && w >= FPBits::MIN_NORMAL;
          v += STEP, w -= STEP) {
       T x = T(FPBits(v)), y = T(FPBits(w)),
         z = T(FPBits(get_random_bit_pattern()));
       mpfr::TernaryInput<T> input{x, y, z};
       ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Fma, input, func(x, y, z),
                                      0.5);
     }
   }
 };
 
 #endif // LLVM_LIBC_TEST_SRC_MATH_FMATEST_H

libc/test/src/math/HypotTest.h

for (int i = 0; i < N; ++i) {
         EXPECT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Hypot, input,
                                        func(SpecialInputs[i], SpecialInputs[j]),
                                        0.5);
       }
     }
   }
 
   void test_subnormal_range(Func func) {
-    constexpr UIntType COUNT = 100001;
+    constexpr UIntType COUNT = 10'001;
     for (unsigned scale = 0; scale < 4; ++scale) {
       UIntType max_value = FPBits::MAX_SUBNORMAL << scale;
       UIntType step = (max_value - FPBits::MIN_SUBNORMAL) / COUNT;
       for (int signs = 0; signs < 4; ++signs) {
         for (UIntType v = FPBits::MIN_SUBNORMAL, w = max_value;
              v <= max_value && w >= FPBits::MIN_SUBNORMAL;
              v += step, w -= step) {
           T x = T(FPBits(v)), y = T(FPBits(w));
           if (signs % 2 == 1) {
             x = -x;
           }
           if (signs >= 2) {
             y = -y;
           }
 
           mpfr::BinaryInput<T> input{x, y};
           ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Hypot, input,
                                          func(x, y), 0.5);
         }
       }
     }
   }
 
   void test_normal_range(Func func) {
-    constexpr UIntType COUNT = 100001;
+    constexpr UIntType COUNT = 10'001;
     constexpr UIntType STEP = (FPBits::MAX_NORMAL - FPBits::MIN_NORMAL) / COUNT;
     for (int signs = 0; signs < 4; ++signs) {
       for (UIntType v = FPBits::MIN_NORMAL, w = FPBits::MAX_NORMAL;
            v <= FPBits::MAX_NORMAL && w >= FPBits::MIN_NORMAL;
            v += STEP, w -= STEP) {
         T x = T(FPBits(v)), y = T(FPBits(w));
         if (signs % 2 == 1) {
           x = -x;

libc/test/src/math/RIntTest.h

for (int mode : ROUNDING_MODES) {
       ASSERT_FP_EQ(func(T(0.115)), mpfr::round(T(0.115), mpfr_mode));
       ASSERT_FP_EQ(func(T(-0.115)), mpfr::round(T(-0.115), mpfr_mode));
       ASSERT_FP_EQ(func(T(0.715)), mpfr::round(T(0.715), mpfr_mode));
       ASSERT_FP_EQ(func(T(-0.715)), mpfr::round(T(-0.715), mpfr_mode));
     }
   }
 
   void testSubnormalRange(RIntFunc func) {
-    constexpr UIntType COUNT = 1000001;
+    constexpr UIntType COUNT = 100'001;
     constexpr UIntType STEP =
         (FPBits::MAX_SUBNORMAL - FPBits::MIN_SUBNORMAL) / COUNT;
     for (UIntType i = FPBits::MIN_SUBNORMAL; i <= FPBits::MAX_SUBNORMAL;
          i += STEP) {
       T x = T(FPBits(i));
       for (int mode : ROUNDING_MODES) {
         __llvm_libc::fputil::set_round(mode);
         mpfr::RoundingMode mpfr_mode = to_mpfr_rounding_mode(mode);
         ASSERT_FP_EQ(func(x), mpfr::round(x, mpfr_mode));
       }
     }
   }
 
   void testNormalRange(RIntFunc func) {
-    constexpr UIntType COUNT = 1000001;
+    constexpr UIntType COUNT = 100'001;
     constexpr UIntType STEP = (FPBits::MAX_NORMAL - FPBits::MIN_NORMAL) / COUNT;
     for (UIntType i = FPBits::MIN_NORMAL; i <= FPBits::MAX_NORMAL; i += STEP) {
       T x = T(FPBits(i));
       // In normal range on x86 platforms, the long double implicit 1 bit can be
       // zero making the numbers NaN. We will skip them.
       if (isnan(x)) {
         continue;
       }

libc/test/src/math/RemQuoTest.h

void testEqualNumeratorAndDenominator(RemQuoFunc func) {
     EXPECT_FP_EQ(func(-x, y, &q), neg_zero);
     EXPECT_EQ(q, -1);
 
     EXPECT_FP_EQ(func(-x, -y, &q), neg_zero);
     EXPECT_EQ(q, 1);
   }
 
   void testSubnormalRange(RemQuoFunc func) {
-    constexpr UIntType COUNT = 1000001;
+    constexpr UIntType COUNT = 100'001;
     constexpr UIntType STEP =
         (FPBits::MAX_SUBNORMAL - FPBits::MIN_SUBNORMAL) / COUNT;
     for (UIntType v = FPBits::MIN_SUBNORMAL, w = FPBits::MAX_SUBNORMAL;
          v <= FPBits::MAX_SUBNORMAL && w >= FPBits::MIN_SUBNORMAL;
          v += STEP, w -= STEP) {
       T x = T(FPBits(v)), y = T(FPBits(w));
       mpfr::BinaryOutput<T> result;
       mpfr::BinaryInput<T> input{x, y};
       result.f = func(x, y, &result.i);
       ASSERT_MPFR_MATCH(mpfr::Operation::RemQuo, input, result, 0.0);
     }
   }
 
   void testNormalRange(RemQuoFunc func) {
-    constexpr UIntType COUNT = 234561;
+    constexpr UIntType COUNT = 1'001;
     constexpr UIntType STEP = (FPBits::MAX_NORMAL - FPBits::MIN_NORMAL) / COUNT;
     for (UIntType v = FPBits::MIN_NORMAL, w = FPBits::MAX_NORMAL;
          v <= FPBits::MAX_NORMAL && w >= FPBits::MIN_NORMAL;
          v += STEP, w -= STEP) {
       T x = T(FPBits(v)), y = T(FPBits(w));
       mpfr::BinaryOutput<T> result;
       mpfr::BinaryInput<T> input{x, y};
       result.f = func(x, y, &result.i);

libc/test/src/math/RoundToIntegerTest.h

if (TestModes) {
       long mpfr_long_result;
       bool erangeflag = mpfr::round_to_long(x, mpfr_long_result);
       ASSERT_TRUE(erangeflag);
       test_one_input(func, x, INTEGER_MIN, true);
     }
   }
 
   void testSubnormalRange(RoundToIntegerFunc func) {
-    constexpr UIntType COUNT = 1000001;
+    constexpr UIntType COUNT = 1'000'001;
     constexpr UIntType STEP =
         (FPBits::MAX_SUBNORMAL - FPBits::MIN_SUBNORMAL) / COUNT;
     for (UIntType i = FPBits::MIN_SUBNORMAL; i <= FPBits::MAX_SUBNORMAL;
          i += STEP) {
       F x = F(FPBits(i));
       if (x == F(0.0))
         continue;
       // All subnormal numbers should round to zero.
void testNormalRange(RoundToIntegerFunc func) {
     // This function compares with an equivalent MPFR function which rounds
     // floating point numbers to long values. There is no MPFR function to
     // round to long long or wider integer values. So, we will peform the
     // comparisons in this function only if the width of I less than equal to
     // that of long.
     if (sizeof(I) > sizeof(long))
       return;
 
-    constexpr UIntType COUNT = 1000001;
+    constexpr UIntType COUNT = 1'000'001;
     constexpr UIntType STEP = (FPBits::MAX_NORMAL - FPBits::MIN_NORMAL) / COUNT;
     for (UIntType i = FPBits::MIN_NORMAL; i <= FPBits::MAX_NORMAL; i += STEP) {
       F x = F(FPBits(i));
       // In normal range on x86 platforms, the long double implicit 1 bit can be
       // zero making the numbers NaN. We will skip them.
       if (isnan(x)) {
         continue;
       }

libc/test/src/math/SqrtTest.h

public:
   void test_denormal_values(SqrtFunc func) {
     for (UIntType mant = 1; mant < HIDDEN_BIT; mant <<= 1) {
       FPBits denormal(T(0.0));
       denormal.set_mantissa(mant);
 
       test_all_rounding_modes(func, T(denormal));
     }
 
-    constexpr UIntType COUNT = 1'000'001;
+    constexpr UIntType COUNT = 200'001;
     constexpr UIntType STEP = HIDDEN_BIT / COUNT;
     for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
       T x = __llvm_libc::cpp::bit_cast<T>(v);
       test_all_rounding_modes(func, x);
     }
   }
 
   void test_normal_range(SqrtFunc func) {
-    constexpr UIntType COUNT = 1'234'561;
+    constexpr UIntType COUNT = 200'001;
     constexpr UIntType STEP = UIntType(-1) / COUNT;
     for (UIntType i = 0, v = 0; i <= COUNT; ++i, v += STEP) {
       T x = __llvm_libc::cpp::bit_cast<T>(v);
       if (isnan(x) || (x < 0)) {
         continue;
       }
       test_all_rounding_modes(func, x);
     }

libc/test/src/math/asinhf_test.cpp

TEST(LlvmLibcAsinhfTest, SpecialNumbers) {
   EXPECT_FP_EQ(inf, __llvm_libc::asinhf(inf));
   EXPECT_MATH_ERRNO(0);
 
   EXPECT_FP_EQ(neg_inf, __llvm_libc::asinhf(neg_inf));
   EXPECT_MATH_ERRNO(0);
 }
 
 TEST(LlvmLibcAsinhfTest, InFloatRange) {
-  constexpr uint32_t COUNT = 234561;
+  constexpr uint32_t COUNT = 1'001;
   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::Asinh, x,
                                    __llvm_libc::asinhf(x), 0.5);
     ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Asinh, -x,

libc/test/src/math/log10_test.cpp

TEST(LlvmLibcLog10Test, AllExponents) {
   double x = 0x1.0p-1074;
   for (int i = -1074; i < 1024; ++i, x *= 2.0) {
     ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Log10, x,
                                    __llvm_libc::log10(x), 0.5);
   }
 }
 
 TEST(LlvmLibcLog10Test, InDoubleRange) {
-  constexpr uint64_t COUNT = 234561;
+  constexpr uint64_t COUNT = 1'001;
   constexpr uint64_t START = 0x3FD0'0000'0000'0000ULL; // 0.25
   constexpr uint64_t STOP = 0x4010'0000'0000'0000ULL;  // 4.0
   // constexpr uint64_t START = 0x3FF0'0000'0000'0000ULL;  // 1.0
   // constexpr uint64_t STOP = 0x4000'0000'0000'0000ULL;   // 2.0
   constexpr uint64_t STEP = (STOP - START) / COUNT;
 
   auto test = [&](mpfr::RoundingMode rounding_mode) {
     mpfr::ForceRoundingMode __r(rounding_mode);

libc/test/src/math/log1p_test.cpp

TEST(LlvmLibcLog1pTest, AllExponents) {
   double x = 0x1.0p-1074;
   for (int i = -1074; i < 1024; ++i, x *= 2.0) {
     ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Log1p, x,
                                    __llvm_libc::log1p(x), 0.5);
   }
 }
 
 TEST(LlvmLibcLog1pTest, InDoubleRange) {
-  constexpr uint64_t COUNT = 234561;
+  constexpr uint64_t COUNT = 4501;
 
   auto test = [&](uint64_t start, uint64_t stop,
                   mpfr::RoundingMode rounding_mode) {
     mpfr::ForceRoundingMode __r(rounding_mode);
     uint64_t fails = 0;
     uint64_t count = 0;
     uint64_t cc = 0;
     double mx, mr = 0.0;

libc/test/src/math/log2_test.cpp

TEST(LlvmLibcLog2Test, AllExponents) {
   double x = 0x1.0p-1074;
   for (int i = -1074; i < 1024; ++i, x *= 2.0) {
     ASSERT_MPFR_MATCH_ALL_ROUNDING(mpfr::Operation::Log2, x,
                                    __llvm_libc::log2(x), 0.5);
   }
 }
 
 TEST(LlvmLibcLog2Test, InDoubleRange) {
-  constexpr uint64_t COUNT = 234561;
+  constexpr uint64_t COUNT = 1'001;
   constexpr uint64_t START = 0x3FD0'0000'0000'0000ULL; // 0.25
   constexpr uint64_t STOP = 0x4010'0000'0000'0000ULL;  // 4.0
   // constexpr uint64_t START = 0x3FF0'0000'0000'0000ULL;  // 1.0
   // constexpr uint64_t STOP = 0x4000'0000'0000'0000ULL;   // 2.0
   constexpr uint64_t STEP = (STOP - START) / COUNT;
 
   auto test = [&](mpfr::RoundingMode rounding_mode) {
     mpfr::ForceRoundingMode __r(rounding_mode);

libc/test/src/math/sincosf_test.cpp

#define EXPECT_SINCOS_MATCH_ALL_ROUNDING(input)                                \
     __llvm_libc::sincosf(input, &sin, &cos);                                   \
     EXPECT_MPFR_MATCH(mpfr::Operation::Sin, input, sin, 0.5,                   \
                       mpfr::RoundingMode::TowardZero);                         \
     EXPECT_MPFR_MATCH(mpfr::Operation::Cos, input, cos, 0.5,                   \
                       mpfr::RoundingMode::TowardZero);                         \
   }
 
 TEST(LlvmLibcSinCosfTest, InFloatRange) {
-  constexpr uint32_t COUNT = 234561;
+  constexpr uint32_t COUNT = 1'001;
   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;
 
     EXPECT_SINCOS_MATCH_ALL_ROUNDING(x);
     EXPECT_SINCOS_MATCH_ALL_ROUNDING(-x);