+2013-05-24 Joseph Myers <joseph@codesourcery.com>
+
+ * math/gen-libm-test.pl (@functions): Remove variable.
+ (generate_testfile): Don't handle START and END lines.
+ * math/libm-test.inc (START): New macro.
+ (END): Likewise.
+ (END_COMPLEX): Likewise.
+ (acos_test): Use END macro without arguments.
+ (acos_test_tonearest): Likewise.
+ (acos_test_towardzero): Likewise.
+ (acos_test_downward): Likewise.
+ (acos_test_upward): Likewise.
+ (acosh_test): Likewise.
+ (asin_test): Likewise.
+ (asin_test_tonearest): Likewise.
+ (asin_test_towardzero): Likewise.
+ (asin_test_downward): Likewise.
+ (asin_test_upward): Likewise.
+ (asinh_test): Likewise.
+ (atan_test): Likewise.
+ (atanh_test): Likewise.
+ (atan2_test): Likewise.
+ (cabs_test): Likewise.
+ (cacos_test): Use END_COMPLEX macro without arguments.
+ (cacosh_test): Likewise.
+ (carg_test): Use END macro without arguments.
+ (casin_test): Use END_COMPLEX macro without arguments.
+ (casinh_test): Likewise.
+ (catan_test): Likewise.
+ (catanh_test): Likewise.
+ (cbrt_test): Use END macro without arguments.
+ (ccos_test): Use END_COMPLEX macro without arguments.
+ (ccosh_test): Likewise.
+ (ceil_test): Use END macro without arguments.
+ (cexp_test): Use END_COMPLEX macro without arguments.
+ (cimag_test): Use END macro without arguments.
+ (clog_test): Use END_COMPLEX macro without arguments.
+ (clog10_test): Likewise.
+ (conj_test): Likewise.
+ (copysign_test): Use END macro without arguments.
+ (cos_test): Likewise.
+ (cos_test_tonearest): Likewise.
+ (cos_test_towardzero): Likewise.
+ (cos_test_downward): Likewise.
+ (cos_test_upward): Likewise.
+ (cosh_test): Likewise.
+ (cosh_test_tonearest): Likewise.
+ (cosh_test_towardzero): Likewise.
+ (cosh_test_downward): Likewise.
+ (cosh_test_upward): Likewise.
+ (cpow_test): Use END_COMPLEX macro without arguments.
+ (cproj_test): Likewise.
+ (creal_test): Use END macro without arguments.
+ (csin_test): Use END_COMPLEX macro without arguments.
+ (csinh_test): Likewise.
+ (csqrt_test): Likewise.
+ (ctan_test): Likewise.
+ (ctan_test_tonearest): Likewise.
+ (ctan_test_towardzero): Likewise.
+ (ctan_test_downward): Likewise.
+ (ctan_test_upward): Likewise.
+ (ctanh_test): Likewise.
+ (ctanh_test_tonearest): Likewise.
+ (ctanh_test_towardzero): Likewise.
+ (ctanh_test_downward): Likewise.
+ (ctanh_test_upward): Likewise.
+ (erf_test): Use END macro without arguments.
+ (erfc_test): Likewise.
+ (exp_test): Likewise.
+ (exp_test_tonearest): Likewise.
+ (exp_test_towardzero): Likewise.
+ (exp_test_downward): Likewise.
+ (exp_test_upward): Likewise.
+ (exp10_test): Likewise.
+ (exp2_test): Likewise.
+ (expm1_test): Likewise.
+ (fabs_test): Likewise.
+ (fdim_test): Likewise.
+ (finite_test): Likewise.
+ (floor_test): Likewise.
+ (fma_test): Likewise.
+ (fma_test_towardzero): Likewise.
+ (fma_test_downward): Likewise.
+ (fma_test_upward): Likewise.
+ (fmax_test): Likewise.
+ (fmin_test): Likewise.
+ (fmod_test): Likewise.
+ (fpclassify_test): Likewise.
+ (frexp_test): Likewise.
+ (gamma_test): Likewise.
+ (hypot_test): Likewise.
+ (ilogb_test): Likewise.
+ (isfinite_test): Likewise.
+ (isgreater_test): Likewise.
+ (isgreaterequal_test): Likewise.
+ (isinf_test): Likewise.
+ (isless_test): Likewise.
+ (islessequal_test): Likewise.
+ (islessgreater_test): Likewise.
+ (isnan_test): Likewise.
+ (isnormal_test): Likewise.
+ (issignaling_test): Likewise.
+ (isunordered_test): Likewise.
+ (j0_test): Likewise.
+ (j1_test): Likewise.
+ (jn_test): Likewise.
+ (ldexp_test): Likewise.
+ (lgamma_test): Likewise.
+ (lrint_test): Likewise.
+ (lrint_test_tonearest): Likewise.
+ (lrint_test_towardzero): Likewise.
+ (lrint_test_downward): Likewise.
+ (lrint_test_upward): Likewise.
+ (llrint_test): Likewise.
+ (llrint_test_tonearest): Likewise.
+ (llrint_test_towardzero): Likewise.
+ (llrint_test_downward): Likewise.
+ (llrint_test_upward): Likewise.
+ (log_test): Likewise.
+ (log10_test): Likewise.
+ (log1p_test): Likewise.
+ (log2_test): Likewise.
+ (logb_test): Likewise.
+ (logb_test_downward): Likewise.
+ (lround_test): Likewise.
+ (llround_test): Likewise.
+ (modf_test): Likewise.
+ (nearbyint_test): Likewise.
+ (nextafter_test): Likewise.
+ (nexttoward_test): Likewise.
+ (pow_test): Likewise.
+ (pow_test_tonearest): Likewise.
+ (pow_test_towardzero): Likewise.
+ (pow_test_downward): Likewise.
+ (pow_test_upward): Likewise.
+ (remainder_test): Likewise.
+ (remainder_test_tonearest): Likewise.
+ (remainder_test_towardzero): Likewise.
+ (remainder_test_downward): Likewise.
+ (remainder_test_upward): Likewise.
+ (remquo_test): Likewise.
+ (rint_test): Likewise.
+ (rint_test_tonearest): Likewise.
+ (rint_test_towardzero): Likewise.
+ (rint_test_downward): Likewise.
+ (rint_test_upward): Likewise.
+ (round_test): Likewise.
+ (scalb_test): Likewise.
+ (scalbn_test): Likewise.
+ (scalbln_test): Likewise.
+ (signbit_test): Likewise.
+ (sin_test): Likewise.
+ (sin_test_tonearest): Likewise.
+ (sin_test_towardzero): Likewise.
+ (sin_test_downward): Likewise.
+ (sin_test_upward): Likewise.
+ (sincos_test): Likewise.
+ (sinh_test): Likewise.
+ (sinh_test_tonearest): Likewise.
+ (sinh_test_towardzero): Likewise.
+ (sinh_test_downward): Likewise.
+ (sinh_test_upward): Likewise.
+ (sqrt_test): Likewise.
+ (tan_test): Likewise.
+ (tan_test_tonearest): Likewise.
+ (tan_test_towardzero): Likewise.
+ (tan_test_downward): Likewise.
+ (tan_test_upward): Likewise.
+ (tanh_test): Likewise.
+ (tgamma_test): Likewise.
+ (trunc_test): Likewise.
+ (y0_test): Likewise.
+ (y1_test): Likewise.
+ (yn_test): Likewise.
+ (significand_test): Likewise.
+
2013-05-24 Ondřej Bílka <neleai@seznam.cz>
[BZ #15381]
(ARRAY)[i].extra2_expected); \
ROUND_RESTORE_ ## ROUNDING_MODE
-
+/* Start and end the tests for a given function. */
+#define START(FUNC) \
+ const char *this_func = #FUNC; \
+ init_max_error ()
+#define END \
+ print_max_error (this_func)
+#define END_COMPLEX \
+ print_complex_max_error (this_func)
/* This is to prevent messages from the SVID libm emulation. */
int
{
START (acos);
RUN_TEST_LOOP_f_f (acos, acos_test_data, );
- END (acos);
+ END;
}
{
START (acos_tonearest);
RUN_TEST_LOOP_f_f (acos, acos_tonearest_test_data, FE_TONEAREST);
- END (acos_tonearest);
+ END;
}
{
START (acos_towardzero);
RUN_TEST_LOOP_f_f (acos, acos_towardzero_test_data, FE_TOWARDZERO);
- END (acos_towardzero);
+ END;
}
{
START (acos_downward);
RUN_TEST_LOOP_f_f (acos, acos_downward_test_data, FE_DOWNWARD);
- END (acos_downward);
+ END;
}
{
START (acos_upward);
RUN_TEST_LOOP_f_f (acos, acos_upward_test_data, FE_UPWARD);
- END (acos_upward);
+ END;
}
static const struct test_f_f_data acosh_test_data[] =
{
START (acosh);
RUN_TEST_LOOP_f_f (acosh, acosh_test_data, );
- END (acosh);
+ END;
}
static const struct test_f_f_data asin_test_data[] =
{
START (asin);
RUN_TEST_LOOP_f_f (asin, asin_test_data, );
- END (asin);
+ END;
}
{
START (asin_tonearest);
RUN_TEST_LOOP_f_f (asin, asin_tonearest_test_data, FE_TONEAREST);
- END (asin_tonearest);
+ END;
}
{
START (asin_towardzero);
RUN_TEST_LOOP_f_f (asin, asin_towardzero_test_data, FE_TOWARDZERO);
- END (asin_towardzero);
+ END;
}
{
START (asin_downward);
RUN_TEST_LOOP_f_f (asin, asin_downward_test_data, FE_DOWNWARD);
- END (asin_downward);
+ END;
}
{
START (asin_upward);
RUN_TEST_LOOP_f_f (asin, asin_upward_test_data, FE_UPWARD);
- END (asin_upward);
+ END;
}
static const struct test_f_f_data asinh_test_data[] =
{
START (asinh);
RUN_TEST_LOOP_f_f (asinh, asinh_test_data, );
- END (asinh);
+ END;
}
static const struct test_f_f_data atan_test_data[] =
{
START (atan);
RUN_TEST_LOOP_f_f (atan, atan_test_data, );
- END (atan);
+ END;
}
{
START (atanh);
RUN_TEST_LOOP_f_f (atanh, atanh_test_data, );
- END (atanh);
+ END;
}
static const struct test_ff_f_data atan2_test_data[] =
{
START (atan2);
RUN_TEST_LOOP_ff_f (atan2, atan2_test_data, );
- END (atan2);
+ END;
}
static const struct test_c_f_data cabs_test_data[] =
{
START (cabs);
RUN_TEST_LOOP_c_f (cabs, cabs_test_data, );
- END (cabs);
+ END;
}
{
START (cacos);
RUN_TEST_LOOP_c_c (cacos, cacos_test_data, );
- END (cacos, complex);
+ END_COMPLEX;
}
static const struct test_c_c_data cacosh_test_data[] =
{
START (cacosh);
RUN_TEST_LOOP_c_c (cacosh, cacosh_test_data, );
- END (cacosh, complex);
+ END_COMPLEX;
}
{
START (carg);
RUN_TEST_LOOP_c_f (carg, carg_test_data, );
- END (carg);
+ END;
}
static const struct test_c_c_data casin_test_data[] =
{
START (casin);
RUN_TEST_LOOP_c_c (casin, casin_test_data, );
- END (casin, complex);
+ END_COMPLEX;
}
{
START (casinh);
RUN_TEST_LOOP_c_c (casinh, casinh_test_data, );
- END (casinh, complex);
+ END_COMPLEX;
}
{
START (catan);
RUN_TEST_LOOP_c_c (catan, catan_test_data, );
- END (catan, complex);
+ END_COMPLEX;
}
static const struct test_c_c_data catanh_test_data[] =
{
START (catanh);
RUN_TEST_LOOP_c_c (catanh, catanh_test_data, );
- END (catanh, complex);
+ END_COMPLEX;
}
static const struct test_f_f_data cbrt_test_data[] =
{
START (cbrt);
RUN_TEST_LOOP_f_f (cbrt, cbrt_test_data, );
- END (cbrt);
+ END;
}
{
START (ccos);
RUN_TEST_LOOP_c_c (ccos, ccos_test_data, );
- END (ccos, complex);
+ END_COMPLEX;
}
{
START (ccosh);
RUN_TEST_LOOP_c_c (ccosh, ccosh_test_data, );
- END (ccosh, complex);
+ END_COMPLEX;
}
{
START (ceil);
RUN_TEST_LOOP_f_f (ceil, ceil_test_data, );
- END (ceil);
+ END;
}
{
START (cexp);
RUN_TEST_LOOP_c_c (cexp, cexp_test_data, );
- END (cexp, complex);
+ END_COMPLEX;
}
{
START (cimag);
RUN_TEST_LOOP_c_f (cimag, cimag_test_data, );
- END (cimag);
+ END;
}
static const struct test_c_c_data clog_test_data[] =
{
START (clog);
RUN_TEST_LOOP_c_c (clog, clog_test_data, );
- END (clog, complex);
+ END_COMPLEX;
}
{
START (clog10);
RUN_TEST_LOOP_c_c (clog10, clog10_test_data, );
- END (clog10, complex);
+ END_COMPLEX;
}
{
START (conj);
RUN_TEST_LOOP_c_c (conj, conj_test_data, );
- END (conj, complex);
+ END_COMPLEX;
}
{
START (copysign);
RUN_TEST_LOOP_ff_f (copysign, copysign_test_data, );
- END (copysign);
+ END;
}
{
START (cos);
RUN_TEST_LOOP_f_f (cos, cos_test_data, );
- END (cos);
+ END;
}
{
START (cos_tonearest);
RUN_TEST_LOOP_f_f (cos, cos_tonearest_test_data, FE_TONEAREST);
- END (cos_tonearest);
+ END;
}
{
START (cos_towardzero);
RUN_TEST_LOOP_f_f (cos, cos_towardzero_test_data, FE_TOWARDZERO);
- END (cos_towardzero);
+ END;
}
{
START (cos_downward);
RUN_TEST_LOOP_f_f (cos, cos_downward_test_data, FE_DOWNWARD);
- END (cos_downward);
+ END;
}
{
START (cos_upward);
RUN_TEST_LOOP_f_f (cos, cos_upward_test_data, FE_UPWARD);
- END (cos_upward);
+ END;
}
{
START (cosh);
RUN_TEST_LOOP_f_f (cosh, cosh_test_data, );
- END (cosh);
+ END;
}
{
START (cosh_tonearest);
RUN_TEST_LOOP_f_f (cosh, cosh_tonearest_test_data, FE_TONEAREST);
- END (cosh_tonearest);
+ END;
}
{
START (cosh_towardzero);
RUN_TEST_LOOP_f_f (cosh, cosh_towardzero_test_data, FE_TOWARDZERO);
- END (cosh_towardzero);
+ END;
}
{
START (cosh_downward);
RUN_TEST_LOOP_f_f (cosh, cosh_downward_test_data, FE_DOWNWARD);
- END (cosh_downward);
+ END;
}
{
START (cosh_upward);
RUN_TEST_LOOP_f_f (cosh, cosh_upward_test_data, FE_UPWARD);
- END (cosh_upward);
+ END;
}
{
START (cpow);
RUN_TEST_LOOP_cc_c (cpow, cpow_test_data, );
- END (cpow, complex);
+ END_COMPLEX;
}
{
START (cproj);
RUN_TEST_LOOP_c_c (cproj, cproj_test_data, );
- END (cproj, complex);
+ END_COMPLEX;
}
{
START (creal);
RUN_TEST_LOOP_c_f (creal, creal_test_data, );
- END (creal);
+ END;
}
static const struct test_c_c_data csin_test_data[] =
{
START (csin);
RUN_TEST_LOOP_c_c (csin, csin_test_data, );
- END (csin, complex);
+ END_COMPLEX;
}
{
START (csinh);
RUN_TEST_LOOP_c_c (csinh, csinh_test_data, );
- END (csinh, complex);
+ END_COMPLEX;
}
{
START (csqrt);
RUN_TEST_LOOP_c_c (csqrt, csqrt_test_data, );
- END (csqrt, complex);
+ END_COMPLEX;
}
static const struct test_c_c_data ctan_test_data[] =
{
START (ctan);
RUN_TEST_LOOP_c_c (ctan, ctan_test_data, );
- END (ctan, complex);
+ END_COMPLEX;
}
{
START (ctan_tonearest);
RUN_TEST_LOOP_c_c (ctan, ctan_tonearest_test_data, FE_TONEAREST);
- END (ctan_tonearest, complex);
+ END_COMPLEX;
}
{
START (ctan_towardzero);
RUN_TEST_LOOP_c_c (ctan, ctan_towardzero_test_data, FE_TOWARDZERO);
- END (ctan_towardzero, complex);
+ END_COMPLEX;
}
{
START (ctan_downward);
RUN_TEST_LOOP_c_c (ctan, ctan_downward_test_data, FE_DOWNWARD);
- END (ctan_downward, complex);
+ END_COMPLEX;
}
{
START (ctan_upward);
RUN_TEST_LOOP_c_c (ctan, ctan_upward_test_data, FE_UPWARD);
- END (ctan_upward, complex);
+ END_COMPLEX;
}
{
START (ctanh);
RUN_TEST_LOOP_c_c (ctanh, ctanh_test_data, );
- END (ctanh, complex);
+ END_COMPLEX;
}
{
START (ctanh_tonearest);
RUN_TEST_LOOP_c_c (ctanh, ctanh_tonearest_test_data, FE_TONEAREST);
- END (ctanh_tonearest, complex);
+ END_COMPLEX;
}
{
START (ctanh_towardzero);
RUN_TEST_LOOP_c_c (ctanh, ctanh_towardzero_test_data, FE_TOWARDZERO);
- END (ctanh_towardzero, complex);
+ END_COMPLEX;
}
{
START (ctanh_downward);
RUN_TEST_LOOP_c_c (ctanh, ctanh_downward_test_data, FE_DOWNWARD);
- END (ctanh_downward, complex);
+ END_COMPLEX;
}
{
START (ctanh_upward);
RUN_TEST_LOOP_c_c (ctanh, ctanh_upward_test_data, FE_UPWARD);
- END (ctanh_upward, complex);
+ END_COMPLEX;
}
{
START (erf);
RUN_TEST_LOOP_f_f (erf, erf_test_data, );
- END (erf);
+ END;
}
{
START (erfc);
RUN_TEST_LOOP_f_f (erfc, erfc_test_data, );
- END (erfc);
+ END;
}
{
START (exp);
RUN_TEST_LOOP_f_f (exp, exp_test_data, );
- END (exp);
+ END;
}
{
START (exp_tonearest);
RUN_TEST_LOOP_f_f (exp, exp_tonearest_test_data, FE_TONEAREST);
- END (exp_tonearest);
+ END;
}
{
START (exp_towardzero);
RUN_TEST_LOOP_f_f (exp, exp_towardzero_test_data, FE_TOWARDZERO);
- END (exp_towardzero);
+ END;
}
{
START (exp_downward);
RUN_TEST_LOOP_f_f (exp, exp_downward_test_data, FE_DOWNWARD);
- END (exp_downward);
+ END;
}
{
START (exp_upward);
RUN_TEST_LOOP_f_f (exp, exp_upward_test_data, FE_UPWARD);
- END (exp_upward);
+ END;
}
{
START (exp10);
RUN_TEST_LOOP_f_f (exp10, exp10_test_data, );
- END (exp10);
+ END;
}
{
START (exp2);
RUN_TEST_LOOP_f_f (exp2, exp2_test_data, );
- END (exp2);
+ END;
}
{
START (expm1);
RUN_TEST_LOOP_f_f (expm1, expm1_test_data, );
- END (expm1);
+ END;
}
{
START (fabs);
RUN_TEST_LOOP_f_f (fabs, fabs_test_data, );
- END (fabs);
+ END;
}
{
START (fdim);
RUN_TEST_LOOP_ff_f (fdim, fdim_test_data, );
- END (fdim);
+ END;
}
{
START (finite);
RUN_TEST_LOOP_f_b (finite, finite_test_data, );
- END (finite);
+ END;
}
{
START (floor);
RUN_TEST_LOOP_f_f (floor, floor_test_data, );
- END (floor);
+ END;
}
{
START (fma);
RUN_TEST_LOOP_fff_f (fma, fma_test_data, );
- END (fma);
+ END;
}
{
START (fma_towardzero);
RUN_TEST_LOOP_fff_f (fma, fma_towardzero_test_data, FE_TOWARDZERO);
- END (fma_towardzero);
+ END;
}
{
START (fma_downward);
RUN_TEST_LOOP_fff_f (fma, fma_downward_test_data, FE_DOWNWARD);
- END (fma_downward);
+ END;
}
{
START (fma_upward);
RUN_TEST_LOOP_fff_f (fma, fma_upward_test_data, FE_UPWARD);
- END (fma_upward);
+ END;
}
{
START (fmax);
RUN_TEST_LOOP_ff_f (fmax, fmax_test_data, );
- END (fmax);
+ END;
}
{
START (fmin);
RUN_TEST_LOOP_ff_f (fmin, fmin_test_data, );
- END (fmin);
+ END;
}
{
START (fmod);
RUN_TEST_LOOP_ff_f (fmod, fmod_test_data, );
- END (fmod);
+ END;
}
{
START (fpclassify);
RUN_TEST_LOOP_f_i_tg (fpclassify, fpclassify_test_data, );
- END (fpclassify);
+ END;
}
START (frexp);
RUN_TEST_LOOP_fI_f1 (frexp, frexp_test_data, , x);
- END (frexp);
+ END;
}
{
START (gamma);
RUN_TEST_LOOP_f_f1 (gamma, gamma_test_data, , signgam);
- END (gamma);
+ END;
}
static const struct test_ff_f_data hypot_test_data[] =
{
START (hypot);
RUN_TEST_LOOP_ff_f (hypot, hypot_test_data, );
- END (hypot);
+ END;
}
{
START (ilogb);
RUN_TEST_LOOP_f_i (ilogb, ilogb_test_data, );
- END (ilogb);
+ END;
}
static const struct test_f_i_data isfinite_test_data[] =
{
START (isfinite);
RUN_TEST_LOOP_f_b_tg (isfinite, isfinite_test_data, );
- END (isfinite);
+ END;
}
static const struct test_ff_i_data isgreater_test_data[] =
{
START (isgreater);
RUN_TEST_LOOP_ff_i_tg (isgreater, isgreater_test_data, );
- END (isgreater);
+ END;
}
static const struct test_ff_i_data isgreaterequal_test_data[] =
{
START (isgreaterequal);
RUN_TEST_LOOP_ff_i_tg (isgreaterequal, isgreaterequal_test_data, );
- END (isgreaterequal);
+ END;
}
static const struct test_f_i_data isinf_test_data[] =
{
START (isinf);
RUN_TEST_LOOP_f_b_tg (isinf, isinf_test_data, );
- END (isinf);
+ END;
}
static const struct test_ff_i_data isless_test_data[] =
{
START (isless);
RUN_TEST_LOOP_ff_i_tg (isless, isless_test_data, );
- END (isless);
+ END;
}
static const struct test_ff_i_data islessequal_test_data[] =
{
START (islessequal);
RUN_TEST_LOOP_ff_i_tg (islessequal, islessequal_test_data, );
- END (islessequal);
+ END;
}
static const struct test_ff_i_data islessgreater_test_data[] =
{
START (islessgreater);
RUN_TEST_LOOP_ff_i_tg (islessgreater, islessgreater_test_data, );
- END (islessgreater);
+ END;
}
static const struct test_f_i_data isnan_test_data[] =
{
START (isnan);
RUN_TEST_LOOP_f_b_tg (isnan, isnan_test_data, );
- END (isnan);
+ END;
}
static const struct test_f_i_data isnormal_test_data[] =
{
START (isnormal);
RUN_TEST_LOOP_f_b_tg (isnormal, isnormal_test_data, );
- END (isnormal);
+ END;
}
static const struct test_f_i_data issignaling_test_data[] =
{
START (issignaling);
RUN_TEST_LOOP_f_b_tg (issignaling, issignaling_test_data, );
- END (issignaling);
+ END;
}
static const struct test_ff_i_data isunordered_test_data[] =
{
START (isunordered);
RUN_TEST_LOOP_ff_i_tg (isunordered, isunordered_test_data, );
- END (isunordered);
+ END;
}
static const struct test_f_f_data j0_test_data[] =
{
START (j0);
RUN_TEST_LOOP_f_f (j0, j0_test_data, );
- END (j0);
+ END;
}
{
START (j1);
RUN_TEST_LOOP_f_f (j1, j1_test_data, );
- END (j1);
+ END;
}
static const struct test_if_f_data jn_test_data[] =
{
START (jn);
RUN_TEST_LOOP_if_f (jn, jn_test_data, );
- END (jn);
+ END;
}
{
START (ldexp);
RUN_TEST_LOOP_fi_f (ldexp, ldexp_test_data, );
- END (ldexp);
+ END;
}
{
START (lgamma);
RUN_TEST_LOOP_f_f1 (lgamma, lgamma_test_data, , signgam);
- END (lgamma);
+ END;
}
{
START (lrint);
RUN_TEST_LOOP_f_l (lrint, lrint_test_data, );
- END (lrint);
+ END;
}
{
START (lrint_tonearest);
RUN_TEST_LOOP_f_l (lrint, lrint_tonearest_test_data, FE_TONEAREST);
- END (lrint_tonearest);
+ END;
}
{
START (lrint_towardzero);
RUN_TEST_LOOP_f_l (lrint, lrint_towardzero_test_data, FE_TOWARDZERO);
- END (lrint_towardzero);
+ END;
}
{
START (lrint_downward);
RUN_TEST_LOOP_f_l (lrint, lrint_downward_test_data, FE_DOWNWARD);
- END (lrint_downward);
+ END;
}
{
START (lrint_upward);
RUN_TEST_LOOP_f_l (lrint, lrint_upward_test_data, FE_UPWARD);
- END (lrint_upward);
+ END;
}
{
START (llrint);
RUN_TEST_LOOP_f_L (llrint, llrint_test_data, );
- END (llrint);
+ END;
}
static const struct test_f_L_data llrint_tonearest_test_data[] =
{
START (llrint_tonearest);
RUN_TEST_LOOP_f_L (llrint, llrint_tonearest_test_data, FE_TONEAREST);
- END (llrint_tonearest);
+ END;
}
static const struct test_f_L_data llrint_towardzero_test_data[] =
{
START (llrint_towardzero);
RUN_TEST_LOOP_f_L (llrint, llrint_towardzero_test_data, FE_TOWARDZERO);
- END (llrint_towardzero);
+ END;
}
static const struct test_f_L_data llrint_downward_test_data[] =
{
START (llrint_downward);
RUN_TEST_LOOP_f_L (llrint, llrint_downward_test_data, FE_DOWNWARD);
- END (llrint_downward);
+ END;
}
static const struct test_f_L_data llrint_upward_test_data[] =
{
START (llrint_upward);
RUN_TEST_LOOP_f_L (llrint, llrint_upward_test_data, FE_UPWARD);
- END (llrint_upward);
+ END;
}
{
START (log);
RUN_TEST_LOOP_f_f (log, log_test_data, );
- END (log);
+ END;
}
{
START (log10);
RUN_TEST_LOOP_f_f (log10, log10_test_data, );
- END (log10);
+ END;
}
{
START (log1p);
RUN_TEST_LOOP_f_f (log1p, log1p_test_data, );
- END (log1p);
+ END;
}
{
START (log2);
RUN_TEST_LOOP_f_f (log2, log2_test_data, );
- END (log2);
+ END;
}
{
START (logb);
RUN_TEST_LOOP_f_f (logb, logb_test_data, );
- END (logb);
+ END;
}
static const struct test_f_f_data logb_downward_test_data[] =
{
START (logb_downward);
RUN_TEST_LOOP_f_f (logb, logb_downward_test_data, FE_DOWNWARD);
- END (logb_downward);
+ END;
}
static const struct test_f_l_data lround_test_data[] =
{
START (lround);
RUN_TEST_LOOP_f_l (lround, lround_test_data, );
- END (lround);
+ END;
}
{
START (llround);
RUN_TEST_LOOP_f_L (llround, llround_test_data, );
- END (llround);
+ END;
}
static const struct test_fF_f1_data modf_test_data[] =
START (modf);
RUN_TEST_LOOP_fF_f1 (modf, modf_test_data, , x);
- END (modf);
+ END;
}
{
START (nearbyint);
RUN_TEST_LOOP_f_f (nearbyint, nearbyint_test_data, );
- END (nearbyint);
+ END;
}
static const struct test_ff_f_data nextafter_test_data[] =
START (nextafter);
RUN_TEST_LOOP_ff_f (nextafter, nextafter_test_data, );
- END (nextafter);
+ END;
}
{
START (nexttoward);
RUN_TEST_LOOP_ff_f (nexttoward, nexttoward_test_data, );
- END (nexttoward);
+ END;
}
START (pow);
RUN_TEST_LOOP_ff_f (pow, pow_test_data, );
- END (pow);
+ END;
}
{
START (pow_tonearest);
RUN_TEST_LOOP_ff_f (pow, pow_tonearest_test_data, FE_TONEAREST);
- END (pow_tonearest);
+ END;
}
{
START (pow_towardzero);
RUN_TEST_LOOP_ff_f (pow, pow_towardzero_test_data, FE_TOWARDZERO);
- END (pow_towardzero);
+ END;
}
{
START (pow_downward);
RUN_TEST_LOOP_ff_f (pow, pow_downward_test_data, FE_DOWNWARD);
- END (pow_downward);
+ END;
}
{
START (pow_upward);
RUN_TEST_LOOP_ff_f (pow, pow_upward_test_data, FE_UPWARD);
- END (pow_upward);
+ END;
}
{
START (remainder);
RUN_TEST_LOOP_ff_f (remainder, remainder_test_data, );
- END (remainder);
+ END;
}
{
START (remainder_tonearest);
RUN_TEST_LOOP_ff_f (remainder, remainder_tonearest_test_data, FE_TONEAREST);
- END (remainder_tonearest);
+ END;
}
{
START (remainder_towardzero);
RUN_TEST_LOOP_ff_f (remainder, remainder_towardzero_test_data, FE_TOWARDZERO);
- END (remainder_towardzero);
+ END;
}
{
START (remainder_downward);
RUN_TEST_LOOP_ff_f (remainder, remainder_downward_test_data, FE_DOWNWARD);
- END (remainder_downward);
+ END;
}
{
START (remainder_upward);
RUN_TEST_LOOP_ff_f (remainder, remainder_upward_test_data, FE_UPWARD);
- END (remainder_upward);
+ END;
}
static const struct test_ffI_f1_data remquo_test_data[] =
START (remquo);
RUN_TEST_LOOP_ffI_f1 (remquo, remquo_test_data, , x);
- END (remquo);
+ END;
}
static const struct test_f_f_data rint_test_data[] =
{
START (rint);
RUN_TEST_LOOP_f_f (rint, rint_test_data, );
- END (rint);
+ END;
}
static const struct test_f_f_data rint_tonearest_test_data[] =
{
START (rint_tonearest);
RUN_TEST_LOOP_f_f (rint, rint_tonearest_test_data, FE_TONEAREST);
- END (rint_tonearest);
+ END;
}
static const struct test_f_f_data rint_towardzero_test_data[] =
{
START (rint_towardzero);
RUN_TEST_LOOP_f_f (rint, rint_towardzero_test_data, FE_TOWARDZERO);
- END (rint_towardzero);
+ END;
}
static const struct test_f_f_data rint_downward_test_data[] =
{
START (rint_downward);
RUN_TEST_LOOP_f_f (rint, rint_downward_test_data, FE_DOWNWARD);
- END (rint_downward);
+ END;
}
static const struct test_f_f_data rint_upward_test_data[] =
{
START (rint_upward);
RUN_TEST_LOOP_f_f (rint, rint_upward_test_data, FE_UPWARD);
- END (rint_upward);
+ END;
}
static const struct test_f_f_data round_test_data[] =
{
START (round);
RUN_TEST_LOOP_f_f (round, round_test_data, );
- END (round);
+ END;
}
START (scalb);
RUN_TEST_LOOP_ff_f (scalb, scalb_test_data, );
- END (scalb);
+ END;
}
START (scalbn);
RUN_TEST_LOOP_fi_f (scalbn, scalbn_test_data, );
- END (scalbn);
+ END;
}
START (scalbln);
RUN_TEST_LOOP_fl_f (scalbln, scalbln_test_data, );
- END (scalbln);
+ END;
}
{
START (signbit);
RUN_TEST_LOOP_f_b_tg (signbit, signbit_test_data, );
- END (signbit);
+ END;
}
{
START (sin);
RUN_TEST_LOOP_f_f (sin, sin_test_data, );
- END (sin);
+ END;
}
{
START (sin_tonearest);
RUN_TEST_LOOP_f_f (sin, sin_tonearest_test_data, FE_TONEAREST);
- END (sin_tonearest);
+ END;
}
{
START (sin_towardzero);
RUN_TEST_LOOP_f_f (sin, sin_towardzero_test_data, FE_TOWARDZERO);
- END (sin_towardzero);
+ END;
}
{
START (sin_downward);
RUN_TEST_LOOP_f_f (sin, sin_downward_test_data, FE_DOWNWARD);
- END (sin_downward);
+ END;
}
{
START (sin_upward);
RUN_TEST_LOOP_f_f (sin, sin_upward_test_data, FE_UPWARD);
- END (sin_upward);
+ END;
}
START (sincos);
RUN_TEST_LOOP_fFF_11 (sincos, sincos_test_data, , sin_res, cos_res);
- END (sincos);
+ END;
}
static const struct test_f_f_data sinh_test_data[] =
{
START (sinh);
RUN_TEST_LOOP_f_f (sinh, sinh_test_data, );
- END (sinh);
+ END;
}
{
START (sinh_tonearest);
RUN_TEST_LOOP_f_f (sinh, sinh_tonearest_test_data, FE_TONEAREST);
- END (sinh_tonearest);
+ END;
}
{
START (sinh_towardzero);
RUN_TEST_LOOP_f_f (sinh, sinh_towardzero_test_data, FE_TOWARDZERO);
- END (sinh_towardzero);
+ END;
}
{
START (sinh_downward);
RUN_TEST_LOOP_f_f (sinh, sinh_downward_test_data, FE_DOWNWARD);
- END (sinh_downward);
+ END;
}
{
START (sinh_upward);
RUN_TEST_LOOP_f_f (sinh, sinh_upward_test_data, FE_UPWARD);
- END (sinh_upward);
+ END;
}
{
START (sqrt);
RUN_TEST_LOOP_f_f (sqrt, sqrt_test_data, );
- END (sqrt);
+ END;
}
{
START (tan);
RUN_TEST_LOOP_f_f (tan, tan_test_data, );
- END (tan);
+ END;
}
{
START (tan_tonearest);
RUN_TEST_LOOP_f_f (tan, tan_tonearest_test_data, FE_TONEAREST);
- END (tan_tonearest);
+ END;
}
{
START (tan_towardzero);
RUN_TEST_LOOP_f_f (tan, tan_towardzero_test_data, FE_TOWARDZERO);
- END (tan_towardzero);
+ END;
}
{
START (tan_downward);
RUN_TEST_LOOP_f_f (tan, tan_downward_test_data, FE_DOWNWARD);
- END (tan_downward);
+ END;
}
{
START (tan_upward);
RUN_TEST_LOOP_f_f (tan, tan_upward_test_data, FE_UPWARD);
- END (tan_upward);
+ END;
}
{
START (tanh);
RUN_TEST_LOOP_f_f (tanh, tanh_test_data, );
- END (tanh);
+ END;
}
static const struct test_f_f_data tgamma_test_data[] =
{
START (tgamma);
RUN_TEST_LOOP_f_f (tgamma, tgamma_test_data, );
- END (tgamma);
+ END;
}
{
START (trunc);
RUN_TEST_LOOP_f_f (trunc, trunc_test_data, );
- END (trunc);
+ END;
}
static const struct test_f_f_data y0_test_data[] =
{
START (y0);
RUN_TEST_LOOP_f_f (y0, y0_test_data, );
- END (y0);
+ END;
}
{
START (y1);
RUN_TEST_LOOP_f_f (y1, y1_test_data, );
- END (y1);
+ END;
}
{
START (yn);
RUN_TEST_LOOP_if_f (yn, yn_test_data, );
- END (yn);
+ END;
}
{
START (significand);
RUN_TEST_LOOP_f_f (significand, significand_test_data, );
- END (significand);
+ END;
}