/* Copyright (C) 1997 Free Software Foundation, Inc. This file is part of the GNU C Library. Contributed by Andreas Jaeger , 1997. The GNU C Library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. The GNU C Library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with the GNU C Library; see the file COPYING.LIB. If not, write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ /* Part of testsuite for libm. This file has to be included by a master file that defines: Makros: FUNC(function): converts general function name (like cos) to name with correct suffix (e.g. cosl or cosf) MATHCONST(x): like FUNC but for constants (e.g convert 0.0 to 0.0L) MATHTYPE: floating point type to test TEST_MSG: informal message to be displayed CHOOSE(Clongdouble,Cdouble,Cfloat): chooses one of the parameters as epsilon for testing equality PRINTF_EXPR Floating point conversion specification to print a variable of type MATHTYPE with printf. PRINTF_EXPR just contains the specifier, not the percent and width arguments, e.g. "f" */ /* This program isn't finished yet. It has tests for: acos, acosh, asin, asinh, atan, atan2, atanh, cbrt, ceil, copysign, cos, cosh, erf, erfc, exp, exp2, expm1, fabs, fdim, floor, fmin, fmax, fmod, fpclassify, frexp, gamma, hypot, ilogb, isfinite, isinf, isnan, isnormal, ldexp, lgamma, log, log10, log1p, log2, logb, modf, nearbyint, nextafter, pow, remainder, remquo, rint, lrint, llrint, round, lround, llround, scalb, scalbn, signbit, sin, sincos, sinh, sqrt, tan, tanh, trunc and for the following complex math functions: cacos, cacosh, casin, casinh, catan, catanh, ccos, ccosh, cexp, clog, cpow, csin, csinh, csqrt, ctanh. At the moment the following functions aren't tested: cabs, carg, conj, cproj, cimag, creal, ctan, drem, j0, j1, jn, y0, y1, yn, significand, nan, comparison macros (isless,isgreater,...). The routines using random variables are still under construction. I don't like it the way it's working now and will change it. Parameter handling is primitive in the moment: --verbose=[0..4] for different levels of output: 0: only error count 1: basic report on failed tests (default) 2: full report on failed tests 3: full report on failed and passed tests 4: additional report on exceptions -v for full output (equals --verbose=4) -s,--silent outputs only the error count (equals --verbose=0) */ /* "Philosophy": This suite tests the correct implementation of mathematical functions in libm. Some simple, specific parameters are tested for correctness. Handling of specific inputs (e.g. infinity, not-a-number) is also tested. Correct handling of exceptions is checked against. These implemented tests should check all cases that are specified in ISO C 9X. Exception testing: At the moment only divide-by-zero and invalid exceptions are tested. Overflow/underflow and inexact exceptions aren't checked at the moment. NaN values: There exist signalling and quiet NaNs. This implementation only uses signalling NaN as parameter but does not differenciate between the two kinds of NaNs as result. Inline functions: Inlining functions should give an improvement in speed - but not in precission. The inlined functions return reasonable values for a reasonable range of input values. The result is not necessarily correct for all values and exceptions are not correctly raised in all cases. Problematic input and return values are infinity, not-a-number and minus zero. This suite therefore does not check these specific inputs and the exception handling for inlined mathematical functions - just the "reasonable" values are checked. Beware: The tests might fail for any of the following reasons: - Tests are wrong - Functions are wrong - Floating Point Unit not working properly - Compiler has errors With e.g. gcc 2.7.2.2 the test for cexp fails because of a compiler error. */ #ifndef _GNU_SOURCE # define _GNU_SOURCE #endif #include #include #include #include #include #include #include #include /* Possible exceptions */ #define NO_EXCEPTION 0x0 #define INVALID_EXCEPTION 0x1 #define DIVIDE_BY_ZERO_EXCEPTION 0x2 #define PRINT 1 #define NO_PRINT 0 /* Various constants (we must supply them precalculated for accuracy). */ #define M_PI_6 .52359877559829887308L static int noErrors; static int verbose = 3; static MATHTYPE minus_zero, plus_zero; static MATHTYPE plus_infty, minus_infty, nan_value; typedef MATHTYPE (*mathfunc) (MATHTYPE); #define BUILD_COMPLEX(real, imag) \ ({ __complex__ MATHTYPE __retval; \ __real__ __retval = (real); \ __imag__ __retval = (imag); \ __retval; }) #define ISINF(x) \ (sizeof (x) == sizeof (float) ? \ isinff (x) \ : sizeof (x) == sizeof (double) ? \ isinf (x) : isinfl (x)) /* Test if Floating-Point stack hasn't changed */ static void fpstack_test (const char *test_name) { #ifdef i386 static int old_stack; int sw; asm ("fnstsw":"=a" (sw)); sw >>= 11; sw &= 7; if (sw != old_stack) { printf ("FP-Stack wrong after test %s\n", test_name); if (verbose > 2) printf ("=======> stack = %d\n", sw); ++noErrors; old_stack = sw; } #endif } /* Get a random value x with min_value < x < max_value and min_value, max_value finite, max_value and min_value shouldn't be too close together */ static MATHTYPE random_value (MATHTYPE min_value, MATHTYPE max_value) { int r; MATHTYPE x; r = rand (); x = (max_value - min_value) / RAND_MAX * (MATHTYPE) r + min_value; if ((x <= min_value) || (x >= max_value) || !isfinite (x)) x = (max_value - min_value) / 2 + min_value; /* Make sure the RNG has no influence on the exceptions. */ feclearexcept (FE_ALL_EXCEPT); return x; } /* Get a random value x with x > min_value. */ static MATHTYPE random_greater (MATHTYPE min_value) { return random_value (min_value, 1e6); /* CHOOSE (LDBL_MAX, DBL_MAX, FLT_MAX) */ } /* Get a random value x with x < max_value. */ static MATHTYPE random_less (MATHTYPE max_value) { return random_value (-1e6, max_value); } static void output_new_test (const char *test_name) { if (verbose > 2) printf ("\nTesting: %s\n", test_name); } static void output_pass_value (void) { if (verbose > 2) printf ("Pass: Value Ok.\n"); } static void output_fail_value (const char * test_name) { if (verbose > 0 && verbose < 3) printf ("Fail: %s\n", test_name); if (verbose >= 3) printf ("Fail:\n"); } /* Test whether a given exception was raised. */ static void test_single_exception (const char *test_name, short int exception, short int exc_flag, int fe_flag, const char *flag_name) { #ifndef TEST_INLINE if (exception & exc_flag) { if (fetestexcept (fe_flag)) { if (verbose > 3) printf ("Pass: Exception \"%s\" set\n", flag_name); } else { if (verbose && verbose < 3) printf ("Fail: %s: Exception \"%s\" not set\n", test_name, flag_name); if (verbose >= 3) printf ("Fail: Exception \"%s\" not set\n", flag_name); ++noErrors; } } else { if (fetestexcept (fe_flag)) { if (verbose && verbose < 3) printf ("Fail: %s: Exception \"%s\" set\n", test_name, flag_name); if (verbose >= 3) printf ("Fail: Exception \"%s\" set\n", flag_name); ++noErrors; } else { if (verbose > 3) printf ("Pass: Exception \"%s\" not set\n", flag_name); } } #endif } /* Test whether exception given by EXCEPTION are raised. */ static void test_not_exception (const char *test_name, short int exception) { #ifdef FE_DIVBYZERO if ((exception & DIVIDE_BY_ZERO_EXCEPTION) == 0) test_single_exception (test_name, exception, DIVIDE_BY_ZERO_EXCEPTION, FE_DIVBYZERO, "Divide by zero"); #endif #ifdef FE_INVALID if ((exception & INVALID_EXCEPTION) == 0) test_single_exception (test_name, exception, INVALID_EXCEPTION, FE_INVALID, "Invalid operation"); #endif feclearexcept (FE_ALL_EXCEPT); } /* Test whether exceptions given by EXCEPTION are raised. */ static void test_exceptions (const char *test_name, short int exception) { #ifdef FE_DIVBYZERO test_single_exception (test_name, exception, DIVIDE_BY_ZERO_EXCEPTION, FE_DIVBYZERO, "Divide by zero"); #endif #ifdef FE_INVALID test_single_exception (test_name, exception, INVALID_EXCEPTION, FE_INVALID, "Invalid operation"); #endif feclearexcept (FE_ALL_EXCEPT); } /* Test if two floating point numbers are equal. */ static int check_equal (MATHTYPE computed, MATHTYPE supplied, MATHTYPE eps, MATHTYPE * diff) { int ret_value; /* Both plus Infinity or both minus infinity. */ if (ISINF (computed) && (ISINF (computed) == ISINF (supplied))) return 1; if (isnan (computed) && isnan (supplied)) /* isnan works for all types */ return 1; *diff = FUNC(fabs) (computed - supplied); ret_value = (*diff <= eps && (signbit (computed) == signbit (supplied) || eps != 0.0)); /* Make sure the subtraction/comparsion have no influence on the exceptions. */ feclearexcept (FE_ALL_EXCEPT); return ret_value; } static void output_result_bool (const char *test_name, int result) { if (result) { output_pass_value (); } else { output_fail_value (test_name); if (verbose > 1) printf (" Value: %d\n", result); ++noErrors; } fpstack_test (test_name); } static void output_isvalue (const char *test_name, int result, MATHTYPE value) { if (result) { output_pass_value (); } else { output_fail_value (test_name); if (verbose > 1) printf (" Value: %.20" PRINTF_EXPR "\n", value); noErrors++; } fpstack_test (test_name); } static void output_isvalue_ext (const char *test_name, int result, MATHTYPE value, MATHTYPE parameter) { if (result) { output_pass_value (); } else { output_fail_value (test_name); if (verbose > 1) { printf (" Value: %.20" PRINTF_EXPR "\n", value); printf (" Parameter: %.20" PRINTF_EXPR "\n", parameter); } noErrors++; } fpstack_test (test_name); } static void output_result (const char *test_name, int result, MATHTYPE computed, MATHTYPE expected, MATHTYPE difference, int print_values, int print_diff) { if (result) { output_pass_value (); } else { output_fail_value (test_name); if (verbose > 1 && print_values) { printf ("Result:\n"); printf (" is: %.20" PRINTF_EXPR "\n", computed); printf (" should be: %.20" PRINTF_EXPR "\n", expected); if (print_diff) printf (" difference: %.20" PRINTF_EXPR "\n", difference); } noErrors++; } fpstack_test (test_name); } static void output_result_ext (const char *test_name, int result, MATHTYPE computed, MATHTYPE expected, MATHTYPE difference, MATHTYPE parameter, int print_values, int print_diff) { if (result) { output_pass_value (); } else { output_fail_value (test_name); if (verbose > 1 && print_values) { printf ("Result:\n"); printf (" is: %.20" PRINTF_EXPR "\n", computed); printf (" should be: %.20" PRINTF_EXPR "\n", expected); if (print_diff) printf (" difference: %.20" PRINTF_EXPR "\n", difference); printf ("Parameter: %.20" PRINTF_EXPR "\n", parameter); } noErrors++; } fpstack_test (test_name); } /* check that computed and expected values are the same */ static void check (const char *test_name, MATHTYPE computed, MATHTYPE expected) { MATHTYPE diff; int result; output_new_test (test_name); test_exceptions (test_name, NO_EXCEPTION); result = check_equal (computed, expected, 0, &diff); output_result (test_name, result, computed, expected, diff, PRINT, PRINT); } /* check that computed and expected values are the same, outputs the parameter to the function */ static void check_ext (const char *test_name, MATHTYPE computed, MATHTYPE expected, MATHTYPE parameter) { MATHTYPE diff; int result; output_new_test (test_name); test_exceptions (test_name, NO_EXCEPTION); result = check_equal (computed, expected, 0, &diff); output_result_ext (test_name, result, computed, expected, diff, parameter, PRINT, PRINT); } /* check that computed and expected values are the same and checks also for exception flags */ static void check_exc (const char *test_name, MATHTYPE computed, MATHTYPE expected, short exception) { MATHTYPE diff; int result; output_new_test (test_name); test_exceptions (test_name, exception); result = check_equal (computed, expected, 0, &diff); output_result (test_name, result, computed, expected, diff, PRINT, PRINT); } /* check that computed and expected values are close enough */ static void check_eps (const char *test_name, MATHTYPE computed, MATHTYPE expected, MATHTYPE epsilon) { MATHTYPE diff; int result; output_new_test (test_name); test_exceptions (test_name, NO_EXCEPTION); result = check_equal (computed, expected, epsilon, &diff); output_result (test_name, result, computed, expected, diff, PRINT, PRINT); } /* check a boolean condition */ static void check_bool (const char *test_name, int computed) { output_new_test (test_name); test_exceptions (test_name, NO_EXCEPTION); output_result_bool (test_name, computed); } /* check that computed and expected values are equal (int values) */ static void check_int (const char *test_name, int computed, int expected) { int diff = computed - expected; int result = diff == 0; output_new_test (test_name); test_exceptions (test_name, NO_EXCEPTION); if (result) { output_pass_value (); } else { output_fail_value (test_name); if (verbose > 1) { printf ("Result:\n"); printf (" is: %d\n", computed); printf (" should be: %d\n", expected); } noErrors++; } fpstack_test (test_name); } /* check that computed and expected values are equal (long int values) */ static void check_long (const char *test_name, long int computed, long int expected) { long int diff = computed - expected; int result = diff == 0; output_new_test (test_name); test_exceptions (test_name, NO_EXCEPTION); if (result) { output_pass_value (); } else { output_fail_value (test_name); if (verbose > 1) { printf ("Result:\n"); printf (" is: %ld\n", computed); printf (" should be: %ld\n", expected); } noErrors++; } fpstack_test (test_name); } /* check that computed and expected values are equal (long long int values) */ static void check_longlong (const char *test_name, long long int computed, long long int expected) { long long int diff = computed - expected; int result = diff == 0; output_new_test (test_name); test_exceptions (test_name, NO_EXCEPTION); if (result) { output_pass_value (); } else { output_fail_value (test_name); if (verbose > 1) { printf ("Result:\n"); printf (" is: %lld\n", computed); printf (" should be: %lld\n", expected); } noErrors++; } fpstack_test (test_name); } /* check that computed value is not-a-number */ static void check_isnan (const char *test_name, MATHTYPE computed) { output_new_test (test_name); test_exceptions (test_name, NO_EXCEPTION); output_isvalue (test_name, isnan (computed), computed); } /* check that computed value is not-a-number and test for exceptions */ static void check_isnan_exc (const char *test_name, MATHTYPE computed, short exception) { output_new_test (test_name); test_exceptions (test_name, exception); output_isvalue (test_name, isnan (computed), computed); } /* check that computed value is not-a-number and test for exceptions */ static void check_isnan_maybe_exc (const char *test_name, MATHTYPE computed, short exception) { output_new_test (test_name); test_not_exception (test_name, exception); output_isvalue (test_name, isnan (computed), computed); } /* check that computed value is not-a-number and supply parameter */ #ifndef TEST_INLINE static void check_isnan_ext (const char *test_name, MATHTYPE computed, MATHTYPE parameter) { output_new_test (test_name); test_exceptions (test_name, NO_EXCEPTION); output_isvalue_ext (test_name, isnan (computed), computed, parameter); } #endif /* check that computed value is not-a-number, test for exceptions and supply parameter */ static void check_isnan_exc_ext (const char *test_name, MATHTYPE computed, short exception, MATHTYPE parameter) { output_new_test (test_name); test_exceptions (test_name,exception); output_isvalue_ext (test_name, isnan (computed), computed, parameter); } /* Tests if computed is +Inf */ static void check_isinfp (const char *test_name, MATHTYPE computed) { output_new_test (test_name); test_exceptions (test_name, NO_EXCEPTION); output_isvalue (test_name, (ISINF (computed) == +1), computed); } static void check_isinfp_ext (const char *test_name, MATHTYPE computed, MATHTYPE parameter) { output_new_test (test_name); test_exceptions (test_name, NO_EXCEPTION); output_isvalue_ext (test_name, (ISINF (computed) == +1), computed, parameter); } /* Tests if computed is +Inf */ static void check_isinfp_exc (const char *test_name, MATHTYPE computed, int exception) { output_new_test (test_name); test_exceptions (test_name, exception); output_isvalue (test_name, (ISINF (computed) == +1), computed); } /* Tests if computed is -Inf */ static void check_isinfn (const char *test_name, MATHTYPE computed) { output_new_test (test_name); test_exceptions (test_name, NO_EXCEPTION); output_isvalue (test_name, (ISINF (computed) == -1), computed); } #ifndef TEST_INLINE static void check_isinfn_ext (const char *test_name, MATHTYPE computed, MATHTYPE parameter) { output_new_test (test_name); test_exceptions (test_name, NO_EXCEPTION); output_isvalue_ext (test_name, (ISINF (computed) == -1), computed, parameter); } #endif /* Tests if computed is -Inf */ static void check_isinfn_exc (const char *test_name, MATHTYPE computed, int exception) { output_new_test (test_name); test_exceptions (test_name, exception); output_isvalue (test_name, (ISINF (computed) == -1), computed); } /* This is to prevent messages from the SVID libm emulation. */ int matherr (struct exception *x __attribute__ ((unused))) { return 1; } /**************************************************************************** Test for single functions of libm ****************************************************************************/ static void acos_test (void) { #ifndef TEST_INLINE MATHTYPE x; x = random_greater (1); check_isnan_exc ("acos (x) == NaN plus invalid exception for |x| > 1", FUNC(acos) (x), INVALID_EXCEPTION); x = random_less (1); check_isnan_exc ("acos (x) == NaN plus invalid exception for |x| > 1", FUNC(acos) (x), INVALID_EXCEPTION); #endif check ("acos (1) == 0", FUNC(acos) (1), 0); check ("acos (-1) == pi", FUNC(acos) (-1), M_PI); } static void acosh_test (void) { #ifndef TEST_INLINE MATHTYPE x; check_isinfp ("acosh(+inf) == +inf", FUNC(acosh) (plus_infty)); x = random_less (1); check_isnan_exc ("acosh(x) == NaN plus invalid exception if x < 1", FUNC(acosh) (x), INVALID_EXCEPTION); #endif check ("acosh(1) == 0", FUNC(acosh) (1), 0); } static void asin_test (void) { #ifndef TEST_INLINE MATHTYPE x; x = random_greater (1); check_isnan_exc ("asin x == NaN plus invalid exception for |x| > 1", FUNC(asin) (x), INVALID_EXCEPTION); x = random_less (1); check_isnan_exc ("asin x == NaN plus invalid exception for |x| > 1", FUNC(asin) (x), INVALID_EXCEPTION); #endif check ("asin (0) == 0", FUNC(asin) (0), 0); } static void asinh_test (void) { check ("asinh(+0) == +0", FUNC(asinh) (0), 0); #ifndef TEST_INLINE check ("asinh(-0) == -0", FUNC(asinh) (minus_zero), minus_zero); check_isinfp ("asinh(+inf) == +inf", FUNC(asinh) (plus_infty)); check_isinfn ("asinh(-inf) == -inf", FUNC(asinh) (minus_infty)); #endif } static void atan_test (void) { check ("atan (0) == 0", FUNC(atan) (0), 0); check ("atan (-0) == -0", FUNC(atan) (minus_zero), minus_zero); check ("atan (+inf) == pi/2", FUNC(atan) (plus_infty), M_PI_2); check ("atan (-inf) == -pi/2", FUNC(atan) (minus_infty), -M_PI_2); } static void atan2_test (void) { MATHTYPE x; x = random_greater (0); check ("atan2 (0,x) == 0 for x > 0", FUNC(atan2) (0, x), 0); x = random_greater (0); check ("atan2 (-0,x) == -0 for x > 0", FUNC(atan2) (minus_zero, x), minus_zero); check ("atan2 (+0,+0) == +0", FUNC(atan2) (0, 0), 0); check ("atan2 (-0,+0) == -0", FUNC(atan2) (minus_zero, 0), minus_zero); x = -random_greater (0); check ("atan2 (+0,x) == +pi for x < 0", FUNC(atan2) (0, x), M_PI); x = -random_greater (0); check ("atan2 (-0,x) == -pi for x < 0", FUNC(atan2) (minus_zero, x), -M_PI); check ("atan2 (+0,-0) == +pi", FUNC(atan2) (0, minus_zero), M_PI); check ("atan2 (-0,-0) == -pi", FUNC(atan2) (minus_zero, minus_zero), -M_PI); x = random_greater (0); check ("atan2 (y,+0) == pi/2 for y > 0", FUNC(atan2) (x, 0), M_PI_2); x = random_greater (0); check ("atan2 (y,-0) == pi/2 for y > 0", FUNC(atan2) (x, minus_zero), M_PI_2); x = random_less (0); check ("atan2 (y,+0) == -pi/2 for y < 0", FUNC(atan2) (x, 0), -M_PI_2); x = random_less (0); check ("atan2 (y,-0) == -pi/2 for y < 0", FUNC(atan2) (x, minus_zero), -M_PI_2); x = random_greater (0); check ("atan2 (y,inf) == +0 for finite y > 0", FUNC(atan2) (x, plus_infty), 0); x = -random_greater (0); check ("atan2 (y,inf) == -0 for finite y < 0", FUNC(atan2) (x, plus_infty), minus_zero); x = random_value (-1e4, 1e4); check ("atan2(+inf, x) == pi/2 for finite x", FUNC(atan2) (plus_infty, x), M_PI_2); x = random_value (-1e4, 1e4); check ("atan2(-inf, x) == -pi/2 for finite x", FUNC(atan2) (minus_infty, x), -M_PI_2); x = random_greater (0); check ("atan2 (y,-inf) == +pi for finite y > 0", FUNC(atan2) (x, minus_infty), M_PI); x = -random_greater (0); check ("atan2 (y,-inf) == -pi for finite y < 0", FUNC(atan2) (x, minus_infty), -M_PI); check ("atan2 (+inf,+inf) == +pi/4", FUNC(atan2) (plus_infty, plus_infty), M_PI_4); check ("atan2 (-inf,+inf) == -pi/4", FUNC(atan2) (minus_infty, plus_infty), -M_PI_4); check ("atan2 (+inf,-inf) == +3*pi/4", FUNC(atan2) (plus_infty, minus_infty), 3 * M_PI_4); check ("atan2 (-inf,-inf) == -3*pi/4", FUNC(atan2) (minus_infty, minus_infty), -3 * M_PI_4); /* FIXME: Add some specific tests */ } static void atanh_test (void) { #ifndef TEST_INLINE MATHTYPE x; #endif check ("atanh(+0) == +0", FUNC(atanh) (0), 0); #ifndef TEST_INLINE check ("atanh(-0) == -0", FUNC(atanh) (minus_zero), minus_zero); check_isinfp_exc ("atanh(+1) == +inf plus divide-by-zero exception", FUNC(atanh) (1), DIVIDE_BY_ZERO_EXCEPTION); check_isinfn_exc ("atanh(-1) == -inf plus divide-by-zero exception", FUNC(atanh) (-1), DIVIDE_BY_ZERO_EXCEPTION); x = random_greater (1.0); check_isnan_exc_ext ("atanh (x) == NaN plus invalid exception if |x| > 1", FUNC(atanh) (x), INVALID_EXCEPTION, x); x = random_less (1.0); check_isnan_exc_ext ("atanh (x) == NaN plus invalid exception if |x| > 1", FUNC(atanh) (x), INVALID_EXCEPTION, x); #endif } static void cbrt_test (void) { check ("cbrt (+0) == +0", FUNC(cbrt) (0.0), 0.0); check ("cbrt (-0) == -0", FUNC(cbrt) (minus_zero), minus_zero); #ifndef TEST_INLINE check_isinfp ("cbrt (+inf) == +inf", FUNC(cbrt) (plus_infty)); check_isinfn ("cbrt (-inf) == -inf", FUNC(cbrt) (minus_infty)); check_isnan ("cbrt (NaN) == NaN", FUNC(cbrt) (nan_value)); #endif check_eps ("cbrt (-0.001) == -0.1", FUNC(cbrt) (-0.001), -0.1, CHOOSE (5e-18L, 0, 0)); check_eps ("cbrt (8) == 2", FUNC(cbrt) (8), 2, CHOOSE (5e-17L, 0, 0)); check_eps ("cbrt (-27) == -3", FUNC(cbrt) (-27.0), -3.0, CHOOSE (3e-16L, 5e-16, 0)); check_eps ("cbrt (0.970299) == 0.99", FUNC(cbrt) (0.970299), 0.99, CHOOSE (2e-17L, 0, 0)); } static void ceil_test (void) { check ("ceil (+0) == +0", FUNC(ceil) (0.0), 0.0); check ("ceil (-0) == -0", FUNC(ceil) (minus_zero), minus_zero); check_isinfp ("ceil (+inf) == +inf", FUNC(ceil) (plus_infty)); check_isinfn ("ceil (-inf) == -inf", FUNC(ceil) (minus_infty)); check ("ceil (pi) == 4", FUNC(ceil) (M_PI), 4.0); check ("ceil (-pi) == -3", FUNC(ceil) (-M_PI), -3.0); } static void cos_test (void) { check ("cos (+0) == 1", FUNC(cos) (0), 1); check ("cos (-0) == 1", FUNC(cos) (minus_zero), 1); check_isnan_exc ("cos (+inf) == NaN plus invalid exception", FUNC(cos) (plus_infty), INVALID_EXCEPTION); check_isnan_exc ("cos (-inf) == NaN plus invalid exception", FUNC(cos) (minus_infty), INVALID_EXCEPTION); check_eps ("cos (pi/3) == 0.5", FUNC(cos) (M_PI_6 * 2.0), 0.5, CHOOSE (4e-18L, 1e-15L, 1e-7L)); check_eps ("cos (pi/2) == 0", FUNC(cos) (M_PI_2), 0, CHOOSE (1e-19L, 1e-16L, 1e-7L)); } static void cosh_test (void) { check ("cosh (+0) == 1", FUNC(cosh) (0), 1); check ("cosh (-0) == 1", FUNC(cosh) (minus_zero), 1); #ifndef TEST_INLINE check_isinfp ("cosh (+inf) == +inf", FUNC(cosh) (plus_infty)); check_isinfp ("cosh (-inf) == +inf", FUNC(cosh) (minus_infty)); #endif } static void erf_test (void) { errno = 0; FUNC(erf) (0); if (errno == ENOSYS) /* Function not implemented. */ return; check ("erf (+0) == +0", FUNC(erf) (0), 0); check ("erf (-0) == -0", FUNC(erf) (minus_zero), minus_zero); check ("erf (+inf) == +1", FUNC(erf) (plus_infty), 1); check ("erf (-inf) == -1", FUNC(erf) (minus_infty), -1); } static void erfc_test (void) { errno = 0; FUNC(erfc) (0); if (errno == ENOSYS) /* Function not implemented. */ return; check ("erfc (+inf) == 0", FUNC(erfc) (plus_infty), 0.0); check ("erfc (-inf) == 2", FUNC(erfc) (minus_infty), 2.0); check ("erfc (+0) == 1", FUNC(erfc) (0.0), 1.0); check ("erfc (-0) == 1", FUNC(erfc) (minus_zero), 1.0); } static void exp_test (void) { check ("exp (+0) == 1", FUNC(exp) (0), 1); check ("exp (-0) == 1", FUNC(exp) (minus_zero), 1); #ifndef TEST_INLINE check_isinfp ("exp (+inf) == +inf", FUNC(exp) (plus_infty)); check ("exp (-inf) == 0", FUNC(exp) (minus_infty), 0); #endif check_eps ("exp (1) == e", FUNC(exp) (1), M_E, CHOOSE (4e-18L, 5e-16, 0)); } static void exp2_test (void) { errno = 0; FUNC(exp2) (0); if (errno == ENOSYS) /* Function not implemented. */ return; check ("exp2 (+0) == 1", FUNC(exp2) (0), 1); check ("exp2 (-0) == 1", FUNC(exp2) (minus_zero), 1); check_isinfp ("exp2 (+inf) == +inf", FUNC(exp2) (plus_infty)); check ("exp2 (-inf) == 0", FUNC(exp2) (minus_infty), 0); check ("exp2 (10) == 1024", FUNC(exp2) (10), 1024); check ("exp2 (-1) == 0.5", FUNC(exp2) (-1), 0.5); check_isinfp ("exp2 (1e6) == +inf", FUNC(exp2) (1e6)); check ("exp2 (-1e6) == 0", FUNC(exp2) (-1e6), 0); } static void expm1_test (void) { check ("expm1 (+0) == 0", FUNC(expm1) (0), 0); #ifndef TEST_INLINE check ("expm1 (-0) == -0", FUNC(expm1) (minus_zero), minus_zero); check_isinfp ("expm1 (+inf) == +inf", FUNC(expm1) (plus_infty)); check ("expm1 (-inf) == -1", FUNC(expm1) (minus_infty), -1); #endif check_eps ("expm1 (1) == e-1", FUNC(expm1) (1), M_E - 1.0, CHOOSE (4e-18L, 0, 2e-7)); } static void check_frexp (const char *test_name, MATHTYPE computed, MATHTYPE expected, int comp_int, int exp_int) { MATHTYPE diff; int result; result = (check_equal (computed, expected, 0, &diff) && (comp_int == exp_int)); if (result) { if (verbose > 2) printf ("Pass: %s\n", test_name); } else { if (verbose) printf ("Fail: %s\n", test_name); if (verbose > 1) { printf ("Result:\n"); printf (" is: %.20" PRINTF_EXPR " *2^%d\n", computed, comp_int); printf (" should be: %.20" PRINTF_EXPR " *2^%d\n", expected, exp_int); printf (" difference: %.20" PRINTF_EXPR "\n", diff); } noErrors++; } fpstack_test (test_name); output_result (test_name, result, computed, expected, diff, PRINT, PRINT); } static void frexp_test (void) { int x_int; MATHTYPE result; result = FUNC(frexp) (plus_infty, &x_int); check_isinfp ("frexp (+inf, expr) == +inf", result); result = FUNC(frexp) (minus_infty, &x_int); check_isinfn ("frexp (-inf, expr) == -inf", result); result = FUNC(frexp) (nan_value, &x_int); check_isnan ("frexp (Nan, expr) == NaN", result); result = FUNC(frexp) (0, &x_int); check_frexp ("frexp: +0 == 0 * 2^0", result, 0, x_int, 0); result = FUNC(frexp) (minus_zero, &x_int); check_frexp ("frexp: -0 == -0 * 2^0", result, minus_zero, x_int, 0); result = FUNC(frexp) (12.8L, &x_int); check_frexp ("frexp: 12.8 == 0.8 * 2^4", result, 0.8L, x_int, 4); result = FUNC(frexp) (-27.34L, &x_int); check_frexp ("frexp: -27.34 == -0.854375 * 2^5", result, -0.854375L, x_int, 5); } #if __GLIBC__ < 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ < 1) /* All floating-point numbers can be put in one of these categories. */ enum { FP_NAN, #define FP_NAN FP_NAN FP_INFINITE, #define FP_INFINITE FP_INFINITE FP_ZERO, #define FP_ZERO FP_ZERO FP_SUBNORMAL, #define FP_SUBNORMAL FP_SUBNORMAL FP_NORMAL #define FP_NORMAL FP_NORMAL }; #endif static void fpclassify_test (void) { MATHTYPE x; /* fpclassify is a macro, don't give it constants as parameter */ check_bool ("fpclassify (NaN) == FP_NAN", fpclassify (nan_value) == FP_NAN); check_bool ("fpclassify (+inf) == FP_INFINITE", fpclassify (plus_infty) == FP_INFINITE); check_bool ("fpclassify (-inf) == FP_INFINITE", fpclassify (minus_infty) == FP_INFINITE); check_bool ("fpclassify (+0) == FP_ZERO", fpclassify (plus_zero) == FP_ZERO); check_bool ("fpclassify (-0) == FP_ZERO", fpclassify (minus_zero) == FP_ZERO); x = 1000.0; check_bool ("fpclassify (1000) == FP_NORMAL", fpclassify (x) == FP_NORMAL); } static void isfinite_test (void) { check_bool ("isfinite (0) != 0", isfinite (0)); check_bool ("isfinite (-0) != 0", isfinite (minus_zero)); check_bool ("isfinite (10) != 0", isfinite (10)); check_bool ("isfinite (+inf) == 0", isfinite (plus_infty) == 0); check_bool ("isfinite (-inf) == 0", isfinite (minus_infty) == 0); check_bool ("isfinite (NaN) == 0", isfinite (nan_value) == 0); } static void isnormal_test (void) { check_bool ("isnormal (0) == 0", isnormal (0) == 0); check_bool ("isnormal (-0) == 0", isnormal (minus_zero) == 0); check_bool ("isnormal (10) != 0", isnormal (10)); check_bool ("isnormal (+inf) == 0", isnormal (plus_infty) == 0); check_bool ("isnormal (-inf) == 0", isnormal (minus_infty) == 0); check_bool ("isnormal (NaN) == 0", isnormal (nan_value) == 0); } static void signbit_test (void) { MATHTYPE x; check_bool ("signbit (+0) == 0", signbit (0) == 0); check_bool ("signbit (-0) != 0", signbit (minus_zero)); check_bool ("signbit (+inf) == 0", signbit (plus_infty) == 0); check_bool ("signbit (-inf) != 0", signbit (minus_infty)); x = random_less (0); check_bool ("signbit (x) != 0 for x < 0", signbit (x)); x = random_greater (0); check_bool ("signbit (x) == 0 for x > 0", signbit (x) == 0); } /* gamma has different semantics depending on _LIB_VERSION: if _LIB_VERSION is _SVID, gamma is just an alias for lgamma, otherwise gamma is the real gamma function as definied in ISO C 9X. */ static void gamma_test (void) { int save_lib_version = _LIB_VERSION; errno = 0; FUNC(gamma) (1); if (errno == ENOSYS) /* Function not implemented. */ return; feclearexcept (FE_ALL_EXCEPT); _LIB_VERSION = _SVID_; check_isinfp ("gamma (+inf) == +inf", FUNC(gamma) (plus_infty)); check_isinfp_exc ("gamma (0) == +inf plus divide by zero exception", FUNC(gamma) (0), DIVIDE_BY_ZERO_EXCEPTION); check_isinfp_exc ("gamma (x) == +inf plus divide by zero exception for integer x <= 0", FUNC(gamma) (-3), DIVIDE_BY_ZERO_EXCEPTION); check_isnan_exc ("gamma (-inf) == NaN plus invalid exception", FUNC(gamma) (minus_infty), INVALID_EXCEPTION); signgam = 0; check ("gamma (1) == 0", FUNC(gamma) (1), 0); check_int ("gamma (0) sets signgam to 1", signgam, 1); signgam = 0; check ("gamma (3) == M_LN2", FUNC(gamma) (3), M_LN2); check_int ("gamma (3) sets signgam to 1", signgam, 1); signgam = 0; check_eps ("gamma (0.5) == log(sqrt(pi))", FUNC(gamma) (0.5), FUNC(log) (FUNC(sqrt) (M_PI)), CHOOSE (0, 1e-15, 1e-7)); check_int ("gamma (0.5) sets signgam to 1", signgam, 1); signgam = 0; check_eps ("gamma (-0.5) == log(2*sqrt(pi))", FUNC(gamma) (-0.5), FUNC(log) (2*FUNC(sqrt) (M_PI)), CHOOSE (0, 1e-15, 0)); check_int ("gamma (-0.5) sets signgam to -1", signgam, -1); _LIB_VERSION = _IEEE_; check_isinfp ("gamma (+inf) == +inf", FUNC(gamma) (plus_infty)); check_isnan_exc ("gamma (0) == NaN plus invalid exception", FUNC(gamma) (0), INVALID_EXCEPTION); check_isnan_exc_ext ("gamma (x) == NaN plus invalid exception for integer x <= 0", FUNC(gamma) (-2), INVALID_EXCEPTION, -2); check_isnan_exc ("gamma (-inf) == NaN plus invalid exception", FUNC(gamma) (minus_infty), INVALID_EXCEPTION); check_eps ("gamma (0.5) == sqrt(pi)", FUNC(gamma) (0.5), FUNC(sqrt) (M_PI), CHOOSE (0, 5e-16, 2e-7)); check_eps ("gamma (-0.5) == -2*sqrt(pi)", FUNC(gamma) (-0.5), -2*FUNC(sqrt) (M_PI), CHOOSE (0, 5e-16, 3e-7)); check ("gamma (1) == 1", FUNC(gamma) (1), 1); check ("gamma (4) == 6", FUNC(gamma) (4), 6); _LIB_VERSION = save_lib_version; } static void lgamma_test (void) { errno = 0; FUNC(lgamma) (0); if (errno == ENOSYS) /* Function not implemented. */ return; feclearexcept (FE_ALL_EXCEPT); check_isinfp ("lgamma (+inf) == +inf", FUNC(lgamma) (plus_infty)); check_isinfp_exc ("lgamma (0) == +inf plus divide by zero exception", FUNC(lgamma) (0), DIVIDE_BY_ZERO_EXCEPTION); check_isinfp_exc ("lgamma (x) == +inf plus divide by zero exception for integer x <= 0", FUNC(lgamma) (-3), DIVIDE_BY_ZERO_EXCEPTION); check_isnan_exc ("lgamma (-inf) == NaN plus invalid exception", FUNC(lgamma) (minus_infty), INVALID_EXCEPTION); signgam = 0; check ("lgamma (1) == 0", FUNC(lgamma) (1), 0); check_int ("lgamma (0) sets signgam to 1", signgam, 1); signgam = 0; check ("lgamma (3) == M_LN2", FUNC(lgamma) (3), M_LN2); check_int ("lgamma (3) sets signgam to 1", signgam, 1); signgam = 0; check_eps ("lgamma (0.5) == log(sqrt(pi))", FUNC(lgamma) (0.5), FUNC(log) (FUNC(sqrt) (M_PI)), CHOOSE (0, 1e-15, 1e-7)); check_int ("lgamma (0.5) sets signgam to 1", signgam, 1); signgam = 0; check_eps ("lgamma (-0.5) == log(2*sqrt(pi))", FUNC(lgamma) (-0.5), FUNC(log) (2*FUNC(sqrt) (M_PI)), CHOOSE (0, 1e-15, 0)); check_int ("lgamma (-0.5) sets signgam to -1", signgam, -1); } static void ilogb_test (void) { int i; check_int ("ilogb (1) == 0", FUNC(ilogb) (1), 0); check_int ("ilogb (e) == 1", FUNC(ilogb) (M_E), 1); check_int ("ilogb (1024) == 10", FUNC(ilogb) (1024), 10); check_int ("ilogb (-2000) == 10", FUNC(ilogb) (-2000), 10); /* XXX We have a problem here: the standard does not tell us whether exceptions are allowed/required. ignore them for now. */ i = FUNC (ilogb) (0.0); feclearexcept (FE_ALL_EXCEPT); check_int ("ilogb (0) == FP_ILOGB0", i, FP_ILOGB0); i = FUNC(ilogb) (nan_value); feclearexcept (FE_ALL_EXCEPT); check_int ("ilogb (NaN) == FP_ILOGBNAN", i, FP_ILOGBNAN); } static void ldexp_test (void) { MATHTYPE x; check ("ldexp (0, 0) == 0", FUNC(ldexp) (0, 0), 0); check_isinfp ("ldexp (+inf, 1) == +inf", FUNC(ldexp) (plus_infty, 1)); check_isinfn ("ldexp (-inf, 1) == -inf", FUNC(ldexp) (minus_infty, 1)); check_isnan ("ldexp (NaN, 1) == NaN", FUNC(ldexp) (nan_value, 1)); check ("ldexp (0.8, 4) == 12.8", FUNC(ldexp) (0.8L, 4), 12.8L); check ("ldexp (-0.854375, 5) == -27.34", FUNC(ldexp) (-0.854375L, 5), -27.34L); x = random_greater (0.0); check_ext ("ldexp (x, 0) == x", FUNC(ldexp) (x, 0L), x, x); } static void log_test (void) { check_isinfn_exc ("log (+0) == -inf plus divide-by-zero exception", FUNC(log) (0), DIVIDE_BY_ZERO_EXCEPTION); check_isinfn_exc ("log (-0) == -inf plus divide-by-zero exception", FUNC(log) (minus_zero), DIVIDE_BY_ZERO_EXCEPTION); check ("log (1) == 0", FUNC(log) (1), 0); check_isnan_exc ("log (x) == NaN plus invalid exception if x < 0", FUNC(log) (-1), INVALID_EXCEPTION); check_isinfp ("log (+inf) == +inf", FUNC(log) (plus_infty)); check_eps ("log (e) == 1", FUNC(log) (M_E), 1, CHOOSE (1e-18L, 0, 9e-8L)); check_eps ("log (1/e) == -1", FUNC(log) (1.0 / M_E), -1, CHOOSE (2e-18L, 0, 0)); check ("log (2) == M_LN2", FUNC(log) (2), M_LN2); check_eps ("log (10) == M_LN10", FUNC(log) (10), M_LN10, CHOOSE (1e-18L, 0, 0)); } static void log10_test (void) { check_isinfn_exc ("log10 (+0) == -inf plus divide-by-zero exception", FUNC(log10) (0), DIVIDE_BY_ZERO_EXCEPTION); check_isinfn_exc ("log10 (-0) == -inf plus divide-by-zero exception", FUNC(log10) (minus_zero), DIVIDE_BY_ZERO_EXCEPTION); check ("log10 (1) == +0", FUNC(log10) (1), 0); check_isnan_exc ("log10 (x) == NaN plus invalid exception if x < 0", FUNC(log10) (-1), INVALID_EXCEPTION); check_isinfp ("log10 (+inf) == +inf", FUNC(log10) (plus_infty)); check_eps ("log10 (0.1) == -1", FUNC(log10) (0.1L), -1, CHOOSE (1e-18L, 0, 0)); check_eps ("log10 (10) == 1", FUNC(log10) (10.0), 1, CHOOSE (1e-18L, 0, 0)); check_eps ("log10 (100) == 2", FUNC(log10) (100.0), 2, CHOOSE (1e-18L, 0, 0)); check ("log10 (10000) == 4", FUNC(log10) (10000.0), 4); check_eps ("log10 (e) == M_LOG10E", FUNC(log10) (M_E), M_LOG10E, CHOOSE (1e-18, 0, 9e-8)); } static void log1p_test (void) { check ("log1p (+0) == +0", FUNC(log1p) (0), 0); check ("log1p (-0) == -0", FUNC(log1p) (minus_zero), minus_zero); check_isinfn_exc ("log1p (-1) == -inf plus divide-by-zero exception", FUNC(log1p) (-1), DIVIDE_BY_ZERO_EXCEPTION); check_isnan_exc ("log1p (x) == NaN plus invalid exception if x < -1", FUNC(log1p) (-2), INVALID_EXCEPTION); check_isinfp ("log1p (+inf) == +inf", FUNC(log1p) (plus_infty)); check_eps ("log1p (e-1) == 1", FUNC(log1p) (M_E - 1.0), 1, CHOOSE (1e-18L, 0, 0)); } static void log2_test (void) { check_isinfn_exc ("log2 (+0) == -inf plus divide-by-zero exception", FUNC(log2) (0), DIVIDE_BY_ZERO_EXCEPTION); check_isinfn_exc ("log2 (-0) == -inf plus divide-by-zero exception", FUNC(log2) (minus_zero), DIVIDE_BY_ZERO_EXCEPTION); check ("log2 (1) == +0", FUNC(log2) (1), 0); check_isnan_exc ("log2 (x) == NaN plus invalid exception if x < 0", FUNC(log2) (-1), INVALID_EXCEPTION); check_isinfp ("log2 (+inf) == +inf", FUNC(log2) (plus_infty)); check_eps ("log2 (e) == M_LOG2E", FUNC(log2) (M_E), M_LOG2E, CHOOSE (1e-18L, 0, 0)); check ("log2 (2) == 1", FUNC(log2) (2.0), 1); check_eps ("log2 (16) == 4", FUNC(log2) (16.0), 4, CHOOSE (1e-18L, 0, 0)); check ("log2 (256) == 8", FUNC(log2) (256.0), 8); } static void logb_test (void) { check_isinfp ("logb (+inf) == +inf", FUNC(logb) (plus_infty)); check_isinfp ("logb (-inf) == +inf", FUNC(logb) (minus_infty)); check_isinfn_exc ("logb (+0) == -inf plus divide-by-zero exception", FUNC(logb) (0), DIVIDE_BY_ZERO_EXCEPTION); check_isinfn_exc ("logb (-0) == -inf plus divide-by-zero exception", FUNC(logb) (minus_zero), DIVIDE_BY_ZERO_EXCEPTION); check ("logb (1) == 0", FUNC(logb) (1), 0); check ("logb (e) == 1", FUNC(logb) (M_E), 1); check ("logb (1024) == 10", FUNC(logb) (1024), 10); check ("logb (-2000) == 10", FUNC(logb) (-2000), 10); } static void modf_test (void) { MATHTYPE result, intpart; result = FUNC(modf) (plus_infty, &intpart); check ("modf (+inf, &x) returns +0", result, 0); check_isinfp ("modf (+inf, &x) set x to +inf", intpart); result = FUNC(modf) (minus_infty, &intpart); check ("modf (-inf, &x) returns -0", result, minus_zero); check_isinfn ("modf (-inf, &x) sets x to -inf", intpart); result = FUNC(modf) (nan_value, &intpart); check_isnan ("modf (NaN, &x) returns NaN", result); check_isnan ("modf (NaN, &x) sets x to NaN", intpart); result = FUNC(modf) (0, &intpart); check ("modf (0, &x) returns 0", result, 0); check ("modf (0, &x) sets x to 0", intpart, 0); result = FUNC(modf) (minus_zero, &intpart); check ("modf (-0, &x) returns -0", result, minus_zero); check ("modf (-0, &x) sets x to -0", intpart, minus_zero); result = FUNC(modf) (2.5, &intpart); check ("modf (2.5, &x) returns 0.5", result, 0.5); check ("modf (2.5, &x) sets x to 2", intpart, 2); result = FUNC(modf) (-2.5, &intpart); check ("modf (-2.5, &x) returns -0.5", result, -0.5); check ("modf (-2.5, &x) sets x to -2", intpart, -2); } static void scalb_test (void) { MATHTYPE x; check_isnan ("scalb (2, 0.5) == NaN", FUNC(scalb) (2, 0.5)); check_isnan ("scalb (3, -2.5) == NaN", FUNC(scalb) (3, -2.5)); check_isnan ("scalb (0, NaN) == NaN", FUNC(scalb) (0, nan_value)); check_isnan ("scalb (1, NaN) == NaN", FUNC(scalb) (1, nan_value)); x = random_greater (0.0); check ("scalb (x, 0) == 0", FUNC(scalb) (x, 0), x); x = random_greater (0.0); check ("scalb (-x, 0) == 0", FUNC(scalb) (-x, 0), -x); check_isnan_exc ("scalb (+0, +inf) == NaN plus invalid exception", FUNC(scalb) (0, plus_infty), INVALID_EXCEPTION); check_isnan_exc ("scalb (-0, +inf) == NaN plus invalid exception", FUNC(scalb) (minus_zero, plus_infty), INVALID_EXCEPTION); check ("scalb (+0, 2) == +0", FUNC(scalb) (0, 2), 0); check ("scalb (-0, 4) == -0", FUNC(scalb) (minus_zero, -4), minus_zero); check ("scalb (+0, 0) == +0", FUNC(scalb) (0, 0), 0); check ("scalb (-0, 0) == -0", FUNC(scalb) (minus_zero, 0), minus_zero); check ("scalb (+0, -1) == +0", FUNC(scalb) (0, -1), 0); check ("scalb (-0, -10) == -0", FUNC(scalb) (minus_zero, -10), minus_zero); check ("scalb (+0, -inf) == +0", FUNC(scalb) (0, minus_infty), 0); check ("scalb (-0, -inf) == -0", FUNC(scalb) (minus_zero, minus_infty), minus_zero); check_isinfp ("scalb (+inf, -1) == +inf", FUNC(scalb) (plus_infty, -1)); check_isinfn ("scalb (-inf, -10) == -inf", FUNC(scalb) (minus_infty, -10)); check_isinfp ("scalb (+inf, 0) == +inf", FUNC(scalb) (plus_infty, 0)); check_isinfn ("scalb (-inf, 0) == -inf", FUNC(scalb) (minus_infty, 0)); check_isinfp ("scalb (+inf, 2) == +inf", FUNC(scalb) (plus_infty, 2)); check_isinfn ("scalb (-inf, 100) == -inf", FUNC(scalb) (minus_infty, 100)); x = random_greater (0.0); check ("scalb (x, -inf) == 0", FUNC(scalb) (x, minus_infty), 0.0); check ("scalb (-x, -inf) == -0", FUNC(scalb) (-x, minus_infty), minus_zero); x = random_greater (0.0); check_isinfp ("scalb (x, +inf) == +inf", FUNC(scalb) (x, plus_infty)); x = random_greater (0.0); check_isinfn ("scalb (-x, +inf) == -inf", FUNC(scalb) (-x, plus_infty)); check_isinfp ("scalb (+inf, +inf) == +inf", FUNC(scalb) (plus_infty, plus_infty)); check_isinfn ("scalb (-inf, +inf) == -inf", FUNC(scalb) (minus_infty, plus_infty)); check_isnan ("scalb (+inf, -inf) == NaN", FUNC(scalb) (plus_infty, minus_infty)); check_isnan ("scalb (-inf, -inf) == NaN", FUNC(scalb) (minus_infty, minus_infty)); check_isnan ("scalb (NaN, 1) == NaN", FUNC(scalb) (nan_value, 1)); check_isnan ("scalb (1, NaN) == NaN", FUNC(scalb) (1, nan_value)); check_isnan ("scalb (NaN, 0) == NaN", FUNC(scalb) (nan_value, 0)); check_isnan ("scalb (0, NaN) == NaN", FUNC(scalb) (0, nan_value)); check_isnan ("scalb (NaN, +inf) == NaN", FUNC(scalb) (nan_value, plus_infty)); check_isnan ("scalb (+inf, NaN) == NaN", FUNC(scalb) (plus_infty, nan_value)); check_isnan ("scalb (NaN, NaN) == NaN", FUNC(scalb) (nan_value, nan_value)); check ("scalb (0.8, 4) == 12.8", FUNC(scalb) (0.8L, 4), 12.8L); check ("scalb (-0.854375, 5) == -27.34", FUNC(scalb) (-0.854375L, 5), -27.34L); } static void scalbn_test (void) { MATHTYPE x; check ("scalbn (0, 0) == 0", FUNC(scalbn) (0, 0), 0); check_isinfp ("scalbn (+inf, 1) == +inf", FUNC(scalbn) (plus_infty, 1)); check_isinfn ("scalbn (-inf, 1) == -inf", FUNC(scalbn) (minus_infty, 1)); check_isnan ("scalbn (NaN, 1) == NaN", FUNC(scalbn) (nan_value, 1)); check ("scalbn (0.8, 4) == 12.8", FUNC(scalbn) (0.8L, 4), 12.8L); check ("scalbn (-0.854375, 5) == -27.34", FUNC(scalbn) (-0.854375L, 5), -27.34L); x = random_greater (0.0); check_ext ("scalbn (x, 0) == x", FUNC(scalbn) (x, 0L), x, x); } static void sin_test (void) { check ("sin (+0) == +0", FUNC(sin) (0), 0); check ("sin (-0) == -0", FUNC(sin) (minus_zero), minus_zero); check_isnan_exc ("sin (+inf) == NaN plus invalid exception", FUNC(sin) (plus_infty), INVALID_EXCEPTION); check_isnan_exc ("sin (-inf) == NaN plus invalid exception", FUNC(sin) (minus_infty), INVALID_EXCEPTION); check_eps ("sin (pi/6) == 0.5", FUNC(sin) (M_PI_6), 0.5,CHOOSE (4e-18L, 0, 0)); check ("sin (pi/2) == 1", FUNC(sin) (M_PI_2), 1); } static void sinh_test (void) { check ("sinh (+0) == +0", FUNC(sinh) (0), 0); #ifndef TEST_INLINE check ("sinh (-0) == -0", FUNC(sinh) (minus_zero), minus_zero); check_isinfp ("sinh (+inf) == +inf", FUNC(sinh) (plus_infty)); check_isinfn ("sinh (-inf) == -inf", FUNC(sinh) (minus_infty)); #endif } static void sincos_test (void) { MATHTYPE sin_res, cos_res; fenv_t fenv; FUNC(sincos) (0, &sin_res, &cos_res); fegetenv (&fenv); check ("sincos (+0, &sin, &cos) puts +0 in sin", sin_res, 0); fesetenv (&fenv); check ("sincos (+0, &sin, &cos) puts 1 in cos", cos_res, 1); FUNC(sincos) (minus_zero, &sin_res, &cos_res); fegetenv (&fenv); check ("sincos (-0, &sin, &cos) puts -0 in sin", sin_res, minus_zero); fesetenv (&fenv); check ("sincos (-0, &sin, &cos) puts 1 in cos", cos_res, 1); FUNC(sincos) (plus_infty, &sin_res, &cos_res); fegetenv (&fenv); check_isnan_exc ("sincos (+inf, &sin, &cos) puts NaN in sin plus invalid exception", sin_res, INVALID_EXCEPTION); fesetenv (&fenv); check_isnan_exc ("sincos (+inf, &sin, &cos) puts NaN in cos plus invalid exception", cos_res, INVALID_EXCEPTION); FUNC(sincos) (minus_infty, &sin_res, &cos_res); fegetenv (&fenv); check_isnan_exc ("sincos (-inf,&sin, &cos) puts NaN in sin plus invalid exception", sin_res, INVALID_EXCEPTION); fesetenv (&fenv); check_isnan_exc ("sincos (-inf,&sin, &cos) puts NaN in cos plus invalid exception", cos_res, INVALID_EXCEPTION); FUNC(sincos) (M_PI_2, &sin_res, &cos_res); fegetenv (&fenv); check ("sincos (pi/2, &sin, &cos) puts 1 in sin", sin_res, 1); fesetenv (&fenv); check_eps ("sincos (pi/2, &sin, &cos) puts 0 in cos", cos_res, 0, CHOOSE (1e-18L, 1e-16, 1e-7)); FUNC(sincos) (M_PI_6, &sin_res, &cos_res); check_eps ("sincos (pi/6, &sin, &cos) puts 0.5 in sin", sin_res, 0.5, CHOOSE (5e-18L, 0, 0)); FUNC(sincos) (M_PI_6*2.0, &sin_res, &cos_res); check_eps ("sincos (pi/3, &sin, &cos) puts 0.5 in cos", cos_res, 0.5, CHOOSE (5e-18L, 1e-15, 1e-7)); } static void tan_test (void) { check ("tan (+0) == +0", FUNC(tan) (0), 0); check ("tan (-0) == -0", FUNC(tan) (minus_zero), minus_zero); check_isnan_exc ("tan (+inf) == NaN plus invalid exception", FUNC(tan) (plus_infty), INVALID_EXCEPTION); check_isnan_exc ("tan (-inf) == NaN plus invalid exception", FUNC(tan) (minus_infty), INVALID_EXCEPTION); check_eps ("tan (pi/4) == 1", FUNC(tan) (M_PI_4), 1, CHOOSE (2e-18L, 1e-15L, 0)); } static void tanh_test (void) { check ("tanh (+0) == +0", FUNC(tanh) (0), 0); #ifndef TEST_INLINE check ("tanh (-0) == -0", FUNC(tanh) (minus_zero), minus_zero); check ("tanh (+inf) == +1", FUNC(tanh) (plus_infty), 1); check ("tanh (-inf) == -1", FUNC(tanh) (minus_infty), -1); #endif } static void fabs_test (void) { check ("fabs (+0) == +0", FUNC(fabs) (0), 0); check ("fabs (-0) == +0", FUNC(fabs) (minus_zero), 0); check_isinfp ("fabs (+inf) == +inf", FUNC(fabs) (plus_infty)); check_isinfp ("fabs (-inf) == +inf", FUNC(fabs) (minus_infty)); check ("fabs (+38) == 38", FUNC(fabs) (38.0), 38.0); check ("fabs (-e) == e", FUNC(fabs) (-M_E), M_E); } static void floor_test (void) { check ("floor (+0) == +0", FUNC(floor) (0.0), 0.0); check ("floor (-0) == -0", FUNC(floor) (minus_zero), minus_zero); check_isinfp ("floor (+inf) == +inf", FUNC(floor) (plus_infty)); check_isinfn ("floor (-inf) == -inf", FUNC(floor) (minus_infty)); check ("floor (pi) == 3", FUNC(floor) (M_PI), 3.0); check ("floor (-pi) == -4", FUNC(floor) (-M_PI), -4.0); } static void hypot_test (void) { MATHTYPE a; a = random_greater (0); check_isinfp_ext ("hypot (+inf, x) == +inf", FUNC(hypot) (plus_infty, a), a); check_isinfp_ext ("hypot (-inf, x) == +inf", FUNC(hypot) (minus_infty, a), a); #ifndef TEST_INLINE check_isinfp ("hypot (+inf, NaN) == +inf", FUNC(hypot) (minus_infty, nan_value)); check_isinfp ("hypot (-inf, NaN) == +inf", FUNC(hypot) (minus_infty, nan_value)); #endif check_isnan ("hypot (NaN, NaN) == NaN", FUNC(hypot) (nan_value, nan_value)); a = FUNC(hypot) (12.4L, 0.7L); check ("hypot (x,y) == hypot (y,x)", FUNC(hypot) (0.7L, 12.4L), a); check ("hypot (x,y) == hypot (-x,y)", FUNC(hypot) (-12.4L, 0.7L), a); check ("hypot (x,y) == hypot (-y,x)", FUNC(hypot) (-0.7L, 12.4L), a); check ("hypot (x,y) == hypot (-x,-y)", FUNC(hypot) (-12.4L, -0.7L), a); check ("hypot (x,y) == hypot (-y,-x)", FUNC(hypot) (-0.7L, -12.4L), a); check ("hypot (x,0) == fabs (x)", FUNC(hypot) (-0.7L, 0), 0.7L); check ("hypot (x,0) == fabs (x)", FUNC(hypot) (0.7L, 0), 0.7L); check ("hypot (x,0) == fabs (x)", FUNC(hypot) (-1.0L, 0), 1.0L); check ("hypot (x,0) == fabs (x)", FUNC(hypot) (1.0L, 0), 1.0L); check ("hypot (x,0) == fabs (x)", FUNC(hypot) (-5.7e7L, 0), 5.7e7L); check ("hypot (x,0) == fabs (x)", FUNC(hypot) (5.7e7L, 0), 5.7e7L); } static void pow_test (void) { MATHTYPE x; check ("pow (+0, +0) == 1", FUNC(pow) (0, 0), 1); check ("pow (+0, -0) == 1", FUNC(pow) (0, minus_zero), 1); check ("pow (-0, +0) == 1", FUNC(pow) (minus_zero, 0), 1); check ("pow (-0, -0) == 1", FUNC(pow) (minus_zero, minus_zero), 1); check ("pow (+10, +0) == 1", FUNC(pow) (10, 0), 1); check ("pow (+10, -0) == 1", FUNC(pow) (10, minus_zero), 1); check ("pow (-10, +0) == 1", FUNC(pow) (-10, 0), 1); check ("pow (-10, -0) == 1", FUNC(pow) (-10, minus_zero), 1); check ("pow (NaN, +0) == 1", FUNC(pow) (nan_value, 0), 1); check ("pow (NaN, -0) == 1", FUNC(pow) (nan_value, minus_zero), 1); #ifndef TEST_INLINE check_isinfp ("pow (+1.1, +inf) == +inf", FUNC(pow) (1.1, plus_infty)); check_isinfp ("pow (+inf, +inf) == +inf", FUNC(pow) (plus_infty, plus_infty)); check_isinfp ("pow (-1.1, +inf) == +inf", FUNC(pow) (-1.1, plus_infty)); check_isinfp ("pow (-inf, +inf) == +inf", FUNC(pow) (minus_infty, plus_infty)); check ("pow (0.9, +inf) == +0", FUNC(pow) (0.9L, plus_infty), 0); check ("pow (1e-7, +inf) == +0", FUNC(pow) (1e-7L, plus_infty), 0); check ("pow (-0.9, +inf) == +0", FUNC(pow) (-0.9L, plus_infty), 0); check ("pow (-1e-7, +inf) == +0", FUNC(pow) (-1e-7L, plus_infty), 0); check ("pow (+1.1, -inf) == 0", FUNC(pow) (1.1, minus_infty), 0); check ("pow (+inf, -inf) == 0", FUNC(pow) (plus_infty, minus_infty), 0); check ("pow (-1.1, -inf) == 0", FUNC(pow) (-1.1, minus_infty), 0); check ("pow (-inf, -inf) == 0", FUNC(pow) (minus_infty, minus_infty), 0); check_isinfp ("pow (0.9, -inf) == +inf", FUNC(pow) (0.9L, minus_infty)); check_isinfp ("pow (1e-7, -inf) == +inf", FUNC(pow) (1e-7L, minus_infty)); check_isinfp ("pow (-0.9, -inf) == +inf", FUNC(pow) (-0.9L, minus_infty)); check_isinfp ("pow (-1e-7, -inf) == +inf", FUNC(pow) (-1e-7L, minus_infty)); check_isinfp ("pow (+inf, 1e-7) == +inf", FUNC(pow) (plus_infty, 1e-7L)); check_isinfp ("pow (+inf, 1) == +inf", FUNC(pow) (plus_infty, 1)); check_isinfp ("pow (+inf, 1e7) == +inf", FUNC(pow) (plus_infty, 1e7L)); check ("pow (+inf, -1e-7) == 0", FUNC(pow) (plus_infty, -1e-7L), 0); check ("pow (+inf, -1) == 0", FUNC(pow) (plus_infty, -1), 0); check ("pow (+inf, -1e7) == 0", FUNC(pow) (plus_infty, -1e7L), 0); check_isinfn ("pow (-inf, 1) == -inf", FUNC(pow) (minus_infty, 1)); check_isinfn ("pow (-inf, 11) == -inf", FUNC(pow) (minus_infty, 11)); check_isinfn ("pow (-inf, 1001) == -inf", FUNC(pow) (minus_infty, 1001)); check_isinfp ("pow (-inf, 2) == +inf", FUNC(pow) (minus_infty, 2)); check_isinfp ("pow (-inf, 12) == +inf", FUNC(pow) (minus_infty, 12)); check_isinfp ("pow (-inf, 1002) == +inf", FUNC(pow) (minus_infty, 1002)); check_isinfp ("pow (-inf, 0.1) == +inf", FUNC(pow) (minus_infty, 0.1)); check_isinfp ("pow (-inf, 1.1) == +inf", FUNC(pow) (minus_infty, 1.1)); check_isinfp ("pow (-inf, 11.1) == +inf", FUNC(pow) (minus_infty, 11.1)); check_isinfp ("pow (-inf, 1001.1) == +inf", FUNC(pow) (minus_infty, 1001.1)); check ("pow (-inf, -1) == -0", FUNC(pow) (minus_infty, -1), minus_zero); check ("pow (-inf, -11) == -0", FUNC(pow) (minus_infty, -11), minus_zero); check ("pow (-inf, -1001) == -0", FUNC(pow) (minus_infty, -1001), minus_zero); check ("pow (-inf, -2) == +0", FUNC(pow) (minus_infty, -2), 0); check ("pow (-inf, -12) == +0", FUNC(pow) (minus_infty, -12), 0); check ("pow (-inf, -1002) == +0", FUNC(pow) (minus_infty, -1002), 0); check ("pow (-inf, -0.1) == +0", FUNC(pow) (minus_infty, -0.1), 0); check ("pow (-inf, -1.1) == +0", FUNC(pow) (minus_infty, -1.1), 0); check ("pow (-inf, -11.1) == +0", FUNC(pow) (minus_infty, -11.1), 0); check ("pow (-inf, -1001.1) == +0", FUNC(pow) (minus_infty, -1001.1), 0); check_isnan ("pow (NaN, NaN) == NaN", FUNC(pow) (nan_value, nan_value)); check_isnan ("pow (0, NaN) == NaN", FUNC(pow) (0, nan_value)); check_isnan ("pow (1, NaN) == NaN", FUNC(pow) (1, nan_value)); check_isnan ("pow (-1, NaN) == NaN", FUNC(pow) (-1, nan_value)); check_isnan ("pow (NaN, 1) == NaN", FUNC(pow) (nan_value, 1)); check_isnan ("pow (NaN, -1) == NaN", FUNC(pow) (nan_value, -1)); x = random_greater (0.0); check_isnan_ext ("pow (x, NaN) == NaN", FUNC(pow) (x, nan_value), x); check_isnan_exc ("pow (+1, +inf) == NaN plus invalid exception", FUNC(pow) (1, plus_infty), INVALID_EXCEPTION); check_isnan_exc ("pow (-1, +inf) == NaN plus invalid exception", FUNC(pow) (-1, plus_infty), INVALID_EXCEPTION); check_isnan_exc ("pow (+1, -inf) == NaN plus invalid exception", FUNC(pow) (1, minus_infty), INVALID_EXCEPTION); check_isnan_exc ("pow (-1, -inf) == NaN plus invalid exception", FUNC(pow) (-1, minus_infty), INVALID_EXCEPTION); check_isnan_exc ("pow (-0.1, 1.1) == NaN plus invalid exception", FUNC(pow) (-0.1, 1.1), INVALID_EXCEPTION); check_isnan_exc ("pow (-0.1, -1.1) == NaN plus invalid exception", FUNC(pow) (-0.1, -1.1), INVALID_EXCEPTION); check_isnan_exc ("pow (-10.1, 1.1) == NaN plus invalid exception", FUNC(pow) (-10.1, 1.1), INVALID_EXCEPTION); check_isnan_exc ("pow (-10.1, -1.1) == NaN plus invalid exception", FUNC(pow) (-10.1, -1.1), INVALID_EXCEPTION); check_isinfp_exc ("pow (+0, -1) == +inf plus divide-by-zero exception", FUNC(pow) (0, -1), DIVIDE_BY_ZERO_EXCEPTION); check_isinfp_exc ("pow (+0, -11) == +inf plus divide-by-zero exception", FUNC(pow) (0, -11), DIVIDE_BY_ZERO_EXCEPTION); check_isinfn_exc ("pow (-0, -1) == -inf plus divide-by-zero exception", FUNC(pow) (minus_zero, -1), DIVIDE_BY_ZERO_EXCEPTION); check_isinfn_exc ("pow (-0, -11) == -inf plus divide-by-zero exception", FUNC(pow) (minus_zero, -11), DIVIDE_BY_ZERO_EXCEPTION); check_isinfp_exc ("pow (+0, -2) == +inf plus divide-by-zero exception", FUNC(pow) (0, -2), DIVIDE_BY_ZERO_EXCEPTION); check_isinfp_exc ("pow (+0, -11.1) == +inf plus divide-by-zero exception", FUNC(pow) (0, -11.1), DIVIDE_BY_ZERO_EXCEPTION); check_isinfp_exc ("pow (-0, -2) == +inf plus divide-by-zero exception", FUNC(pow) (minus_zero, -2), DIVIDE_BY_ZERO_EXCEPTION); check_isinfp_exc ("pow (-0, -11.1) == +inf plus divide-by-zero exception", FUNC(pow) (minus_zero, -11.1), DIVIDE_BY_ZERO_EXCEPTION); #endif check ("pow (+0, 1) == +0", FUNC(pow) (0, 1), 0); check ("pow (+0, 11) == +0", FUNC(pow) (0, 11), 0); #ifndef TEST_INLINE check ("pow (-0, 1) == -0", FUNC(pow) (minus_zero, 1), minus_zero); check ("pow (-0, 11) == -0", FUNC(pow) (minus_zero, 11), minus_zero); #endif check ("pow (+0, 2) == +0", FUNC(pow) (0, 2), 0); check ("pow (+0, 11.1) == +0", FUNC(pow) (0, 11.1), 0); #ifndef TEST_INLINE check ("pow (-0, 2) == +0", FUNC(pow) (minus_zero, 2), 0); check ("pow (-0, 11.1) == +0", FUNC(pow) (minus_zero, 11.1), 0); x = random_greater (1.0); check_isinfp_ext ("pow (x, +inf) == +inf for |x| > 1", FUNC(pow) (x, plus_infty), x); x = random_value (-1.0, 1.0); check_ext ("pow (x, +inf) == +0 for |x| < 1", FUNC(pow) (x, plus_infty), 0.0, x); x = random_greater (1.0); check_ext ("pow (x, -inf) == +0 for |x| > 1", FUNC(pow) (x, minus_infty), 0.0, x); x = random_value (-1.0, 1.0); check_isinfp_ext ("pow (x, -inf) == +inf for |x| < 1", FUNC(pow) (x, minus_infty), x); x = random_greater (0.0); check_isinfp_ext ("pow (+inf, y) == +inf for y > 0", FUNC(pow) (plus_infty, x), x); x = random_less (0.0); check_ext ("pow (+inf, y) == +0 for y < 0", FUNC(pow) (plus_infty, x), 0.0, x); x = (rand () % 1000000) * 2.0 + 1; /* Get random odd integer > 0 */ check_isinfn_ext ("pow (-inf, y) == -inf for y an odd integer > 0", FUNC(pow) (minus_infty, x), x); x = ((rand () % 1000000) + 1) * 2.0; /* Get random even integer > 1 */ check_isinfp_ext ("pow (-inf, y) == +inf for y > 0 and not an odd integer", FUNC(pow) (minus_infty, x), x); x = -((rand () % 1000000) * 2.0 + 1); /* Get random odd integer < 0 */ check_ext ("pow (-inf, y) == -0 for y an odd integer < 0", FUNC(pow) (minus_infty, x), minus_zero, x); x = ((rand () % 1000000) + 1) * -2.0; /* Get random even integer < 0 */ check_ext ("pow (-inf, y) == +0 for y < 0 and not an odd integer", FUNC(pow) (minus_infty, x), 0.0, x); #endif x = (rand () % 1000000) * 2.0 + 1; /* Get random odd integer > 0 */ check_ext ("pow (+0, y) == +0 for y an odd integer > 0", FUNC(pow) (0.0, x), 0.0, x); #ifndef TEST_INLINE x = (rand () % 1000000) * 2.0 + 1; /* Get random odd integer > 0 */ check_ext ("pow (-0, y) == -0 for y an odd integer > 0", FUNC(pow) (minus_zero, x), minus_zero, x); #endif x = ((rand () % 1000000) + 1) * 2.0; /* Get random even integer > 1 */ check_ext ("pow (+0, y) == +0 for y > 0 and not an odd integer", FUNC(pow) (0.0, x), 0.0, x); x = ((rand () % 1000000) + 1) * 2.0; /* Get random even integer > 1 */ check_ext ("pow (-0, y) == +0 for y > 0 and not an odd integer", FUNC(pow) (minus_zero, x), 0.0, x); } static void fdim_test (void) { check ("fdim (+0, +0) = +0", FUNC(fdim) (0, 0), 0); check ("fdim (9, 0) = 9", FUNC(fdim) (9, 0), 9); check ("fdim (0, 9) = 0", FUNC(fdim) (0, 9), 0); check ("fdim (-9, 0) = 9", FUNC(fdim) (-9, 0), 0); check ("fdim (0, -9) = 9", FUNC(fdim) (0, -9), 9); check_isinfp ("fdim (+inf, 9) = +inf", FUNC(fdim) (plus_infty, 9)); check_isinfp ("fdim (+inf, -9) = +inf", FUNC(fdim) (plus_infty, -9)); check ("fdim (-inf, 9) = 0", FUNC(fdim) (minus_infty, 9), 0); check ("fdim (-inf, -9) = 0", FUNC(fdim) (minus_infty, -9), 0); check_isinfp ("fdim (+9, -inf) = +inf", FUNC(fdim) (9, minus_infty)); check_isinfp ("fdim (-9, -inf) = +inf", FUNC(fdim) (-9, minus_infty)); check ("fdim (9, inf) = 0", FUNC(fdim) (9, plus_infty), 0); check ("fdim (-9, inf) = 0", FUNC(fdim) (-9, plus_infty), 0); check_isnan ("fdim (0, NaN) = NaN", FUNC(fdim) (0, nan_value)); check_isnan ("fdim (9, NaN) = NaN", FUNC(fdim) (9, nan_value)); check_isnan ("fdim (-9, NaN) = NaN", FUNC(fdim) (-9, nan_value)); check_isnan ("fdim (NaN, 9) = NaN", FUNC(fdim) (nan_value, 9)); check_isnan ("fdim (NaN, -9) = NaN", FUNC(fdim) (nan_value, -9)); check_isnan ("fdim (+inf, NaN) = NaN", FUNC(fdim) (plus_infty, nan_value)); check_isnan ("fdim (-inf, NaN) = NaN", FUNC(fdim) (minus_infty, nan_value)); check_isnan ("fdim (NaN, +inf) = NaN", FUNC(fdim) (nan_value, plus_infty)); check_isnan ("fdim (NaN, -inf) = NaN", FUNC(fdim) (nan_value, minus_infty)); check_isnan ("fdim (NaN, NaN) = NaN", FUNC(fdim) (nan_value, nan_value)); } static void fmin_test (void) { check ("fmin (+0, +0) = +0", FUNC(fmin) (0, 0), 0); check ("fmin (9, 0) = 0", FUNC(fmin) (9, 0), 0); check ("fmin (0, 9) = 0", FUNC(fmin) (0, 9), 0); check ("fmin (-9, 0) = -9", FUNC(fmin) (-9, 0), -9); check ("fmin (0, -9) = -9", FUNC(fmin) (0, -9), -9); check ("fmin (+inf, 9) = 9", FUNC(fmin) (plus_infty, 9), 9); check ("fmin (9, +inf) = 9", FUNC(fmin) (9, plus_infty), 9); check ("fmin (+inf, -9) = -9", FUNC(fmin) (plus_infty, -9), -9); check ("fmin (-9, +inf) = -9", FUNC(fmin) (-9, plus_infty), -9); check_isinfn ("fmin (-inf, 9) = -inf", FUNC(fmin) (minus_infty, 9)); check_isinfn ("fmin (-inf, -9) = -inf", FUNC(fmin) (minus_infty, -9)); check_isinfn ("fmin (+9, -inf) = -inf", FUNC(fmin) (9, minus_infty)); check_isinfn ("fmin (-9, -inf) = -inf", FUNC(fmin) (-9, minus_infty)); check ("fmin (0, NaN) = 0", FUNC(fmin) (0, nan_value), 0); check ("fmin (9, NaN) = 9", FUNC(fmin) (9, nan_value), 9); check ("fmin (-9, NaN) = 9", FUNC(fmin) (-9, nan_value), -9); check ("fmin (NaN, 0) = 0", FUNC(fmin) (nan_value, 0), 0); check ("fmin (NaN, 9) = NaN", FUNC(fmin) (nan_value, 9), 9); check ("fmin (NaN, -9) = NaN", FUNC(fmin) (nan_value, -9), -9); check_isinfp ("fmin (+inf, NaN) = +inf", FUNC(fmin) (plus_infty, nan_value)); check_isinfn ("fmin (-inf, NaN) = -inf", FUNC(fmin) (minus_infty, nan_value)); check_isinfp ("fmin (NaN, +inf) = +inf", FUNC(fmin) (nan_value, plus_infty)); check_isinfn ("fmin (NaN, -inf) = -inf", FUNC(fmin) (nan_value, minus_infty)); check_isnan ("fmin (NaN, NaN) = NaN", FUNC(fmin) (nan_value, nan_value)); } static void fmax_test (void) { check ("fmax (+0, +0) = +0", FUNC(fmax) (0, 0), 0); check ("fmax (9, 0) = 9", FUNC(fmax) (9, 0), 9); check ("fmax (0, 9) = 9", FUNC(fmax) (0, 9), 9); check ("fmax (-9, 0) = 0", FUNC(fmax) (-9, 0), 0); check ("fmax (0, -9) = 0", FUNC(fmax) (0, -9), 0); check_isinfp ("fmax (+inf, 9) = +inf", FUNC(fmax) (plus_infty, 9)); check_isinfp ("fmax (9, +inf) = +inf", FUNC(fmax) (0, plus_infty)); check_isinfp ("fmax (-9, +inf) = +inf", FUNC(fmax) (-9, plus_infty)); check_isinfp ("fmax (+inf, -9) = +inf", FUNC(fmax) (plus_infty, -9)); check ("fmax (-inf, 9) = 9", FUNC(fmax) (minus_infty, 9), 9); check ("fmax (-inf, -9) = -9", FUNC(fmax) (minus_infty, -9), -9); check ("fmax (+9, -inf) = 9", FUNC(fmax) (9, minus_infty), 9); check ("fmax (-9, -inf) = -9", FUNC(fmax) (-9, minus_infty), -9); check ("fmax (0, NaN) = 0", FUNC(fmax) (0, nan_value), 0); check ("fmax (9, NaN) = 9", FUNC(fmax) (9, nan_value), 9); check ("fmax (-9, NaN) = 9", FUNC(fmax) (-9, nan_value), -9); check ("fmax (NaN, 0) = 0", FUNC(fmax) (nan_value, 0), 0); check ("fmax (NaN, 9) = NaN", FUNC(fmax) (nan_value, 9), 9); check ("fmax (NaN, -9) = NaN", FUNC(fmax) (nan_value, -9), -9); check_isinfp ("fmax (+inf, NaN) = +inf", FUNC(fmax) (plus_infty, nan_value)); check_isinfn ("fmax (-inf, NaN) = -inf", FUNC(fmax) (minus_infty, nan_value)); check_isinfp ("fmax (NaN, +inf) = +inf", FUNC(fmax) (nan_value, plus_infty)); check_isinfn ("fmax (NaN, -inf) = -inf", FUNC(fmax) (nan_value, minus_infty)); check_isnan ("fmax (NaN, NaN) = NaN", FUNC(fmax) (nan_value, nan_value)); } static void fmod_test (void) { MATHTYPE x; x = random_greater (0); check_ext ("fmod (+0, y) == +0 for y != 0", FUNC(fmod) (0, x), 0, x); x = random_greater (0); check_ext ("fmod (-0, y) == -0 for y != 0", FUNC(fmod) (minus_zero, x), minus_zero, x); check_isnan_exc_ext ("fmod (+inf, y) == NaN plus invalid exception", FUNC(fmod) (plus_infty, x), INVALID_EXCEPTION, x); check_isnan_exc_ext ("fmod (-inf, y) == NaN plus invalid exception", FUNC(fmod) (minus_infty, x), INVALID_EXCEPTION, x); check_isnan_exc_ext ("fmod (x, +0) == NaN plus invalid exception", FUNC(fmod) (x, 0), INVALID_EXCEPTION, x); check_isnan_exc_ext ("fmod (x, -0) == NaN plus invalid exception", FUNC(fmod) (x, minus_zero), INVALID_EXCEPTION, x); x = random_greater (0); check_ext ("fmod (x, +inf) == x for x not infinite", FUNC(fmod) (x, plus_infty), x, x); x = random_greater (0); check_ext ("fmod (x, -inf) == x for x not infinite", FUNC(fmod) (x, minus_infty), x, x); check_eps ("fmod (6.5, 2.3) == 1.9", FUNC(fmod) (6.5, 2.3), 1.9, CHOOSE(5e-16, 1e-15, 2e-7)); check_eps ("fmod (-6.5, 2.3) == -1.9", FUNC(fmod) (-6.5, 2.3), -1.9, CHOOSE(5e-16, 1e-15, 2e-7)); check_eps ("fmod (6.5, -2.3) == 1.9", FUNC(fmod) (6.5, -2.3), 1.9, CHOOSE(5e-16, 1e-15, 2e-7)); check_eps ("fmod (-6.5, -2.3) == -1.9", FUNC(fmod) (-6.5, -2.3), -1.9, CHOOSE(5e-16, 1e-15, 2e-7)); } static void nextafter_test (void) { MATHTYPE x; check ("nextafter (+0, +0) = +0", FUNC(nextafter) (0, 0), 0); check ("nextafter (-0, +0) = +0", FUNC(nextafter) (minus_zero, 0), 0); check ("nextafter (+0, -0) = -0", FUNC(nextafter) (0, minus_zero), minus_zero); check ("nextafter (-0, -0) = -0", FUNC(nextafter) (minus_zero, minus_zero), minus_zero); check ("nextafter (9, 9) = 9", FUNC(nextafter) (9, 9), 9); check ("nextafter (-9, -9) = -9", FUNC(nextafter) (-9, -9), -9); check_isinfp ("nextafter (+inf, +inf) = +inf", FUNC(nextafter) (plus_infty, plus_infty)); check_isinfn ("nextafter (-inf, -inf) = -inf", FUNC(nextafter) (minus_infty, minus_infty)); x = rand () * 1.1; check_isnan ("nextafter (NaN, x) = NaN", FUNC(nextafter) (nan_value, x)); check_isnan ("nextafter (x, NaN) = NaN", FUNC(nextafter) (x, nan_value)); check_isnan ("nextafter (NaN, NaN) = NaN", FUNC(nextafter) (nan_value, nan_value)); /* XXX We need the hexadecimal FP number representation here for further tests. */ } static void copysign_test (void) { check ("copysign (0, 4) = 0", FUNC(copysign) (0, 4), 0); check ("copysign (0, -4) = -0", FUNC(copysign) (0, -4), minus_zero); check ("copysign (-0, 4) = 0", FUNC(copysign) (minus_zero, 4), 0); check ("copysign (-0, -4) = -0", FUNC(copysign) (minus_zero, -4), minus_zero); check_isinfp ("copysign (+inf, 0) = +inf", FUNC(copysign) (plus_infty, 0)); check_isinfn ("copysign (+inf, -0) = -inf", FUNC(copysign) (plus_infty, minus_zero)); check_isinfp ("copysign (-inf, 0) = +inf", FUNC(copysign) (minus_infty, 0)); check_isinfn ("copysign (-inf, -0) = -inf", FUNC(copysign) (minus_infty, minus_zero)); check ("copysign (0, +inf) = 0", FUNC(copysign) (0, plus_infty), 0); check ("copysign (0, -inf) = -0", FUNC(copysign) (0, minus_zero), minus_zero); check ("copysign (-0, +inf) = 0", FUNC(copysign) (minus_zero, plus_infty), 0); check ("copysign (-0, -inf) = -0", FUNC(copysign) (minus_zero, minus_zero), minus_zero); /* XXX More correctly we would have to check the sign of the NaN. */ check_isnan ("copysign (+NaN, 0) = +NaN", FUNC(copysign) (nan_value, 0)); check_isnan ("copysign (+NaN, -0) = -NaN", FUNC(copysign) (nan_value, minus_zero)); check_isnan ("copysign (-NaN, 0) = +NaN", FUNC(copysign) (-nan_value, 0)); check_isnan ("copysign (-NaN, -0) = -NaN", FUNC(copysign) (-nan_value, minus_zero)); } static void trunc_test (void) { check ("trunc(0) = 0", FUNC(trunc) (0), 0); check ("trunc(-0) = -0", FUNC(trunc) (minus_zero), minus_zero); check ("trunc(0.625) = 0", FUNC(trunc) (0.625), 0); check ("trunc(-0.625) = -0", FUNC(trunc) (-0.625), minus_zero); check ("trunc(1) = 1", FUNC(trunc) (1), 1); check ("trunc(-1) = -1", FUNC(trunc) (-1), -1); check ("trunc(1.625) = 1", FUNC(trunc) (1.625), 1); check ("trunc(-1.625) = -1", FUNC(trunc) (-1.625), -1); check ("trunc(1048580.625) = 1048580", FUNC(trunc) (1048580.625L), 1048580L); check ("trunc(-1048580.625) = -1048580", FUNC(trunc) (-1048580.625L), -1048580L); check ("trunc(8388610.125) = 8388610", FUNC(trunc) (8388610.125L), 8388610.0L); check ("trunc(-8388610.125) = -8388610", FUNC(trunc) (-8388610.125L), -8388610.0L); check ("trunc(4294967296.625) = 4294967296", FUNC(trunc) (4294967296.625L), 4294967296.0L); check ("trunc(-4294967296.625) = -4294967296", FUNC(trunc) (-4294967296.625L), -4294967296.0L); check_isinfp ("trunc(+inf) = +inf", FUNC(trunc) (plus_infty)); check_isinfn ("trunc(-inf) = -inf", FUNC(trunc) (minus_infty)); check_isnan ("trunc(NaN) = NaN", FUNC(trunc) (nan_value)); } static void sqrt_test (void) { MATHTYPE x; /* XXX Tests fuer negative x are missing */ check ("sqrt (0) == 0", FUNC(sqrt) (0), 0); check_isnan ("sqrt (NaN) == NaN", FUNC(sqrt) (nan_value)); check_isinfp ("sqrt (+inf) == +inf", FUNC(sqrt) (plus_infty)); check ("sqrt (-0) == -0", FUNC(sqrt) (0), 0); x = random_less (0.0); check_isnan_exc_ext ("sqrt (x) == NaN plus invalid exception for x < 0", FUNC(sqrt) (x), INVALID_EXCEPTION, x); x = random_value (0, 10000); check_ext ("sqrt (x*x) == x", FUNC(sqrt) (x*x), x, x); check ("sqrt (4) == 2", FUNC(sqrt) (4), 2); } static void remainder_test (void) { MATHTYPE result; result = FUNC(remainder) (1, 0); check_isnan_exc ("remainder(1, +0) == NaN plus invalid exception", result, INVALID_EXCEPTION); result = FUNC(remainder) (1, minus_zero); check_isnan_exc ("remainder(1, -0) == NaN plus invalid exception", result, INVALID_EXCEPTION); result = FUNC(remainder) (plus_infty, 1); check_isnan_exc ("remainder(+inf, 1) == NaN plus invalid exception", result, INVALID_EXCEPTION); result = FUNC(remainder) (minus_infty, 1); check_isnan_exc ("remainder(-inf, 1) == NaN plus invalid exception", result, INVALID_EXCEPTION); result = FUNC(remainder) (1.625, 1.0); check ("remainder(1.625, 1.0) == -0.375", result, -0.375); result = FUNC(remainder) (-1.625, 1.0); check ("remainder(-1.625, 1.0) == 0.375", result, 0.375); result = FUNC(remainder) (1.625, -1.0); check ("remainder(1.625, -1.0) == -0.375", result, -0.375); result = FUNC(remainder) (-1.625, -1.0); check ("remainder(-1.625, -1.0) == 0.375", result, 0.375); result = FUNC(remainder) (5.0, 2.0); check ("remainder(5.0, 2.0) == 1.0", result, 1.0); result = FUNC(remainder) (3.0, 2.0); check ("remainder(3.0, 2.0) == -1.0", result, -1.0); } static void remquo_test (void) { int quo; MATHTYPE result; result = FUNC(remquo) (1, 0, &quo); check_isnan_exc ("remquo(1, +0, &x) == NaN plus invalid exception", result, INVALID_EXCEPTION); result = FUNC(remquo) (1, minus_zero, &quo); check_isnan_exc ("remquo(1, -0, &x) == NaN plus invalid exception", result, INVALID_EXCEPTION); result = FUNC(remquo) (plus_infty, 1, &quo); check_isnan_exc ("remquo(+inf, 1, &x) == NaN plus invalid exception", result, INVALID_EXCEPTION); result = FUNC(remquo) (minus_infty, 1, &quo); check_isnan_exc ("remquo(-inf, 1, &x) == NaN plus invalid exception", result, INVALID_EXCEPTION); result = FUNC(remquo) (1.625, 1.0, &quo); check ("remquo(1.625, 1.0, &x) == -0.375", result, -0.375); check_long ("remquo(1.625, 1.0, &x) puts 2 in x", quo, 2); result = FUNC(remquo) (-1.625, 1.0, &quo); check ("remquo(-1.625, 1.0, &x) == 0.375", result, 0.375); check_long ("remquo(-1.625, 1.0, &x) puts -2 in x", quo, -2); result = FUNC(remquo) (1.625, -1.0, &quo); check ("remquo(1.625, -1.0, &x) == -0.375", result, -0.375); check_long ("remquo(1.625, -1.0, &x) puts -2 in x", quo, -2); result = FUNC(remquo) (-1.625, -1.0, &quo); check ("remquo(-1.625, -1.0, &x) == 0.375", result, 0.375); check_long ("remquo(-1.625, -1.0, &x) puts 2 in x", quo, 2); result = FUNC(remquo) (5.0, 2.0, &quo); check ("remquo(5.0, 2.0, &x) == 1.0", result, 1.0); check_long ("remquo (5.0, 2.0, &x) puts 2 in x", quo, 2); result = FUNC(remquo) (3.0, 2.0, &quo); check ("remquo(3.0, 2.0, &x) == -1.0", result, -1.0); check_long ("remquo (3.0, 2.0, &x) puts 2 in x", quo, 2); } static void cexp_test (void) { __complex__ MATHTYPE result; result = FUNC(cexp) (BUILD_COMPLEX (plus_zero, plus_zero)); check ("real(cexp(0 + 0i)) = 1", __real__ result, 1); check ("imag(cexp(0 + 0i)) = 0", __imag__ result, 0); result = FUNC(cexp) (BUILD_COMPLEX (minus_zero, plus_zero)); check ("real(cexp(-0 + 0i)) = 1", __real__ result, 1); check ("imag(cexp(-0 + 0i)) = 0", __imag__ result, 0); result = FUNC(cexp) (BUILD_COMPLEX (plus_zero, minus_zero)); check ("real(cexp(0 - 0i)) = 1", __real__ result, 1); check ("imag(cexp(0 - 0i)) = -0", __imag__ result, minus_zero); result = FUNC(cexp) (BUILD_COMPLEX (minus_zero, minus_zero)); check ("real(cexp(-0 - 0i)) = 1", __real__ result, 1); check ("imag(cexp(-0 - 0i)) = -0", __imag__ result, minus_zero); result = FUNC(cexp) (BUILD_COMPLEX (plus_infty, plus_zero)); check_isinfp ("real(cexp(+inf + 0i)) = +inf", __real__ result); check ("imag(cexp(+inf + 0i)) = 0", __imag__ result, 0); result = FUNC(cexp) (BUILD_COMPLEX (plus_infty, minus_zero)); check_isinfp ("real(cexp(+inf - 0i)) = +inf", __real__ result); check ("imag(cexp(+inf - 0i)) = -0", __imag__ result, minus_zero); result = FUNC(cexp) (BUILD_COMPLEX (minus_infty, plus_zero)); check ("real(cexp(-inf + 0i)) = 0", __real__ result, 0); check ("imag(cexp(-inf + 0i)) = 0", __imag__ result, 0); result = FUNC(cexp) (BUILD_COMPLEX (minus_infty, minus_zero)); check ("real(cexp(-inf - 0i)) = 0", __real__ result, 0); check ("imag(cexp(-inf - 0i)) = -0", __imag__ result, minus_zero); result = FUNC(cexp) (BUILD_COMPLEX (0.0, plus_infty)); check_isnan_exc ("real(cexp(0 + i inf)) = NaN plus invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(cexp(0 + i inf)) = NaN plus invalid exception", __imag__ result); #if defined __GNUC__ && __GNUC__ <= 2 && __GNUC_MINOR <= 7 if (verbose) printf ("The following test for cexp might fail due to a gcc compiler error!\n"); #endif result = FUNC(cexp) (BUILD_COMPLEX (minus_zero, plus_infty)); check_isnan_exc ("real(cexp(-0 + i inf)) = NaN plus invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(cexp(-0 + i inf)) = NaN plus invalid exception", __imag__ result); result = FUNC(cexp) (BUILD_COMPLEX (0.0, minus_infty)); check_isnan_exc ("real(cexp(0 - i inf)) = NaN plus invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(cexp(0 - i inf)) = NaN plus invalid exception", __imag__ result); result = FUNC(cexp) (BUILD_COMPLEX (minus_zero, minus_infty)); check_isnan_exc ("real(cexp(-0 - i inf)) = NaN plus invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(cexp(-0 - i inf)) = NaN plus invalid exception", __imag__ result); result = FUNC(cexp) (BUILD_COMPLEX (100.0, plus_infty)); check_isnan_exc ("real(cexp(100.0 + i inf)) = NaN plus invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(cexp(100.0 + i inf)) = NaN plus invalid exception", __imag__ result); result = FUNC(cexp) (BUILD_COMPLEX (-100.0, plus_infty)); check_isnan_exc ("real(cexp(-100.0 + i inf)) = NaN plus invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(cexp(-100.0 + i inf)) = NaN plus invalid exception", __imag__ result); result = FUNC(cexp) (BUILD_COMPLEX (100.0, minus_infty)); check_isnan_exc ("real(cexp(100.0 - i inf)) = NaN plus invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(cexp(100.0 - i inf)) = NaN plus invalid exception", __imag__ result); result = FUNC(cexp) (BUILD_COMPLEX (-100.0, minus_infty)); check_isnan_exc ("real(cexp(-100.0 - i inf)) = NaN plus invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(cexp(-100.0 - i inf)) = NaN", __imag__ result); result = FUNC(cexp) (BUILD_COMPLEX (minus_infty, 2.0)); check ("real(cexp(-inf + 2.0i)) = -0", __real__ result, minus_zero); check ("imag(cexp(-inf + 2.0i)) = 0", __imag__ result, 0); result = FUNC(cexp) (BUILD_COMPLEX (minus_infty, 4.0)); check ("real(cexp(-inf + 4.0i)) = -0", __real__ result, minus_zero); check ("imag(cexp(-inf + 4.0i)) = -0", __imag__ result, minus_zero); result = FUNC(cexp) (BUILD_COMPLEX (plus_infty, 2.0)); check_isinfn ("real(cexp(+inf + 2.0i)) = -inf", __real__ result); check_isinfp ("imag(cexp(+inf + 2.0i)) = +inf", __imag__ result); result = FUNC(cexp) (BUILD_COMPLEX (plus_infty, 4.0)); check_isinfn ("real(cexp(+inf + 4.0i)) = -inf", __real__ result); check_isinfn ("imag(cexp(+inf + 4.0i)) = -inf", __imag__ result); result = FUNC(cexp) (BUILD_COMPLEX (plus_infty, plus_infty)); check_isinfp_exc ("real(cexp(+inf + i inf)) = +inf plus invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(cexp(+inf + i inf)) = NaN plus invalid exception", __imag__ result); result = FUNC(cexp) (BUILD_COMPLEX (plus_infty, minus_infty)); check_isinfp_exc ("real(cexp(+inf - i inf)) = +inf plus invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(cexp(+inf - i inf)) = NaN plus invalid exception", __imag__ result); result = FUNC(cexp) (BUILD_COMPLEX (minus_infty, plus_infty)); check ("real(cexp(-inf + i inf)) = 0", __real__ result, 0); check ("imag(cexp(-inf + i inf)) = 0", __imag__ result, 0); result = FUNC(cexp) (BUILD_COMPLEX (minus_infty, minus_infty)); check ("real(cexp(-inf - i inf)) = 0", __real__ result, 0); check ("imag(cexp(-inf - i inf)) = -0", __imag__ result, minus_zero); result = FUNC(cexp) (BUILD_COMPLEX (minus_infty, nan_value)); check ("real(cexp(-inf + i NaN)) = 0", __real__ result, 0); check ("imag(cexp(-inf + i NaN)) = 0", fabs (__imag__ result), 0); result = FUNC(cexp) (BUILD_COMPLEX (plus_infty, nan_value)); check_isinfp ("real(cexp(+inf + i NaN)) = +inf", __real__ result); check_isnan ("imag(cexp(+inf + i NaN)) = NaN", __imag__ result); result = FUNC(cexp) (BUILD_COMPLEX (nan_value, 0.0)); check_isnan_maybe_exc ("real(cexp(NaN + i0)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(cexp(NaN + i0)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(cexp) (BUILD_COMPLEX (nan_value, 1.0)); check_isnan_maybe_exc ("real(cexp(NaN + 1i)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(cexp(NaN + 1i)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(cexp) (BUILD_COMPLEX (nan_value, plus_infty)); check_isnan_maybe_exc ("real(cexp(NaN + i inf)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(cexp(NaN + i inf)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(cexp) (BUILD_COMPLEX (0, nan_value)); check_isnan_maybe_exc ("real(cexp(0 + i NaN)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(cexp(0 + i NaN)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(cexp) (BUILD_COMPLEX (1, nan_value)); check_isnan_maybe_exc ("real(cexp(1 + i NaN)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(cexp(1 + i NaN)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(cexp) (BUILD_COMPLEX (nan_value, nan_value)); check_isnan ("real(cexp(NaN + i NaN)) = NaN", __real__ result); check_isnan ("imag(cexp(NaN + i NaN)) = NaN", __imag__ result); } static void csin_test (void) { __complex__ MATHTYPE result; result = FUNC(csin) (BUILD_COMPLEX (0.0, 0.0)); check ("real(csin(0 + 0i)) = 0", __real__ result, 0); check ("imag(csin(0 + 0i)) = 0", __imag__ result, 0); result = FUNC(csin) (BUILD_COMPLEX (minus_zero, 0.0)); check ("real(csin(-0 + 0i)) = -0", __real__ result, minus_zero); check ("imag(csin(-0 + 0i)) = 0", __imag__ result, 0); result = FUNC(csin) (BUILD_COMPLEX (0.0, minus_zero)); check ("real(csin(0 - 0i)) = 0", __real__ result, 0); check ("imag(csin(0 - 0i)) = -0", __imag__ result, minus_zero); result = FUNC(csin) (BUILD_COMPLEX (minus_zero, minus_zero)); check ("real(csin(-0 - 0i)) = -0", __real__ result, minus_zero); check ("imag(csin(-0 - 0i)) = -0", __imag__ result, minus_zero); result = FUNC(csin) (BUILD_COMPLEX (0.0, plus_infty)); check ("real(csin(0 + i Inf)) = 0", __real__ result, 0); check_isinfp ("imag(csin(0 + i Inf)) = +Inf", __imag__ result); result = FUNC(csin) (BUILD_COMPLEX (minus_zero, plus_infty)); check ("real(csin(-0 + i Inf)) = -0", __real__ result, minus_zero); check_isinfp ("imag(csin(-0 + i Inf)) = +Inf", __imag__ result); result = FUNC(csin) (BUILD_COMPLEX (0.0, minus_infty)); check ("real(csin(0 - i Inf)) = 0", __real__ result, 0); check_isinfn ("imag(csin(0 - i Inf)) = -Inf", __imag__ result); result = FUNC(csin) (BUILD_COMPLEX (minus_zero, minus_infty)); check ("real(csin(-0 - i Inf)) = -0", __real__ result, minus_zero); check_isinfn("imag(csin(-0 - i Inf)) = -Inf", __imag__ result); result = FUNC(csin) (BUILD_COMPLEX (plus_infty, 0.0)); check_isnan_exc ("real(csin(+Inf + 0i)) = NaN plus invalid exception", __real__ result, INVALID_EXCEPTION); check ("imag(csin(+Inf + 0i)) = +-0 plus invalid exception", FUNC(fabs) (__imag__ result), 0); result = FUNC(csin) (BUILD_COMPLEX (minus_infty, 0.0)); check_isnan_exc ("real(csin(-Inf + 0i)) = NaN plus invalid exception", __real__ result, INVALID_EXCEPTION); check ("imag(csin(-Inf + 0i)) = +-0 plus invalid exception", FUNC(fabs) (__imag__ result), 0); result = FUNC(csin) (BUILD_COMPLEX (plus_infty, minus_zero)); check_isnan_exc ("real(csin(+Inf - 0i)) = NaN plus invalid exception", __real__ result, INVALID_EXCEPTION); check ("imag(csin(+Inf - 0i)) = +-0 plus invalid exception", FUNC(fabs) (__imag__ result), 0.0); result = FUNC(csin) (BUILD_COMPLEX (minus_infty, minus_zero)); check_isnan_exc ("real(csin(-Inf - 0i)) = NaN plus invalid exception", __real__ result, INVALID_EXCEPTION); check ("imag(csin(-Inf - 0i)) = +-0 plus invalid exception", FUNC(fabs) (__imag__ result), 0.0); result = FUNC(csin) (BUILD_COMPLEX (plus_infty, plus_infty)); check_isnan_exc ("real(csin(+Inf + i Inf)) = NaN plus invalid exception", __real__ result, INVALID_EXCEPTION); check_isinfp ("imag(csin(+Inf + i Inf)) = +-Inf plus invalid exception", FUNC(fabs) (__imag__ result)); result = FUNC(csin) (BUILD_COMPLEX (minus_infty, plus_infty)); check_isnan_exc ("real(csin(-Inf + i Inf)) = NaN plus invalid exception", __real__ result, INVALID_EXCEPTION); check_isinfp ("imag(csin(-Inf + i Inf)) = +-Inf plus invalid exception", FUNC(fabs) (__imag__ result)); result = FUNC(csin) (BUILD_COMPLEX (plus_infty, minus_infty)); check_isnan_exc ("real(csin(Inf - i Inf)) = NaN plus invalid exception", __real__ result, INVALID_EXCEPTION); check_isinfp ("imag(csin(Inf - i Inf)) = +-Inf plus invalid exception", FUNC(fabs) (__imag__ result)); result = FUNC(csin) (BUILD_COMPLEX (minus_infty, minus_infty)); check_isnan_exc ("real(csin(-Inf - i Inf)) = NaN plus invalid exception", __real__ result, INVALID_EXCEPTION); check_isinfp ("imag(csin(-Inf - i Inf)) = +-Inf plus invalid exception", FUNC(fabs) (__imag__ result)); result = FUNC(csin) (BUILD_COMPLEX (plus_infty, 6.75)); check_isnan_exc ("real(csin(+Inf + i 6.75)) = NaN plus invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(csin(+Inf + i6.75)) = NaN plus invalid exception", __imag__ result); result = FUNC(csin) (BUILD_COMPLEX (plus_infty, -6.75)); check_isnan_exc ("real(csin(+Inf - i 6.75)) = NaN plus invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(csin(+Inf - i6.75)) = NaN plus invalid exception", __imag__ result); result = FUNC(csin) (BUILD_COMPLEX (minus_infty, 6.75)); check_isnan_exc ("real(csin(-Inf + i6.75)) = NaN plus invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(csin(-Inf + i6.75)) = NaN plus invalid exception", __imag__ result); result = FUNC(csin) (BUILD_COMPLEX (minus_infty, -6.75)); check_isnan_exc ("real(csin(-Inf - i6.75)) = NaN plus invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(csin(-Inf - i6.75)) = NaN plus invalid exception", __imag__ result); result = FUNC(csin) (BUILD_COMPLEX (4.625, plus_infty)); check_isinfn ("real(csin(4.625 + i Inf)) = -Inf", __real__ result); check_isinfn ("imag(csin(4.625 + i Inf)) = -Inf", __imag__ result); result = FUNC(csin) (BUILD_COMPLEX (4.625, minus_infty)); check_isinfn ("real(csin(4.625 - i Inf)) = -Inf", __real__ result); check_isinfp ("imag(csin(4.625 - i Inf)) = +Inf", __imag__ result); result = FUNC(csin) (BUILD_COMPLEX (-4.625, plus_infty)); check_isinfp ("real(csin(-4.625 + i Inf)) = +Inf", __real__ result); check_isinfn ("imag(csin(-4.625 + i Inf)) = -Inf", __imag__ result); result = FUNC(csin) (BUILD_COMPLEX (-4.625, minus_infty)); check_isinfp ("real(csin(-4.625 - i Inf)) = +Inf", __real__ result); check_isinfp ("imag(csin(-4.625 - i Inf)) = +Inf", __imag__ result); result = FUNC(csin) (BUILD_COMPLEX (nan_value, 0.0)); check_isnan ("real(csin(NaN + i0)) = NaN", __real__ result); check ("imag(csin(NaN + i0)) = +-0", FUNC(fabs) (__imag__ result), 0); result = FUNC(csin) (BUILD_COMPLEX (nan_value, minus_zero)); check_isnan ("real(csin(NaN - i0)) = NaN", __real__ result); check ("imag(csin(NaN - i0)) = +-0", FUNC(fabs) (__imag__ result), 0); result = FUNC(csin) (BUILD_COMPLEX (nan_value, plus_infty)); check_isnan ("real(csin(NaN + i Inf)) = NaN", __real__ result); check_isinfp ("imag(csin(NaN + i Inf)) = +-Inf", FUNC(fabs) (__imag__ result)); result = FUNC(csin) (BUILD_COMPLEX (nan_value, minus_infty)); check_isnan ("real(csin(NaN - i Inf)) = NaN", __real__ result); check_isinfp ("real(csin(NaN - i Inf)) = +-Inf", FUNC(fabs) (__imag__ result)); result = FUNC(csin) (BUILD_COMPLEX (nan_value, 9.0)); check_isnan_maybe_exc ("real(csin(NaN + i9.0)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(csin(NaN + i9.0)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(csin) (BUILD_COMPLEX (nan_value, -9.0)); check_isnan_maybe_exc ("real(csin(NaN - i9.0)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(csin(NaN - i9.0)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(csin) (BUILD_COMPLEX (0.0, nan_value)); check ("real(csin(0 + i NaN))", __real__ result, 0.0); check_isnan ("imag(csin(0 + i NaN)) = NaN", __imag__ result); result = FUNC(csin) (BUILD_COMPLEX (minus_zero, nan_value)); check ("real(csin(-0 + i NaN)) = -0", __real__ result, minus_zero); check_isnan ("imag(csin(-0 + NaN)) = NaN", __imag__ result); result = FUNC(csin) (BUILD_COMPLEX (10.0, nan_value)); check_isnan_maybe_exc ("real(csin(10 + i NaN)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(csin(10 + i NaN)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(csin) (BUILD_COMPLEX (nan_value, -10.0)); check_isnan_maybe_exc ("real(csin(-10 + i NaN)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(csin(-10 + i NaN)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(csin) (BUILD_COMPLEX (plus_infty, nan_value)); check_isnan_maybe_exc ("real(csin(+Inf + i NaN)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(csin(+Inf + i NaN)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(csin) (BUILD_COMPLEX (minus_infty, nan_value)); check_isnan_maybe_exc ("real(csin(-Inf + i NaN)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(csin(-Inf + i NaN)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(csin) (BUILD_COMPLEX (nan_value, nan_value)); check_isnan ("real(csin(NaN + i NaN)) = NaN", __real__ result); check_isnan ("imag(csin(NaN + i NaN)) = NaN", __imag__ result); } static void csinh_test (void) { __complex__ MATHTYPE result; result = FUNC(csinh) (BUILD_COMPLEX (0.0, 0.0)); check ("real(csinh(0 + 0i)) = 0", __real__ result, 0); check ("imag(csinh(0 + 0i)) = 0", __imag__ result, 0); result = FUNC(csinh) (BUILD_COMPLEX (minus_zero, 0.0)); check ("real(csinh(-0 + 0i)) = -0", __real__ result, minus_zero); check ("imag(csinh(-0 + 0i)) = 0", __imag__ result, 0); result = FUNC(csinh) (BUILD_COMPLEX (0.0, minus_zero)); check ("real(csinh(0 - 0i)) = 0", __real__ result, 0); check ("imag(csinh(0 - 0i)) = -0", __imag__ result, minus_zero); result = FUNC(csinh) (BUILD_COMPLEX (minus_zero, minus_zero)); check ("real(csinh(-0 - 0i)) = -0", __real__ result, minus_zero); check ("imag(csinh(-0 - 0i)) = -0", __imag__ result, minus_zero); result = FUNC(csinh) (BUILD_COMPLEX (0.0, plus_infty)); check_exc ("real(csinh(0 + i Inf)) = +-0 plus invalid exception", FUNC(fabs) (__real__ result), 0, INVALID_EXCEPTION); check_isnan ("imag(csinh(0 + i Inf)) = NaN plus invalid exception", __imag__ result); result = FUNC(csinh) (BUILD_COMPLEX (minus_zero, plus_infty)); check_exc ("real(csinh(-0 + i Inf)) = +-0 plus invalid exception", FUNC(fabs) (__real__ result), 0, INVALID_EXCEPTION); check_isnan ("imag(csinh(-0 + i Inf)) = NaN plus invalid exception", __imag__ result); result = FUNC(csinh) (BUILD_COMPLEX (0.0, minus_infty)); check_exc ("real(csinh(0 - i Inf)) = +-0 plus invalid exception", FUNC(fabs) (__real__ result), 0, INVALID_EXCEPTION); check_isnan ("imag(csinh(0 - i Inf)) = NaN plus invalid exception", __imag__ result); result = FUNC(csinh) (BUILD_COMPLEX (minus_zero, minus_infty)); check_exc ("real(csinh(-0 - i Inf)) = +-0 plus invalid exception", FUNC(fabs) (__real__ result), 0, INVALID_EXCEPTION); check_isnan ("imag(csinh(-0 - i Inf)) = NaN plus invalid exception", __imag__ result); result = FUNC(csinh) (BUILD_COMPLEX (plus_infty, 0.0)); check_isinfp ("real(csinh(+Inf + 0i)) = +Inf", __real__ result); check ("imag(csinh(+Inf + 0i)) = 0", __imag__ result, 0); result = FUNC(csinh) (BUILD_COMPLEX (minus_infty, 0.0)); check_isinfn ("real(csinh(-Inf + 0i)) = -Inf", __real__ result); check ("imag(csinh(-Inf + 0i)) = 0", __imag__ result, 0); result = FUNC(csinh) (BUILD_COMPLEX (plus_infty, minus_zero)); check_isinfp ("real(csinh(+Inf - 0i)) = +Inf", __real__ result); check ("imag(csinh(+Inf - 0i)) = -0", __imag__ result, minus_zero); result = FUNC(csinh) (BUILD_COMPLEX (minus_infty, minus_zero)); check_isinfn ("real(csinh(-Inf - 0i)) = -Inf", __real__ result); check ("imag(csinh(-Inf - 0i)) = -0", __imag__ result, minus_zero); result = FUNC(csinh) (BUILD_COMPLEX (plus_infty, plus_infty)); check_isinfp_exc ("real(csinh(+Inf + i Inf)) = +-Inf plus invalid exception", FUNC(fabs) (__real__ result), INVALID_EXCEPTION); check_isnan ("imag(csinh(+Inf + i Inf)) = NaN plus invalid exception", __imag__ result); result = FUNC(csinh) (BUILD_COMPLEX (minus_infty, plus_infty)); check_isinfp_exc ("real(csinh(-Inf + i Inf)) = +-Inf plus invalid exception", FUNC(fabs) (__real__ result), INVALID_EXCEPTION); check_isnan ("imag(csinh(-Inf + i Inf)) = NaN plus invalid exception", __imag__ result); result = FUNC(csinh) (BUILD_COMPLEX (plus_infty, minus_infty)); check_isinfp_exc ("real(csinh(Inf - i Inf)) = +-Inf plus invalid exception", FUNC(fabs) (__real__ result), INVALID_EXCEPTION); check_isnan ("imag(csinh(Inf - i Inf)) = NaN plus invalid exception", __imag__ result); result = FUNC(csinh) (BUILD_COMPLEX (minus_infty, minus_infty)); check_isinfp_exc ("real(csinh(-Inf - i Inf)) = +-Inf plus invalid exception", FUNC(fabs) (__real__ result), INVALID_EXCEPTION); check_isnan ("imag(csinh(-Inf - i Inf)) = NaN plus invalid exception", __imag__ result); result = FUNC(csinh) (BUILD_COMPLEX (plus_infty, 4.625)); check_isinfn ("real(csinh(+Inf + i4.625)) = -Inf", __real__ result); check_isinfn ("imag(csinh(+Inf + i4.625)) = -Inf", __imag__ result); result = FUNC(csinh) (BUILD_COMPLEX (minus_infty, 4.625)); check_isinfp ("real(csinh(-Inf + i4.625)) = +Inf", __real__ result); check_isinfn ("imag(csinh(-Inf + i4.625)) = -Inf", __imag__ result); result = FUNC(csinh) (BUILD_COMPLEX (plus_infty, -4.625)); check_isinfn ("real(csinh(+Inf - i4.625)) = -Inf", __real__ result); check_isinfp ("imag(csinh(+Inf - i4.625)) = +Inf", __imag__ result); result = FUNC(csinh) (BUILD_COMPLEX (minus_infty, -4.625)); check_isinfp ("real(csinh(-Inf - i4.625)) = +Inf", __real__ result); check_isinfp ("imag(csinh(-Inf - i4.625)) = +Inf", __imag__ result); result = FUNC(csinh) (BUILD_COMPLEX (6.75, plus_infty)); check_isnan_exc ("real(csinh(6.75 + i Inf)) = NaN plus invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(csinh(6.75 + i Inf)) = NaN plus invalid exception", __imag__ result); result = FUNC(csinh) (BUILD_COMPLEX (-6.75, plus_infty)); check_isnan_exc ("real(csinh(-6.75 + i Inf)) = NaN plus invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(csinh(-6.75 + i Inf)) = NaN plus invalid exception", __imag__ result); result = FUNC(csinh) (BUILD_COMPLEX (6.75, minus_infty)); check_isnan_exc ("real(csinh(6.75 - i Inf)) = NaN plus invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(csinh(6.75 - i Inf)) = NaN plus invalid exception", __imag__ result); result = FUNC(csinh) (BUILD_COMPLEX (-6.75, minus_infty)); check_isnan_exc ("real(csinh(-6.75 - i Inf)) = NaN plus invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(csinh(-6.75 - i Inf)) = NaN plus invalid exception", __imag__ result); result = FUNC(csinh) (BUILD_COMPLEX (0.0, nan_value)); check ("real(csinh(0 + i NaN)) = +-0", FUNC(fabs) (__real__ result), 0); check_isnan ("imag(csinh(0 + i NaN)) = NaN", __imag__ result); result = FUNC(csinh) (BUILD_COMPLEX (minus_zero, nan_value)); check ("real(csinh(-0 + i NaN)) = +-0", FUNC(fabs) (__real__ result), 0); check_isnan ("imag(csinh(-0 + i NaN)) = NaN", __imag__ result); result = FUNC(csinh) (BUILD_COMPLEX (plus_infty, nan_value)); check_isinfp ("real(csinh(+Inf + i NaN)) = +-Inf", FUNC(fabs) (__real__ result)); check_isnan ("imag(csinh(+Inf + i NaN)) = NaN", __imag__ result); result = FUNC(csinh) (BUILD_COMPLEX (minus_infty, nan_value)); check_isinfp ("real(csinh(-Inf + i NaN)) = +-Inf", FUNC(fabs) (__real__ result)); check_isnan ("imag(csinh(-Inf + i NaN)) = NaN", __imag__ result); result = FUNC(csinh) (BUILD_COMPLEX (9.0, nan_value)); check_isnan_maybe_exc ("real(csinh(9.0 + i NaN)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(csinh(9.0 + i NaN)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(csinh) (BUILD_COMPLEX (-9.0, nan_value)); check_isnan_maybe_exc ("real(csinh(-9.0 + i NaN)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(csinh(-9.0 + i NaN)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(csinh) (BUILD_COMPLEX (nan_value, 0.0)); check_isnan ("real(csinh(NaN + i0)) = NaN", __real__ result); check ("imag(csinh(NaN + i0)) = 0", __imag__ result, 0.0); result = FUNC(csinh) (BUILD_COMPLEX (nan_value, minus_zero)); check_isnan ("real(csinh(NaN - i0)) = NaN", __real__ result); check ("imag(csinh(NaN - i0)) = -0", __imag__ result, minus_zero); result = FUNC(csinh) (BUILD_COMPLEX (nan_value, 10.0)); check_isnan_maybe_exc ("real(csinh(NaN + i10)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(csinh(NaN + i10)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(csinh) (BUILD_COMPLEX (nan_value, -10.0)); check_isnan_maybe_exc ("real(csinh(NaN - i10)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(csinh(NaN - i10)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(csinh) (BUILD_COMPLEX (nan_value, plus_infty)); check_isnan_maybe_exc ("real(csinh(NaN + i Inf)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(csinh(NaN + i Inf)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(csinh) (BUILD_COMPLEX (nan_value, minus_infty)); check_isnan_maybe_exc ("real(csinh(NaN - i Inf)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(csinh(NaN - i Inf)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(csinh) (BUILD_COMPLEX (nan_value, nan_value)); check_isnan ("real(csinh(NaN + i NaN)) = NaN", __real__ result); check_isnan ("imag(csinh(NaN + i NaN)) = NaN", __imag__ result); } static void ccos_test (void) { __complex__ MATHTYPE result; result = FUNC(ccos) (BUILD_COMPLEX (0.0, 0.0)); check ("real(ccos(0 + 0i)) = 1.0", __real__ result, 1.0); check ("imag(ccos(0 + 0i)) = -0", __imag__ result, minus_zero); result = FUNC(ccos) (BUILD_COMPLEX (minus_zero, 0.0)); check ("real(ccos(-0 + 0i)) = 1.0", __real__ result, 1.0); check ("imag(ccos(-0 + 0i)) = 0", __imag__ result, 0.0); result = FUNC(ccos) (BUILD_COMPLEX (0.0, minus_zero)); check ("real(ccos(0 - 0i)) = 1.0", __real__ result, 1.0); check ("imag(ccos(0 - 0i)) = 0", __imag__ result, 0.0); result = FUNC(ccos) (BUILD_COMPLEX (minus_zero, minus_zero)); check ("real(ccos(-0 - 0i)) = 1.0", __real__ result, 1.0); check ("imag(ccos(-0 - 0i)) = -0", __imag__ result, minus_zero); result = FUNC(ccos) (BUILD_COMPLEX (plus_infty, 0.0)); check_isnan_exc ("real(ccos(+Inf + i0)) = NaN plus invalid exception", __real__ result, INVALID_EXCEPTION); check ("imag(ccos(Inf + i0)) = +-0 plus invalid exception", FUNC(fabs) (__imag__ result), 0); result = FUNC(ccos) (BUILD_COMPLEX (plus_infty, minus_zero)); check_isnan_exc ("real(ccos(Inf - i0)) = NaN plus invalid exception", __real__ result, INVALID_EXCEPTION); check ("imag(ccos(Inf - i0)) = +-0 plus invalid exception", FUNC(fabs) (__imag__ result), 0); result = FUNC(ccos) (BUILD_COMPLEX (minus_infty, 0.0)); check_isnan_exc ("real(ccos(-Inf + i0)) = NaN plus invalid exception", __real__ result, INVALID_EXCEPTION); check ("imag(ccos(-Inf + i0)) = +-0 plus invalid exception", FUNC(fabs) (__imag__ result), 0); result = FUNC(ccos) (BUILD_COMPLEX (minus_infty, minus_zero)); check_isnan_exc ("real(ccos(-Inf - i0)) = NaN plus invalid exception", __real__ result, INVALID_EXCEPTION); check ("imag(ccos(-Inf - i0)) = +-0 plus invalid exception", FUNC(fabs) (__imag__ result), 0); result = FUNC(ccos) (BUILD_COMPLEX (0.0, plus_infty)); check_isinfp ("real(ccos(0 + i Inf)) = +Inf", __real__ result); check ("imag(ccos(0 + i Inf)) = -0", __imag__ result, minus_zero); result = FUNC(ccos) (BUILD_COMPLEX (0.0, minus_infty)); check_isinfp ("real(ccos(0 - i Inf)) = +Inf", __real__ result); check ("imag(ccos(0 - i Inf)) = 0", __imag__ result, 0); result = FUNC(ccos) (BUILD_COMPLEX (minus_zero, plus_infty)); check_isinfp ("real(ccos(-0 + i Inf)) = +Inf", __real__ result); check ("imag(ccos(-0 + i Inf)) = 0", __imag__ result, 0.0); result = FUNC(ccos) (BUILD_COMPLEX (minus_zero, minus_infty)); check_isinfp ("real(ccos(-0 - i Inf)) = +Inf", __real__ result); check ("imag(ccos(-0 - i Inf)) = -0", __imag__ result, minus_zero); result = FUNC(ccos) (BUILD_COMPLEX (plus_infty, plus_infty)); check_isinfp_exc ("real(ccos(+Inf + i Inf)) = +Inf plus invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(ccos(+Inf + i Inf)) = NaN plus invalid exception", __imag__ result); result = FUNC(ccos) (BUILD_COMPLEX (minus_infty, plus_infty)); check_isinfp_exc ("real(ccos(-Inf + i Inf)) = +Inf plus invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(ccos(-Inf + i Inf)) = NaN plus invalid exception", __imag__ result); result = FUNC(ccos) (BUILD_COMPLEX (plus_infty, minus_infty)); check_isinfp_exc ("real(ccos(Inf - i Inf)) = +Inf plus invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(ccos(Inf - i Inf)) = NaN plus invalid exception", __imag__ result); result = FUNC(ccos) (BUILD_COMPLEX (minus_infty, minus_infty)); check_isinfp_exc ("real(ccos(-Inf - i Inf)) = +Inf plus invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(ccos(-Inf - i Inf)) = NaN plus invalid exception", __imag__ result); result = FUNC(ccos) (BUILD_COMPLEX (4.625, plus_infty)); check_isinfn ("real(ccos(4.625 + i Inf)) = -Inf", __real__ result); check_isinfp ("imag(ccos(4.625 + i Inf)) = +Inf", __imag__ result); result = FUNC(ccos) (BUILD_COMPLEX (4.625, minus_infty)); check_isinfn ("real(ccos(4.625 - i Inf)) = -Inf", __real__ result); check_isinfn ("imag(ccos(4.625 - i Inf)) = -Inf", __imag__ result); result = FUNC(ccos) (BUILD_COMPLEX (-4.625, plus_infty)); check_isinfn ("real(ccos(-4.625 + i Inf)) = -Inf", __real__ result); check_isinfn ("imag(ccos(-4.625 + i Inf)) = -Inf", __imag__ result); result = FUNC(ccos) (BUILD_COMPLEX (-4.625, minus_infty)); check_isinfn ("real(ccos(-4.625 - i Inf)) = -Inf", __real__ result); check_isinfp ("imag(ccos(-4.625 - i Inf)) = +Inf", __imag__ result); result = FUNC(ccos) (BUILD_COMPLEX (plus_infty, 6.75)); check_isnan_exc ("real(ccos(+Inf + i6.75)) = NaN plus invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(ccos(+Inf + i6.75)) = NaN plus invalid exception", __imag__ result); result = FUNC(ccos) (BUILD_COMPLEX (plus_infty, -6.75)); check_isnan_exc ("real(ccos(+Inf - i6.75)) = NaN plus invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(ccos(+Inf - i6.75)) = NaN plus invalid exception", __imag__ result); result = FUNC(ccos) (BUILD_COMPLEX (minus_infty, 6.75)); check_isnan_exc ("real(ccos(-Inf + i6.75)) = NaN plus invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(ccos(-Inf + i6.75)) = NaN plus invalid exception", __imag__ result); result = FUNC(ccos) (BUILD_COMPLEX (minus_infty, -6.75)); check_isnan_exc ("real(ccos(-Inf - i6.75)) = NaN plus invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(ccos(-Inf - i6.75)) = NaN plus invalid exception", __imag__ result); result = FUNC(ccos) (BUILD_COMPLEX (nan_value, 0.0)); check_isnan ("real(ccos(NaN + i0)) = NaN", __real__ result); check ("imag(ccos(NaN + i0)) = +-0", FUNC(fabs) (__imag__ result), 0); result = FUNC(ccos) (BUILD_COMPLEX (nan_value, minus_zero)); check_isnan ("real(ccos(NaN - i0)) = NaN", __real__ result); check ("imag(ccos(NaN - i0)) = +-0", FUNC(fabs) (__imag__ result), 0); result = FUNC(ccos) (BUILD_COMPLEX (nan_value, plus_infty)); check_isinfp ("real(ccos(NaN + i Inf)) = +Inf", __real__ result); check_isnan ("imag(ccos(NaN + i Inf)) = NaN", __imag__ result); result = FUNC(ccos) (BUILD_COMPLEX (nan_value, minus_infty)); check_isinfp ("real(ccos(NaN - i Inf)) = +Inf", __real__ result); check_isnan ("imag(ccos(NaN - i Inf)) = NaN", __imag__ result); result = FUNC(ccos) (BUILD_COMPLEX (nan_value, 9.0)); check_isnan_maybe_exc ("real(ccos(NaN + i9.0)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(ccos(NaN + i9.0)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(ccos) (BUILD_COMPLEX (nan_value, -9.0)); check_isnan_maybe_exc ("real(ccos(NaN - i9.0)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(ccos(NaN - i9.0)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(ccos) (BUILD_COMPLEX (0.0, nan_value)); check_isnan ("real(ccos(0 + i NaN)) = NaN", __real__ result); check ("imag(ccos(0 + i NaN)) = +-0", FUNC(fabs) (__imag__ result), 0.0); result = FUNC(ccos) (BUILD_COMPLEX (minus_zero, nan_value)); check_isnan ("real(ccos(-0 + i NaN)) = NaN", __real__ result); check ("imag(ccos(-0 + i NaN)) = +-0", FUNC(fabs) (__imag__ result), 0.0); result = FUNC(ccos) (BUILD_COMPLEX (10.0, nan_value)); check_isnan_maybe_exc ("real(ccos(10 + i NaN)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(ccos(10 + i NaN)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(ccos) (BUILD_COMPLEX (-10.0, nan_value)); check_isnan_maybe_exc ("real(ccos(-10 + i NaN)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(ccos(-10 + i NaN)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(ccos) (BUILD_COMPLEX (plus_infty, nan_value)); check_isnan_maybe_exc ("real(ccos(+Inf + i NaN)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(ccos(+Inf + i NaN)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(ccos) (BUILD_COMPLEX (minus_infty, nan_value)); check_isnan_maybe_exc ("real(ccos(-Inf + i NaN)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(ccos(-Inf + i NaN)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(ccos) (BUILD_COMPLEX (nan_value, nan_value)); check_isnan ("real(ccos(NaN + i NaN)) = NaN", __real__ result); check_isnan ("imag(ccos(NaN + i NaN)) = NaN", __imag__ result); } static void ccosh_test (void) { __complex__ MATHTYPE result; result = FUNC(ccosh) (BUILD_COMPLEX (0.0, 0.0)); check ("real(ccosh(0 + 0i)) = 1.0", __real__ result, 1.0); check ("imag(ccosh(0 + 0i)) = 0", __imag__ result, 0); result = FUNC(ccosh) (BUILD_COMPLEX (minus_zero, 0.0)); check ("real(ccosh(-0 + 0i)) = 1.0", __real__ result, 1.0); check ("imag(ccosh(-0 + 0i)) = -0", __imag__ result, minus_zero); result = FUNC(ccosh) (BUILD_COMPLEX (0.0, minus_zero)); check ("real(ccosh(0 - 0i)) = 1.0", __real__ result, 1.0); check ("imag(ccosh(0 - 0i)) = -0", __imag__ result, minus_zero); result = FUNC(ccosh) (BUILD_COMPLEX (minus_zero, minus_zero)); check ("real(ccosh(-0 - 0i)) = 1.0", __real__ result, 1.0); check ("imag(ccosh(-0 - 0i)) = 0", __imag__ result, 0.0); result = FUNC(ccosh) (BUILD_COMPLEX (0.0, plus_infty)); check_isnan_exc ("real(ccosh(0 + i Inf)) = NaN plus invalid exception", __real__ result, INVALID_EXCEPTION); check ("imag(ccosh(0 + i Inf)) = +-0 plus invalid exception", FUNC(fabs) (__imag__ result), 0); result = FUNC(ccosh) (BUILD_COMPLEX (minus_zero, plus_infty)); check_isnan_exc ("real(ccosh(-0 + i Inf)) = NaN plus invalid exception", __real__ result, INVALID_EXCEPTION); check ("imag(ccosh(-0 + i Inf)) = +-0 plus invalid exception", FUNC(fabs) (__imag__ result), 0); result = FUNC(ccosh) (BUILD_COMPLEX (0.0, minus_infty)); check_isnan_exc ("real(ccosh(0 - i Inf)) = NaN plus invalid exception", __real__ result, INVALID_EXCEPTION); check ("imag(ccosh(0 - i Inf)) = +-0 plus invalid exception", FUNC(fabs) (__imag__ result), 0); result = FUNC(ccosh) (BUILD_COMPLEX (minus_zero, minus_infty)); check_isnan_exc ("real(ccosh(-0 - i Inf)) = NaN plus invalid exception", __real__ result, INVALID_EXCEPTION); check ("imag(ccosh(-0 - i Inf)) = +-0 plus invalid exception", FUNC(fabs) (__imag__ result), 0); result = FUNC(ccosh) (BUILD_COMPLEX (plus_infty, 0.0)); check_isinfp ("real(ccosh(+Inf + 0i)) = +Inf", __real__ result); check ("imag(ccosh(+Inf + 0i)) = 0", __imag__ result, 0); result = FUNC(ccosh) (BUILD_COMPLEX (minus_infty, 0.0)); check_isinfp ("real(ccosh(-Inf + 0i)) = +Inf", __real__ result); check ("imag(ccosh(-Inf + 0i)) = -0", __imag__ result, minus_zero); result = FUNC(ccosh) (BUILD_COMPLEX (plus_infty, minus_zero)); check_isinfp ("real(ccosh(+Inf - 0i)) = +Inf", __real__ result); check ("imag(ccosh(+Inf - 0i)) = -0", __imag__ result, minus_zero); result = FUNC(ccosh) (BUILD_COMPLEX (minus_infty, minus_zero)); check_isinfp ("real(ccosh(-Inf - 0i)) = +Inf", __real__ result); check ("imag(ccosh(-Inf - 0i)) = 0", __imag__ result, 0.0); result = FUNC(ccosh) (BUILD_COMPLEX (plus_infty, plus_infty)); check_isinfp_exc ("real(ccosh(+Inf + i Inf)) = +Inf plus invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(ccosh(+Inf + i Inf)) = NaN plus invalid exception", __imag__ result); result = FUNC(ccosh) (BUILD_COMPLEX (minus_infty, plus_infty)); check_isinfp_exc ("real(ccosh(-Inf + i Inf)) = +Inf plus invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(ccosh(-Inf + i Inf)) = NaN plus invalid exception", __imag__ result); result = FUNC(ccosh) (BUILD_COMPLEX (plus_infty, minus_infty)); check_isinfp_exc ("real(ccosh(Inf - i Inf)) = +Inf plus invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(ccosh(Inf - i Inf)) = NaN plus invalid exception", __imag__ result); result = FUNC(ccosh) (BUILD_COMPLEX (minus_infty, minus_infty)); check_isinfp_exc ("real(ccosh(-Inf - i Inf)) = +Inf plus invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(ccosh(-Inf - i Inf)) = NaN plus invalid exception", __imag__ result); result = FUNC(ccosh) (BUILD_COMPLEX (plus_infty, 4.625)); check_isinfn ("real(ccosh(+Inf + i4.625)) = -Inf", __real__ result); check_isinfn ("imag(ccosh(+Inf + i4.625)) = -Inf", __imag__ result); result = FUNC(ccosh) (BUILD_COMPLEX (minus_infty, 4.625)); check_isinfn ("real(ccosh(-Inf + i4.625)) = -Inf", __real__ result); check_isinfp ("imag(ccosh(-Inf + i4.625)) = Inf", __imag__ result); result = FUNC(ccosh) (BUILD_COMPLEX (plus_infty, -4.625)); check_isinfn ("real(ccosh(+Inf - i4.625)) = -Inf", __real__ result); check_isinfp ("imag(ccosh(+Inf - i4.625)) = +Inf", __imag__ result); result = FUNC(ccosh) (BUILD_COMPLEX (minus_infty, -4.625)); check_isinfn ("real(ccosh(-Inf - i4.625)) = -Inf", __real__ result); check_isinfn ("imag(ccosh(-Inf - i4.625)) = -Inf", __imag__ result); result = FUNC(ccosh) (BUILD_COMPLEX (6.75, plus_infty)); check_isnan_exc ("real(ccosh(6.75 + i Inf)) = NaN plus invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(ccosh(6.75 + i Inf)) = NaN plus invalid exception", __imag__ result); result = FUNC(ccosh) (BUILD_COMPLEX (-6.75, plus_infty)); check_isnan_exc ("real(ccosh(-6.75 + i Inf)) = NaN plus invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(ccosh(-6.75 + i Inf)) = NaN plus invalid exception", __imag__ result); result = FUNC(ccosh) (BUILD_COMPLEX (6.75, minus_infty)); check_isnan_exc ("real(ccosh(6.75 - i Inf)) = NaN plus invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(ccosh(6.75 - i Inf)) = NaN plus invalid exception", __imag__ result); result = FUNC(ccosh) (BUILD_COMPLEX (-6.75, minus_infty)); check_isnan_exc ("real(ccosh(-6.75 - i Inf)) = NaN plus invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(ccosh(-6.75 - i Inf)) = NaN plus invalid exception", __imag__ result); result = FUNC(ccosh) (BUILD_COMPLEX (0.0, nan_value)); check_isnan ("real(ccosh(0 + i NaN)) = NaN", __real__ result); check ("imag(ccosh(0 + i NaN)) = +-0", FUNC(fabs) (__imag__ result), 0); result = FUNC(ccosh) (BUILD_COMPLEX (minus_zero, nan_value)); check_isnan ("real(ccosh(-0 + i NaN)) = NaN", __real__ result); check ("imag(ccosh(-0 + i NaN)) = +-0", FUNC(fabs) (__imag__ result), 0); result = FUNC(ccosh) (BUILD_COMPLEX (plus_infty, nan_value)); check_isinfp ("real(ccosh(+Inf + i NaN)) = +Inf", __real__ result); check_isnan ("imag(ccosh(+Inf + i NaN)) = NaN", __imag__ result); result = FUNC(ccosh) (BUILD_COMPLEX (minus_infty, nan_value)); check_isinfp ("real(ccosh(-Inf + i NaN)) = +Inf", __real__ result); check_isnan ("imag(ccosh(-Inf + i NaN)) = NaN", __imag__ result); result = FUNC(ccosh) (BUILD_COMPLEX (9.0, nan_value)); check_isnan_maybe_exc ("real(ccosh(9.0 + i NaN)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(ccosh(9.0 + i NaN)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(ccosh) (BUILD_COMPLEX (-9.0, nan_value)); check_isnan_maybe_exc ("real(ccosh(-9.0 + i NaN)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(ccosh(-9.0 + i NaN)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(ccosh) (BUILD_COMPLEX (nan_value, 0.0)); check_isnan ("real(ccosh(NaN + i0)) = NaN", __real__ result); check ("imag(ccosh(NaN + i0)) = +-0", FUNC(fabs) (__imag__ result), 0.0); result = FUNC(ccosh) (BUILD_COMPLEX (nan_value, minus_zero)); check_isnan ("real(ccosh(NaN - i0)) = NaN", __real__ result); check ("imag(ccosh(NaN - i0)) = +-0", FUNC(fabs) (__imag__ result), 0.0); result = FUNC(ccosh) (BUILD_COMPLEX (nan_value, 10.0)); check_isnan_maybe_exc ("real(ccosh(NaN + i10)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(ccosh(NaN + i10)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(ccosh) (BUILD_COMPLEX (nan_value, -10.0)); check_isnan_maybe_exc ("real(ccosh(NaN - i10)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(ccosh(NaN - i10)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(ccosh) (BUILD_COMPLEX (nan_value, plus_infty)); check_isnan_maybe_exc ("real(ccosh(NaN + i Inf)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(ccosh(NaN + i Inf)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(ccosh) (BUILD_COMPLEX (nan_value, minus_infty)); check_isnan_maybe_exc ("real(ccosh(NaN - i Inf)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(ccosh(NaN - i Inf)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(ccosh) (BUILD_COMPLEX (nan_value, nan_value)); check_isnan ("real(ccosh(NaN + i NaN)) = NaN", __real__ result); check_isnan ("imag(ccosh(NaN + i NaN)) = NaN", __imag__ result); } static void cacos_test (void) { __complex__ MATHTYPE result; result = FUNC(cacos) (BUILD_COMPLEX (0, 0)); check ("real(cacos(0 + i0)) = pi/2", __real__ result, M_PI_2); check ("imag(cacos(0 + i0)) = -0", __imag__ result, minus_zero); result = FUNC(cacos) (BUILD_COMPLEX (minus_zero, 0)); check ("real(cacos(-0 + i0)) = pi/2", __real__ result, M_PI_2); check ("imag(cacos(-0 + i0)) = -0", __imag__ result, minus_zero); result = FUNC(cacos) (BUILD_COMPLEX (0, minus_zero)); check ("real(cacos(0 - i0)) = pi/2", __real__ result, M_PI_2); check ("imag(cacos(0 - i0)) = 0", __imag__ result, 0); result = FUNC(cacos) (BUILD_COMPLEX (minus_zero, minus_zero)); check ("real(cacos(-0 - i0)) = pi/2", __real__ result, M_PI_2); check ("imag(cacos(-0 - i0)) = 0", __imag__ result, 0); result = FUNC(cacos) (BUILD_COMPLEX (minus_infty, plus_infty)); check ("real(cacos(-Inf + i Inf)) = 3*pi/4", __real__ result, M_PI - M_PI_4); check_isinfn ("imag(cacos(-Inf + i Inf)) = -Inf", __imag__ result); result = FUNC(cacos) (BUILD_COMPLEX (minus_infty, minus_infty)); check ("real(cacos(-Inf - i Inf)) = 3*pi/4", __real__ result, M_PI - M_PI_4); check_isinfp ("imag(cacos(-Inf - i Inf)) = +Inf", __imag__ result); result = FUNC(cacos) (BUILD_COMPLEX (plus_infty, plus_infty)); check ("real(cacos(+Inf + i Inf)) = pi/4", __real__ result, M_PI_4); check_isinfn ("imag(cacos(+Inf + i Inf)) = -Inf", __imag__ result); result = FUNC(cacos) (BUILD_COMPLEX (plus_infty, minus_infty)); check ("real(cacos(+Inf - i Inf)) = pi/4", __real__ result, M_PI_4); check_isinfp ("imag(cacos(+Inf - i Inf)) = +Inf", __imag__ result); result = FUNC(cacos) (BUILD_COMPLEX (-10.0, plus_infty)); check ("real(cacos(-10.0 + i Inf)) = pi/2", __real__ result, M_PI_2); check_isinfn ("imag(cacos(-10.0 + i Inf)) = -Inf", __imag__ result); result = FUNC(cacos) (BUILD_COMPLEX (-10.0, minus_infty)); check ("real(cacos(-10.0 - i Inf)) = pi/2", __real__ result, M_PI_2); check_isinfp ("imag(cacos(-10.0 - i Inf)) = +Inf", __imag__ result); result = FUNC(cacos) (BUILD_COMPLEX (0, plus_infty)); check ("real(cacos(0 + i Inf)) = pi/2", __real__ result, M_PI_2); check_isinfn ("imag(cacos(0 + i Inf)) = -Inf", __imag__ result); result = FUNC(cacos) (BUILD_COMPLEX (0, minus_infty)); check ("real(cacos(0 - i Inf)) = pi/2", __real__ result, M_PI_2); check_isinfp ("imag(cacos(0 - i Inf)) = +Inf", __imag__ result); result = FUNC(cacos) (BUILD_COMPLEX (0.1, plus_infty)); check ("real(cacos(0.1 + i Inf)) = pi/2", __real__ result, M_PI_2); check_isinfn ("imag(cacos(0.1 + i Inf)) = -Inf", __imag__ result); result = FUNC(cacos) (BUILD_COMPLEX (0.1, minus_infty)); check ("real(cacos(0.1 - i Inf)) = pi/2", __real__ result, M_PI_2); check_isinfp ("imag(cacos(0.1 - i Inf)) = +Inf", __imag__ result); result = FUNC(cacos) (BUILD_COMPLEX (minus_infty, 0)); check ("real(cacos(-Inf + i0)) = pi", __real__ result, M_PI); check_isinfn ("imag(cacos(-Inf + i0)) = -Inf", __imag__ result); result = FUNC(cacos) (BUILD_COMPLEX (minus_infty, minus_zero)); check ("real(cacos(-Inf - i0)) = pi", __real__ result, M_PI); check_isinfp ("imag(cacos(-Inf - i0)) = +Inf", __imag__ result); result = FUNC(cacos) (BUILD_COMPLEX (minus_infty, 100)); check ("real(cacos(-Inf + i100)) = pi", __real__ result, M_PI); check_isinfn ("imag(cacos(-Inf + i100)) = -Inf", __imag__ result); result = FUNC(cacos) (BUILD_COMPLEX (minus_infty, -100)); check ("real(cacos(-Inf - i100)) = pi", __real__ result, M_PI); check_isinfp ("imag(cacos(-Inf - i100)) = +Inf", __imag__ result); result = FUNC(cacos) (BUILD_COMPLEX (plus_infty, 0)); check ("real(cacos(+Inf + i0)) = 0", __real__ result, 0); check_isinfn ("imag(cacos(+Inf + i0)) = -Inf", __imag__ result); result = FUNC(cacos) (BUILD_COMPLEX (plus_infty, minus_zero)); check ("real(cacos(+Inf - i0)) = 0", __real__ result, 0); check_isinfp ("imag(cacos(+Inf - i0)) = +Inf", __imag__ result); result = FUNC(cacos) (BUILD_COMPLEX (plus_infty, 0.5)); check ("real(cacos(+Inf + i0.5)) = 0", __real__ result, 0); check_isinfn ("imag(cacos(+Inf + i0.5)) = -Inf", __imag__ result); result = FUNC(cacos) (BUILD_COMPLEX (plus_infty, -0.5)); check ("real(cacos(+Inf - i0.5)) = 0", __real__ result, 0); check_isinfp ("imag(cacos(+Inf - i0.5)) = +Inf", __imag__ result); result = FUNC(cacos) (BUILD_COMPLEX (plus_infty, nan_value)); check_isnan ("real(cacos(+Inf + i NaN)) = NaN", __real__ result); check_isinfp ("imag(cacos(+Inf + i NaN)) = +-Inf", FUNC(fabs) (__imag__ result)); result = FUNC(cacos) (BUILD_COMPLEX (minus_infty, nan_value)); check_isnan ("real(cacos(-Inf + i NaN)) = NaN", __real__ result); check_isinfp ("imag(cacos(-Inf + i NaN)) = +-Inf", FUNC(fabs) (__imag__ result)); result = FUNC(cacos) (BUILD_COMPLEX (0, nan_value)); check ("real(cacos(0 + i NaN)) = pi/2", __real__ result, M_PI_2); check_isnan ("imag(cacos(0 + i NaN)) = NaN", __imag__ result); result = FUNC(cacos) (BUILD_COMPLEX (minus_zero, nan_value)); check ("real(cacos(-0 + i NaN)) = pi/2", __real__ result, M_PI_2); check_isnan ("imag(cacos(-0 + i NaN)) = NaN", __imag__ result); result = FUNC(cacos) (BUILD_COMPLEX (nan_value, plus_infty)); check_isnan ("real(cacos(NaN + i Inf)) = NaN", __real__ result); check_isinfn ("imag(cacos(NaN + i Inf)) = -Inf", __imag__ result); result = FUNC(cacos) (BUILD_COMPLEX (nan_value, minus_infty)); check_isnan ("real(cacos(NaN - i Inf)) = NaN", __real__ result); check_isinfp ("imag(cacos(NaN - i Inf)) = +Inf", __imag__ result); result = FUNC(cacos) (BUILD_COMPLEX (10.5, nan_value)); check_isnan_maybe_exc ("real(cacos(10.5 + i NaN)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(cacos(10.5 + i NaN)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(cacos) (BUILD_COMPLEX (-10.5, nan_value)); check_isnan_maybe_exc ("real(cacos(-10.5 + i NaN)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(cacos(-10.5 + i NaN)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(cacos) (BUILD_COMPLEX (nan_value, 0.75)); check_isnan_maybe_exc ("real(cacos(NaN + i0.75)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(cacos(NaN + i0.75)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(cacos) (BUILD_COMPLEX (-10.5, nan_value)); check_isnan_maybe_exc ("real(cacos(NaN - i0.75)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(cacos(NaN - i0.75)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(cacos) (BUILD_COMPLEX (nan_value, nan_value)); check_isnan ("real(cacos(NaN + i NaN)) = NaN", __real__ result); check_isnan ("imag(cacos(NaN + i NaN)) = NaN", __imag__ result); } static void cacosh_test (void) { __complex__ MATHTYPE result; result = FUNC(cacosh) (BUILD_COMPLEX (0, 0)); check ("real(cacosh(0 + i0)) = 0", __real__ result, 0); check ("imag(cacosh(0 + i0)) = pi/2", __imag__ result, M_PI_2); result = FUNC(cacosh) (BUILD_COMPLEX (minus_zero, 0)); check ("real(cacosh(-0 + i0)) = 0", __real__ result, 0); check ("imag(cacosh(-0 + i0)) = pi/2", __imag__ result, M_PI_2); result = FUNC(cacosh) (BUILD_COMPLEX (0, minus_zero)); check ("real(cacosh(0 - i0)) = 0", __real__ result, 0); check ("imag(cacosh(0 - i0)) = -pi/2", __imag__ result, -M_PI_2); result = FUNC(cacosh) (BUILD_COMPLEX (minus_zero, minus_zero)); check ("real(cacosh(-0 - i0)) = 0", __real__ result, 0); check ("imag(cacosh(-0 - i0)) = -pi/2", __imag__ result, -M_PI_2); result = FUNC(cacosh) (BUILD_COMPLEX (minus_infty, plus_infty)); check_isinfp ("real(cacosh(-Inf + i Inf)) = +Inf", __real__ result); check ("imag(cacosh(-Inf + i Inf)) = 3*pi/4", __imag__ result, M_PI - M_PI_4); result = FUNC(cacosh) (BUILD_COMPLEX (minus_infty, minus_infty)); check_isinfp ("real(cacosh(-Inf - i Inf)) = +Inf", __real__ result); check ("imag(cacosh(-Inf - i Inf)) = -3*pi/4", __imag__ result, M_PI_4 - M_PI); result = FUNC(cacosh) (BUILD_COMPLEX (plus_infty, plus_infty)); check_isinfp ("real(cacosh(+Inf + i Inf)) = +Inf", __real__ result); check ("imag(cacosh(+Inf + i Inf)) = pi/4", __imag__ result, M_PI_4); result = FUNC(cacosh) (BUILD_COMPLEX (plus_infty, minus_infty)); check_isinfp ("real(cacosh(+Inf - i Inf)) = +Inf", __real__ result); check ("imag(cacosh(+Inf - i Inf)) = -pi/4", __imag__ result, -M_PI_4); result = FUNC(cacosh) (BUILD_COMPLEX (-10.0, plus_infty)); check_isinfp ("real(cacosh(-10.0 + i Inf)) = +Inf", __real__ result); check ("imag(cacosh(-10.0 + i Inf)) = pi/2", __imag__ result, M_PI_2); result = FUNC(cacosh) (BUILD_COMPLEX (-10.0, minus_infty)); check_isinfp ("real(cacosh(-10.0 - i Inf)) = +Inf", __real__ result); check ("imag(cacosh(-10.0 - i Inf)) = -pi/2", __imag__ result, -M_PI_2); result = FUNC(cacosh) (BUILD_COMPLEX (0, plus_infty)); check_isinfp ("real(cacosh(0 + i Inf)) = +Inf", __real__ result); check ("imag(cacosh(0 + i Inf)) = pi/2", __imag__ result, M_PI_2); result = FUNC(cacosh) (BUILD_COMPLEX (0, minus_infty)); check_isinfp ("real(cacosh(0 - i Inf)) = +Inf", __real__ result); check ("imag(cacosh(0 - i Inf)) = -pi/2", __imag__ result, -M_PI_2); result = FUNC(cacosh) (BUILD_COMPLEX (0.1, plus_infty)); check_isinfp ("real(cacosh(0.1 + i Inf)) = +Inf", __real__ result); check ("imag(cacosh(0.1 + i Inf)) = pi/2", __imag__ result, M_PI_2); result = FUNC(cacosh) (BUILD_COMPLEX (0.1, minus_infty)); check_isinfp ("real(cacosh(0.1 - i Inf)) = +Inf", __real__ result); check ("imag(cacosh(0.1 - i Inf)) = -pi/2", __imag__ result, -M_PI_2); result = FUNC(cacosh) (BUILD_COMPLEX (minus_infty, 0)); check_isinfp ("real(cacosh(-Inf + i0)) = +Inf", __real__ result); check ("imag(cacosh(-Inf + i0)) = pi", __imag__ result, M_PI); result = FUNC(cacosh) (BUILD_COMPLEX (minus_infty, minus_zero)); check_isinfp ("real(cacosh(-Inf - i0)) = +Inf", __real__ result); check ("imag(cacosh(-Inf - i0)) = -pi", __imag__ result, -M_PI); result = FUNC(cacosh) (BUILD_COMPLEX (minus_infty, 100)); check_isinfp ("real(cacosh(-Inf + i100)) = +Inf", __real__ result); check ("imag(cacosh(-Inf + i100)) = pi", __imag__ result, M_PI); result = FUNC(cacosh) (BUILD_COMPLEX (minus_infty, -100)); check_isinfp ("real(cacosh(-Inf - i100)) = +Inf", __real__ result); check ("imag(cacosh(-Inf - i100)) = -pi", __imag__ result, -M_PI); result = FUNC(cacosh) (BUILD_COMPLEX (plus_infty, 0)); check_isinfp ("real(cacosh(+Inf + i0)) = +Inf", __real__ result); check ("imag(cacosh(+Inf + i0)) = 0", __imag__ result, 0); result = FUNC(cacosh) (BUILD_COMPLEX (plus_infty, minus_zero)); check_isinfp ("real(cacosh(+Inf - i0)) = +Inf", __real__ result); check ("imag(cacosh(+Inf - i0)) = -0", __imag__ result, minus_zero); result = FUNC(cacosh) (BUILD_COMPLEX (plus_infty, 0.5)); check_isinfp ("real(cacosh(+Inf + i0.5)) = +Inf", __real__ result); check ("imag(cacosh(+Inf + i0.5)) = 0", __imag__ result, 0); result = FUNC(cacosh) (BUILD_COMPLEX (plus_infty, -0.5)); check_isinfp ("real(cacosh(+Inf - i0.5)) = +Inf", __real__ result); check ("imag(cacosh(+Inf - i0.5)) = -0", __imag__ result, minus_zero); result = FUNC(cacosh) (BUILD_COMPLEX (plus_infty, nan_value)); check_isinfp ("real(cacosh(+Inf + i NaN)) = +Inf", __real__ result); check_isnan ("imag(cacosh(+Inf + i NaN)) = NaN", __imag__ result); result = FUNC(cacosh) (BUILD_COMPLEX (minus_infty, nan_value)); check_isinfp ("real(cacosh(-Inf + i NaN)) = +Inf", __real__ result); check_isnan ("imag(cacosh(-Inf + i NaN)) = NaN", __imag__ result); result = FUNC(cacosh) (BUILD_COMPLEX (0, nan_value)); check_isnan ("real(cacosh(0 + i NaN)) = NaN", __real__ result); check_isnan ("imag(cacosh(0 + i NaN)) = NaN", __imag__ result); result = FUNC(cacosh) (BUILD_COMPLEX (minus_zero, nan_value)); check_isnan ("real(cacosh(-0 + i NaN)) = NaN", __real__ result); check_isnan ("imag(cacosh(-0 + i NaN)) = NaN", __imag__ result); result = FUNC(cacosh) (BUILD_COMPLEX (nan_value, plus_infty)); check_isinfp ("real(cacosh(NaN + i Inf)) = +Inf", __real__ result); check_isnan ("imag(cacosh(NaN + i Inf)) = NaN", __imag__ result); result = FUNC(cacosh) (BUILD_COMPLEX (nan_value, minus_infty)); check_isinfp ("real(cacosh(NaN - i Inf)) = +Inf", __real__ result); check_isnan ("imag(cacosh(NaN - i Inf)) = NaN", __imag__ result); result = FUNC(cacosh) (BUILD_COMPLEX (10.5, nan_value)); check_isnan_maybe_exc ("real(cacosh(10.5 + i NaN)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(cacosh(10.5 + i NaN)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(cacosh) (BUILD_COMPLEX (-10.5, nan_value)); check_isnan_maybe_exc ("real(cacosh(-10.5 + i NaN)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(cacosh(-10.5 + i NaN)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(cacosh) (BUILD_COMPLEX (nan_value, 0.75)); check_isnan_maybe_exc ("real(cacosh(NaN + i0.75)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(cacosh(NaN + i0.75)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(cacosh) (BUILD_COMPLEX (-10.5, nan_value)); check_isnan_maybe_exc ("real(cacosh(NaN - i0.75)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(cacosh(NaN - i0.75)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(cacosh) (BUILD_COMPLEX (nan_value, nan_value)); check_isnan ("real(cacosh(NaN + i NaN)) = NaN", __real__ result); check_isnan ("imag(cacosh(NaN + i NaN)) = NaN", __imag__ result); } static void casin_test (void) { __complex__ MATHTYPE result; result = FUNC(casin) (BUILD_COMPLEX (0, 0)); check ("real(casin(0 + i0)) = 0", __real__ result, 0); check ("imag(casin(0 + i0)) = 0", __imag__ result, 0); result = FUNC(casin) (BUILD_COMPLEX (minus_zero, 0)); check ("real(casin(-0 + i0)) = -0", __real__ result, minus_zero); check ("imag(casin(-0 + i0)) = 0", __imag__ result, 0); result = FUNC(casin) (BUILD_COMPLEX (0, minus_zero)); check ("real(casin(0 - i0)) = 0", __real__ result, 0); check ("imag(casin(0 - i0)) = -0", __imag__ result, minus_zero); result = FUNC(casin) (BUILD_COMPLEX (minus_zero, minus_zero)); check ("real(casin(-0 - i0)) = -0", __real__ result, minus_zero); check ("imag(casin(-0 - i0)) = -0", __imag__ result, minus_zero); result = FUNC(casin) (BUILD_COMPLEX (plus_infty, plus_infty)); check ("real(casin(+Inf + i Inf)) = pi/4", __real__ result, M_PI_4); check_isinfp ("imag(casin(+Inf + i Inf)) = +Inf", __imag__ result); result = FUNC(casin) (BUILD_COMPLEX (plus_infty, minus_infty)); check ("real(casin(+Inf - i Inf)) = pi/4", __real__ result, M_PI_4); check_isinfn ("imag(casin(+Inf - i Inf)) = -Inf", __imag__ result); result = FUNC(casin) (BUILD_COMPLEX (minus_infty, plus_infty)); check ("real(casin(-Inf + i Inf)) = -pi/4", __real__ result, -M_PI_4); check_isinfp ("imag(casin(-Inf + i Inf)) = +Inf", __imag__ result); result = FUNC(casin) (BUILD_COMPLEX (minus_infty, minus_infty)); check ("real(casin(-Inf - i Inf)) = -pi/4", __real__ result, -M_PI_4); check_isinfn ("imag(casin(-Inf - i Inf)) = -Inf", __imag__ result); result = FUNC(casin) (BUILD_COMPLEX (-10.0, plus_infty)); check ("real(casin(-10.0 + i Inf)) = -0", __real__ result, minus_zero); check_isinfp ("imag(casin(-10.0 + i Inf)) = +Inf", __imag__ result); result = FUNC(casin) (BUILD_COMPLEX (-10.0, minus_infty)); check ("real(casin(-10.0 - i Inf)) = -0", __real__ result, minus_zero); check_isinfn ("imag(casin(-10.0 - i Inf)) = -Inf", __imag__ result); result = FUNC(casin) (BUILD_COMPLEX (0, plus_infty)); check ("real(casin(0 + i Inf)) = 0", __real__ result, 0.0); check_isinfp ("imag(casin(0 + i Inf)) = +Inf", __imag__ result); result = FUNC(casin) (BUILD_COMPLEX (0, minus_infty)); check ("real(casin(0 - i Inf)) = 0", __real__ result, 0.0); check_isinfn ("imag(casin(0 - i Inf)) = -Inf", __imag__ result); result = FUNC(casin) (BUILD_COMPLEX (minus_zero, plus_infty)); check ("real(casin(-0 + i Inf)) = -0", __real__ result, minus_zero); check_isinfp ("imag(casin(-0 + i Inf)) = +Inf", __imag__ result); result = FUNC(casin) (BUILD_COMPLEX (minus_zero, minus_infty)); check ("real(casin(-0 - i Inf)) = -0", __real__ result, minus_zero); check_isinfn ("imag(casin(-0 - i Inf)) = -Inf", __imag__ result); result = FUNC(casin) (BUILD_COMPLEX (0.1, plus_infty)); check ("real(casin(0.1 + i Inf)) = 0", __real__ result, 0); check_isinfp ("imag(casin(0.1 + i Inf)) = +Inf", __imag__ result); result = FUNC(casin) (BUILD_COMPLEX (0.1, minus_infty)); check ("real(casin(0.1 - i Inf)) = 0", __real__ result, 0); check_isinfn ("imag(casin(0.1 - i Inf)) = -Inf", __imag__ result); result = FUNC(casin) (BUILD_COMPLEX (minus_infty, 0)); check ("real(casin(-Inf + i0)) = -pi/2", __real__ result, -M_PI_2); check_isinfp ("imag(casin(-Inf + i0)) = +Inf", __imag__ result); result = FUNC(casin) (BUILD_COMPLEX (minus_infty, minus_zero)); check ("real(casin(-Inf - i0)) = -pi/2", __real__ result, -M_PI_2); check_isinfn ("imag(casin(-Inf - i0)) = -Inf", __imag__ result); result = FUNC(casin) (BUILD_COMPLEX (minus_infty, 100)); check ("real(casin(-Inf + i100)) = -pi/2", __real__ result, -M_PI_2); check_isinfp ("imag(casin(-Inf + i100)) = +Inf", __imag__ result); result = FUNC(casin) (BUILD_COMPLEX (minus_infty, -100)); check ("real(casin(-Inf - i100)) = -pi/2", __real__ result, -M_PI_2); check_isinfn ("imag(casin(-Inf - i100)) = -Inf", __imag__ result); result = FUNC(casin) (BUILD_COMPLEX (plus_infty, 0)); check ("real(casin(+Inf + i0)) = pi/2", __real__ result, M_PI_2); check_isinfp ("imag(casin(+Inf + i0)) = +Inf", __imag__ result); result = FUNC(casin) (BUILD_COMPLEX (plus_infty, minus_zero)); check ("real(casin(+Inf - i0)) = pi/2", __real__ result, M_PI_2); check_isinfn ("imag(casin(+Inf - i0)) = -Inf", __imag__ result); result = FUNC(casin) (BUILD_COMPLEX (plus_infty, 0.5)); check ("real(casin(+Inf + i0.5)) = pi/2", __real__ result, M_PI_2); check_isinfp ("imag(casin(+Inf + i0.5)) = +Inf", __imag__ result); result = FUNC(casin) (BUILD_COMPLEX (plus_infty, -0.5)); check ("real(casin(+Inf - i0.5)) = pi/2", __real__ result, M_PI_2); check_isinfn ("imag(casin(+Inf - i0.5)) = -Inf", __imag__ result); result = FUNC(casin) (BUILD_COMPLEX (nan_value, plus_infty)); check_isnan ("real(casin(NaN + i Inf)) = NaN", __real__ result); check_isinfp ("imag(casin(NaN + i Inf)) = +Inf", __imag__ result); result = FUNC(casin) (BUILD_COMPLEX (nan_value, minus_infty)); check_isnan ("real(casin(NaN - i Inf)) = NaN", __real__ result); check_isinfn ("imag(casin(NaN - i Inf)) = -Inf", __imag__ result); result = FUNC(casin) (BUILD_COMPLEX (0.0, nan_value)); check ("real(casin(0 + i NaN)) = 0", __real__ result, 0.0); check_isnan ("imag(casin(0 + i NaN)) = NaN", __imag__ result); result = FUNC(casin) (BUILD_COMPLEX (minus_zero, nan_value)); check ("real(casin(-0 + i NaN)) = -0", __real__ result, minus_zero); check_isnan ("imag(casin(-0 + i NaN)) = NaN", __imag__ result); result = FUNC(casin) (BUILD_COMPLEX (plus_infty, nan_value)); check_isnan ("real(casin(+Inf + i NaN)) = NaN", __real__ result); check_isinfp ("imag(casin(+Inf + i NaN)) = +-Inf", FUNC(fabs) (__imag__ result)); result = FUNC(casin) (BUILD_COMPLEX (minus_infty, nan_value)); check_isnan ("real(casin(-Inf + i NaN)) = NaN", __real__ result); check_isinfp ("imag(casin(-Inf + NaN)) = +-Inf", FUNC(fabs) (__imag__ result)); result = FUNC(casin) (BUILD_COMPLEX (nan_value, 10.5)); check_isnan_maybe_exc ("real(casin(NaN + i10.5)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(casin(NaN + i10.5)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(casin) (BUILD_COMPLEX (nan_value, -10.5)); check_isnan_maybe_exc ("real(casin(NaN - i10.5)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(casin(NaN - i10.5)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(casin) (BUILD_COMPLEX (0.75, nan_value)); check_isnan_maybe_exc ("real(casin(0.75 + i NaN)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(casin(0.75 + i NaN)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(casin) (BUILD_COMPLEX (-0.75, nan_value)); check_isnan_maybe_exc ("real(casin(-0.75 + i NaN)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(casin(-0.75 + i NaN)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(casin) (BUILD_COMPLEX (nan_value, nan_value)); check_isnan ("real(casin(NaN + i NaN)) = NaN", __real__ result); check_isnan ("imag(casin(NaN + i NaN)) = NaN", __imag__ result); } static void casinh_test (void) { __complex__ MATHTYPE result; result = FUNC(casinh) (BUILD_COMPLEX (0, 0)); check ("real(casinh(0 + i0)) = 0", __real__ result, 0); check ("imag(casinh(0 + i0)) = 0", __imag__ result, 0); result = FUNC(casinh) (BUILD_COMPLEX (minus_zero, 0)); check ("real(casinh(-0 + i0)) = -0", __real__ result, minus_zero); check ("imag(casinh(-0 + i0)) = 0", __imag__ result, 0); result = FUNC(casinh) (BUILD_COMPLEX (0, minus_zero)); check ("real(casinh(0 - i0)) = 0", __real__ result, 0); check ("imag(casinh(0 - i0)) = -0", __imag__ result, minus_zero); result = FUNC(casinh) (BUILD_COMPLEX (minus_zero, minus_zero)); check ("real(casinh(-0 - i0)) = -0", __real__ result, minus_zero); check ("imag(casinh(-0 - i0)) = -0", __imag__ result, minus_zero); result = FUNC(casinh) (BUILD_COMPLEX (plus_infty, plus_infty)); check_isinfp ("real(casinh(+Inf + i Inf)) = +Inf", __real__ result); check ("imag(casinh(+Inf + i Inf)) = pi/4", __imag__ result, M_PI_4); result = FUNC(casinh) (BUILD_COMPLEX (plus_infty, minus_infty)); check_isinfp ("real(casinh(+Inf - i Inf)) = +Inf", __real__ result); check ("imag(casinh(+Inf - i Inf)) = -pi/4", __imag__ result, -M_PI_4); result = FUNC(casinh) (BUILD_COMPLEX (minus_infty, plus_infty)); check_isinfn ("real(casinh(-Inf + i Inf)) = -Inf", __real__ result); check ("imag(casinh(-Inf + i Inf)) = pi/4", __imag__ result, M_PI_4); result = FUNC(casinh) (BUILD_COMPLEX (minus_infty, minus_infty)); check_isinfn ("real(casinh(-Inf - i Inf)) = -Inf", __real__ result); check ("imag(casinh(-Inf - i Inf)) = -pi/4", __imag__ result, -M_PI_4); result = FUNC(casinh) (BUILD_COMPLEX (-10.0, plus_infty)); check_isinfn ("real(casinh(-10.0 + i Inf)) = -Inf", __real__ result); check ("imag(casinh(-10.0 + i Inf)) = pi/2", __imag__ result, M_PI_2); result = FUNC(casinh) (BUILD_COMPLEX (-10.0, minus_infty)); check_isinfn ("real(casinh(-10.0 - i Inf)) = -Inf", __real__ result); check ("imag(casinh(-10.0 - i Inf)) = -pi/2", __imag__ result, -M_PI_2); result = FUNC(casinh) (BUILD_COMPLEX (0, plus_infty)); check_isinfp ("real(casinh(0 + i Inf)) = +Inf", __real__ result); check ("imag(casinh(0 + i Inf)) = pi/2", __imag__ result, M_PI_2); result = FUNC(casinh) (BUILD_COMPLEX (0, minus_infty)); check_isinfp ("real(casinh(0 - i Inf)) = +Inf", __real__ result); check ("imag(casinh(0 - i Inf)) = -pi/2", __imag__ result, -M_PI_2); result = FUNC(casinh) (BUILD_COMPLEX (minus_zero, plus_infty)); check_isinfn ("real(casinh(-0 + i Inf)) = -Inf", __real__ result); check ("imag(casinh(-0 + i Inf)) = pi/2", __imag__ result, M_PI_2); result = FUNC(casinh) (BUILD_COMPLEX (minus_zero, minus_infty)); check_isinfn ("real(casinh(-0 - i Inf)) = -Inf", __real__ result); check ("imag(casinh(-0 - i Inf)) = -pi/2", __imag__ result, -M_PI_2); result = FUNC(casinh) (BUILD_COMPLEX (0.1, plus_infty)); check_isinfp ("real(casinh(0.1 + i Inf)) = +Inf", __real__ result); check ("imag(casinh(0.1 + i Inf)) = pi/2", __imag__ result, M_PI_2); result = FUNC(casinh) (BUILD_COMPLEX (0.1, minus_infty)); check_isinfp ("real(casinh(0.1 - i Inf)) = +Inf", __real__ result); check ("imag(casinh(0.1 - i Inf)) = -pi/2", __imag__ result, -M_PI_2); result = FUNC(casinh) (BUILD_COMPLEX (minus_infty, 0)); check_isinfn ("real(casinh(-Inf + i0)) = -Inf", __real__ result); check ("imag(casinh(-Inf + i0)) = 0", __imag__ result, 0); result = FUNC(casinh) (BUILD_COMPLEX (minus_infty, minus_zero)); check_isinfn ("real(casinh(-Inf - i0)) = -Inf", __real__ result); check ("imag(casinh(-Inf - i0)) = -0", __imag__ result, minus_zero); result = FUNC(casinh) (BUILD_COMPLEX (minus_infty, 100)); check_isinfn ("real(casinh(-Inf + i100)) = -Inf", __real__ result); check ("imag(casinh(-Inf + i100)) = 0", __imag__ result, 0); result = FUNC(casinh) (BUILD_COMPLEX (minus_infty, -100)); check_isinfn ("real(casinh(-Inf - i100)) = -Inf", __real__ result); check ("imag(casinh(-Inf - i100)) = -0", __imag__ result, minus_zero); result = FUNC(casinh) (BUILD_COMPLEX (plus_infty, 0)); check_isinfp ("real(casinh(+Inf + i0)) = +Inf", __real__ result); check ("imag(casinh(+Inf + i0)) = 0", __imag__ result, 0); result = FUNC(casinh) (BUILD_COMPLEX (plus_infty, minus_zero)); check_isinfp ("real(casinh(+Inf - i0)) = +Inf", __real__ result); check ("imag(casinh(+Inf - i0)) = -0", __imag__ result, minus_zero); result = FUNC(casinh) (BUILD_COMPLEX (plus_infty, 0.5)); check_isinfp ("real(casinh(+Inf + i0.5)) = +Inf", __real__ result); check ("imag(casinh(+Inf + i0.5)) = 0", __imag__ result, 0); result = FUNC(casinh) (BUILD_COMPLEX (plus_infty, -0.5)); check_isinfp ("real(casinh(+Inf - i0.5)) = +Inf", __real__ result); check ("imag(casinh(+Inf - i0.5)) = -0", __imag__ result, minus_zero); result = FUNC(casinh) (BUILD_COMPLEX (plus_infty, nan_value)); check_isinfp ("real(casinh(+Inf + i NaN)) = +Inf", __real__ result); check_isnan ("imag(casinh(+Inf + i NaN)) = NaN", __imag__ result); result = FUNC(casinh) (BUILD_COMPLEX (minus_infty, nan_value)); check_isinfn ("real(casinh(-Inf + i NaN)) = -Inf", __real__ result); check_isnan ("imag(casinh(-Inf + i NaN)) = NaN", __imag__ result); result = FUNC(casinh) (BUILD_COMPLEX (nan_value, 0)); check_isnan ("real(casinh(NaN + i0)) = NaN", __real__ result); check ("imag(casinh(NaN + i0)) = 0", __imag__ result, 0); result = FUNC(casinh) (BUILD_COMPLEX (nan_value, minus_zero)); check_isnan ("real(casinh(NaN - i0)) = NaN", __real__ result); check ("imag(casinh(NaN - i0)) = -0", __imag__ result, minus_zero); result = FUNC(casinh) (BUILD_COMPLEX (nan_value, plus_infty)); check_isinfp ("real(casinh(NaN + i Inf)) = +-Inf", FUNC(fabs) (__real__ result)); check_isnan ("imag(casinh(NaN + i Inf)) = NaN", __imag__ result); result = FUNC(casinh) (BUILD_COMPLEX (nan_value, minus_infty)); check_isinfp ("real(casinh(NaN - i Inf)) = +-Inf", FUNC(fabs) (__real__ result)); check_isnan ("imag(casinh(NaN - i Inf)) = NaN", __imag__ result); result = FUNC(casinh) (BUILD_COMPLEX (10.5, nan_value)); check_isnan_maybe_exc ("real(casinh(10.5 + i NaN)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(casinh(10.5 + i NaN)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(casinh) (BUILD_COMPLEX (-10.5, nan_value)); check_isnan_maybe_exc ("real(casinh(-10.5 + i NaN)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(casinh(-10.5 + i NaN)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(casinh) (BUILD_COMPLEX (nan_value, 0.75)); check_isnan_maybe_exc ("real(casinh(NaN + i0.75)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(casinh(NaN + i0.75)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(casinh) (BUILD_COMPLEX (-0.75, nan_value)); check_isnan_maybe_exc ("real(casinh(NaN - i0.75)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(casinh(NaN - i0.75)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(casinh) (BUILD_COMPLEX (nan_value, nan_value)); check_isnan ("real(casinh(NaN + i NaN)) = NaN", __real__ result); check_isnan ("imag(casinh(NaN + i NaN)) = NaN", __imag__ result); } static void catan_test (void) { __complex__ MATHTYPE result; result = FUNC(catan) (BUILD_COMPLEX (0, 0)); check ("real(catan(0 + i0)) = 0", __real__ result, 0); check ("imag(catan(0 + i0)) = 0", __imag__ result, 0); result = FUNC(catan) (BUILD_COMPLEX (minus_zero, 0)); check ("real(catan(-0 + i0)) = -0", __real__ result, minus_zero); check ("imag(catan(-0 + i0)) = 0", __imag__ result, 0); result = FUNC(catan) (BUILD_COMPLEX (0, minus_zero)); check ("real(catan(0 - i0)) = 0", __real__ result, 0); check ("imag(catan(0 - i0)) = -0", __imag__ result, minus_zero); result = FUNC(catan) (BUILD_COMPLEX (minus_zero, minus_zero)); check ("real(catan(-0 - i0)) = -0", __real__ result, minus_zero); check ("imag(catan(-0 - i0)) = -0", __imag__ result, minus_zero); result = FUNC(catan) (BUILD_COMPLEX (plus_infty, plus_infty)); check ("real(catan(+Inf + i Inf)) = pi/2", __real__ result, M_PI_2); check ("imag(catan(+Inf + i Inf)) = 0", __imag__ result, 0); result = FUNC(catan) (BUILD_COMPLEX (plus_infty, minus_infty)); check ("real(catan(+Inf - i Inf)) = pi/2", __real__ result, M_PI_2); check ("imag(catan(+Inf - i Inf)) = -0", __imag__ result, minus_zero); result = FUNC(catan) (BUILD_COMPLEX (minus_infty, plus_infty)); check ("real(catan(-Inf + i Inf)) = -pi/2", __real__ result, -M_PI_2); check ("imag(catan(-Inf + i Inf)) = 0", __imag__ result, 0.0); result = FUNC(catan) (BUILD_COMPLEX (minus_infty, minus_infty)); check ("real(catan(-Inf - i Inf)) = -pi/2", __real__ result, -M_PI_2); check ("imag(catan(-Inf - i Inf)) = -0", __imag__ result, minus_zero); result = FUNC(catan) (BUILD_COMPLEX (plus_infty, -10.0)); check ("real(catan(+Inf - i10.0)) = pi/2", __real__ result, M_PI_2); check ("imag(catan(+Inf - i10.0)) = -0", __imag__ result, minus_zero); result = FUNC(catan) (BUILD_COMPLEX (minus_infty, -10.0)); check ("real(catan(-Inf - i10.0)) = -pi/2", __real__ result, -M_PI_2); check ("imag(catan(-Inf - i10.0)) = -0", __imag__ result, minus_zero); result = FUNC(catan) (BUILD_COMPLEX (plus_infty, minus_zero)); check ("real(catan(Inf - i0)) = pi/2", __real__ result, M_PI_2); check ("imag(catan(Inf - i0)) = -0", __imag__ result, minus_zero); result = FUNC(catan) (BUILD_COMPLEX (minus_infty, minus_zero)); check ("real(catan(-Inf - i0)) = -pi/2", __real__ result, -M_PI_2); check ("imag(catan(-Inf - i0)) = -0", __imag__ result, minus_zero); result = FUNC(catan) (BUILD_COMPLEX (plus_infty, 0.0)); check ("real(catan(Inf + i0)) = pi/2", __real__ result, M_PI_2); check ("imag(catan(Inf + i0)) = 0", __imag__ result, 0.0); result = FUNC(catan) (BUILD_COMPLEX (minus_infty, 0.0)); check ("real(catan(-Inf + i0)) = -pi/2", __real__ result, -M_PI_2); check ("imag(catan(-Inf + i0)) = 0", __imag__ result, 0.0); result = FUNC(catan) (BUILD_COMPLEX (plus_infty, 0.1)); check ("real(catan(+Inf + i0.1)) = pi/2", __real__ result, M_PI_2); check ("imag(catan(+Inf + i0.1)) = 0", __imag__ result, 0); result = FUNC(catan) (BUILD_COMPLEX (minus_infty, 0.1)); check ("real(catan(-Inf + i0.1)) = -pi/2", __real__ result, -M_PI_2); check ("imag(catan(-Inf + i0.1)) = 0", __imag__ result, 0); result = FUNC(catan) (BUILD_COMPLEX (0.0, minus_infty)); check ("real(catan(0 - i Inf)) = pi/2", __real__ result, M_PI_2); check ("imag(catan(0 - i Inf)) = -0", __imag__ result, minus_zero); result = FUNC(catan) (BUILD_COMPLEX (minus_zero, minus_infty)); check ("real(catan(-0 - i Inf)) = -pi/2", __real__ result, -M_PI_2); check ("imag(catan(-0 - i Inf)) = -0", __imag__ result, minus_zero); result = FUNC(catan) (BUILD_COMPLEX (100.0, minus_infty)); check ("real(catan(100 - i Inf)) = pi/2", __real__ result, M_PI_2); check ("imag(catan(100 - i Inf)) = -0", __imag__ result, minus_zero); result = FUNC(catan) (BUILD_COMPLEX (-100.0, minus_infty)); check ("real(catan(-100 - i Inf)) = -pi/2", __real__ result, -M_PI_2); check ("imag(catan(-100 - i Inf)) = -0", __imag__ result, minus_zero); result = FUNC(catan) (BUILD_COMPLEX (0.0, plus_infty)); check ("real(catan(0 + i Inf)) = pi/2", __real__ result, M_PI_2); check ("imag(catan(0 + i Inf)) = 0", __imag__ result, 0); result = FUNC(catan) (BUILD_COMPLEX (minus_zero, plus_infty)); check ("real(catan(-0 + i Inf)) = -pi/2", __real__ result, -M_PI_2); check ("imag(catan(-0 + i Inf)) = 0", __imag__ result, 0); result = FUNC(catan) (BUILD_COMPLEX (0.5, plus_infty)); check ("real(catan(0.5 + i Inf)) = pi/2", __real__ result, M_PI_2); check ("imag(catan(0.5 + i Inf)) = 0", __imag__ result, 0); result = FUNC(catan) (BUILD_COMPLEX (-0.5, plus_infty)); check ("real(catan(-0.5 + i Inf)) = -pi/2", __real__ result, -M_PI_2); check ("imag(catan(-0.5 + i Inf)) = 0", __imag__ result, 0); result = FUNC(catan) (BUILD_COMPLEX (nan_value, 0.0)); check_isnan ("real(catan(NaN + i0)) = NaN", __real__ result); check ("imag(catan(NaN + i0)) = 0", __imag__ result, 0.0); result = FUNC(catan) (BUILD_COMPLEX (nan_value, minus_zero)); check_isnan ("real(catan(NaN - i0)) = NaN", __real__ result); check ("imag(catan(NaN - i0)) = -0", __imag__ result, minus_zero); result = FUNC(catan) (BUILD_COMPLEX (nan_value, plus_infty)); check_isnan ("real(catan(NaN + i Inf)) = NaN", __real__ result); check ("imag(catan(NaN + i Inf)) = 0", __imag__ result, 0); result = FUNC(catan) (BUILD_COMPLEX (nan_value, minus_infty)); check_isnan ("real(catan(NaN - i Inf)) = NaN", __real__ result); check ("imag(catan(NaN - i Inf)) = -0", __imag__ result, minus_zero); result = FUNC(catan) (BUILD_COMPLEX (0.0, nan_value)); check_isnan ("real(catan(0 + i NaN)) = NaN", __real__ result); check_isnan ("imag(catan(0 + i NaN)) = NaN", __imag__ result); result = FUNC(catan) (BUILD_COMPLEX (minus_zero, nan_value)); check_isnan ("real(catan(-0 + i NaN)) = NaN", __real__ result); check_isnan ("imag(catan(-0 + i NaN)) = NaN", __imag__ result); result = FUNC(catan) (BUILD_COMPLEX (plus_infty, nan_value)); check ("real(catan(+Inf + i NaN)) = pi/2", __real__ result, M_PI_2); check ("imag(catan(+Inf + i NaN)) = +-0", FUNC(fabs) (__imag__ result), 0); result = FUNC(catan) (BUILD_COMPLEX (minus_infty, nan_value)); check ("real(catan(-Inf + i NaN)) = -pi/2", __real__ result, -M_PI_2); check ("imag(catan(-Inf + i NaN)) = +-0", FUNC(fabs) (__imag__ result), 0); result = FUNC(catan) (BUILD_COMPLEX (nan_value, 10.5)); check_isnan_maybe_exc ("real(catan(NaN + i10.5)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(catan(NaN + i10.5)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(catan) (BUILD_COMPLEX (nan_value, -10.5)); check_isnan_maybe_exc ("real(catan(NaN - i10.5)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(catan(NaN - i10.5)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(catan) (BUILD_COMPLEX (0.75, nan_value)); check_isnan_maybe_exc ("real(catan(0.75 + i NaN)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(catan(0.75 + i NaN)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(catan) (BUILD_COMPLEX (-0.75, nan_value)); check_isnan_maybe_exc ("real(catan(-0.75 + i NaN)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(catan(-0.75 + i NaN)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(catan) (BUILD_COMPLEX (nan_value, nan_value)); check_isnan ("real(catan(NaN + i NaN)) = NaN", __real__ result); check_isnan ("imag(catan(NaN + i NaN)) = NaN", __imag__ result); } static void catanh_test (void) { __complex__ MATHTYPE result; result = FUNC(catanh) (BUILD_COMPLEX (0, 0)); check ("real(catanh(0 + i0)) = 0", __real__ result, 0); check ("imag(catanh(0 + i0)) = 0", __imag__ result, 0); result = FUNC(catanh) (BUILD_COMPLEX (minus_zero, 0)); check ("real(catanh(-0 + i0)) = -0", __real__ result, minus_zero); check ("imag(catanh(-0 + i0)) = 0", __imag__ result, 0); result = FUNC(catanh) (BUILD_COMPLEX (0, minus_zero)); check ("real(catanh(0 - i0)) = 0", __real__ result, 0); check ("imag(catanh(0 - i0)) = -0", __imag__ result, minus_zero); result = FUNC(catanh) (BUILD_COMPLEX (minus_zero, minus_zero)); check ("real(catanh(-0 - i0)) = -0", __real__ result, minus_zero); check ("imag(catanh(-0 - i0)) = -0", __imag__ result, minus_zero); result = FUNC(catanh) (BUILD_COMPLEX (plus_infty, plus_infty)); check ("real(catanh(+Inf + i Inf)) = 0", __real__ result, 0); check ("imag(catanh(+Inf + i Inf)) = pi/2", __imag__ result, M_PI_2); result = FUNC(catanh) (BUILD_COMPLEX (plus_infty, minus_infty)); check ("real(catanh(+Inf - i Inf)) = 0", __real__ result, 0); check ("imag(catanh(+Inf - i Inf)) = -pi/2", __imag__ result, -M_PI_2); result = FUNC(catanh) (BUILD_COMPLEX (minus_infty, plus_infty)); check ("real(catanh(-Inf + i Inf)) = -0", __real__ result, minus_zero); check ("imag(catanh(-Inf + i Inf)) = pi/2", __imag__ result, M_PI_2); result = FUNC(catanh) (BUILD_COMPLEX (minus_infty, minus_infty)); check ("real(catanh(-Inf - i Inf)) = -0", __real__ result, minus_zero); check ("imag(catanh(-Inf - i Inf)) = -pi/2", __imag__ result, -M_PI_2); result = FUNC(catanh) (BUILD_COMPLEX (-10.0, plus_infty)); check ("real(catanh(-10.0 + i Inf)) = -0", __real__ result, minus_zero); check ("imag(catanh(-10.0 + i Inf)) = pi/2", __imag__ result, M_PI_2); result = FUNC(catanh) (BUILD_COMPLEX (-10.0, minus_infty)); check ("real(catanh(-10.0 - i Inf)) = -0", __real__ result, minus_zero); check ("imag(catanh(-10.0 - i Inf)) = -pi/2", __imag__ result, -M_PI_2); result = FUNC(catanh) (BUILD_COMPLEX (minus_zero, plus_infty)); check ("real(catanh(-0 + i Inf)) = -0", __real__ result, minus_zero); check ("imag(catanh(-0 + i Inf)) = pi/2", __imag__ result, M_PI_2); result = FUNC(catanh) (BUILD_COMPLEX (minus_zero, minus_infty)); check ("real(catanh(-0 - i Inf)) = -0", __real__ result, minus_zero); check ("imag(catanh(-0 - i Inf)) = -pi/2", __imag__ result, -M_PI_2); result = FUNC(catanh) (BUILD_COMPLEX (0, plus_infty)); check ("real(catanh(0 + i Inf)) = 0", __real__ result, 0); check ("imag(catanh(0 + i Inf)) = pi/2", __imag__ result, M_PI_2); result = FUNC(catanh) (BUILD_COMPLEX (0, minus_infty)); check ("real(catanh(0 - i Inf)) = 0", __real__ result, 0); check ("imag(catanh(0 - i Inf)) = -pi/2", __imag__ result, -M_PI_2); result = FUNC(catanh) (BUILD_COMPLEX (0.1, plus_infty)); check ("real(catanh(0.1 + i Inf)) = 0", __real__ result, 0); check ("imag(catanh(0.1 + i Inf)) = pi/2", __imag__ result, M_PI_2); result = FUNC(catanh) (BUILD_COMPLEX (0.1, minus_infty)); check ("real(catanh(0.1 - i Inf)) = 0", __real__ result, 0); check ("imag(catanh(0.1 - i Inf)) = -pi/2", __imag__ result, -M_PI_2); result = FUNC(catanh) (BUILD_COMPLEX (minus_infty, 0)); check ("real(catanh(-Inf + i0)) = -0", __real__ result, minus_zero); check ("imag(catanh(-Inf + i0)) = pi/2", __imag__ result, M_PI_2); result = FUNC(catanh) (BUILD_COMPLEX (minus_infty, minus_zero)); check ("real(catanh(-Inf - i0)) = -0", __real__ result, minus_zero); check ("imag(catanh(-Inf - i0)) = -pi/2", __imag__ result, -M_PI_2); result = FUNC(catanh) (BUILD_COMPLEX (minus_infty, 100)); check ("real(catanh(-Inf + i100)) = -0", __real__ result, minus_zero); check ("imag(catanh(-Inf + i100)) = pi/2", __imag__ result, M_PI_2); result = FUNC(catanh) (BUILD_COMPLEX (minus_infty, -100)); check ("real(catanh(-Inf - i100)) = -0", __real__ result, minus_zero); check ("imag(catanh(-Inf - i100)) = -pi/2", __imag__ result, -M_PI_2); result = FUNC(catanh) (BUILD_COMPLEX (plus_infty, 0)); check ("real(catanh(+Inf + i0)) = 0", __real__ result, 0); check ("imag(catanh(+Inf + i0)) = pi/2", __imag__ result, M_PI_2); result = FUNC(catanh) (BUILD_COMPLEX (plus_infty, minus_zero)); check ("real(catanh(+Inf - i0)) = 0", __real__ result, 0); check ("imag(catanh(+Inf - i0)) = -pi/2", __imag__ result, -M_PI_2); result = FUNC(catanh) (BUILD_COMPLEX (plus_infty, 0.5)); check ("real(catanh(+Inf + i0.5)) = 0", __real__ result, 0); check ("imag(catanh(+Inf + i0.5)) = pi/2", __imag__ result, M_PI_2); result = FUNC(catanh) (BUILD_COMPLEX (plus_infty, -0.5)); check ("real(catanh(+Inf - i0.5)) = 0", __real__ result, 0); check ("imag(catanh(+Inf - i0.5)) = -pi/2", __imag__ result, -M_PI_2); result = FUNC(catanh) (BUILD_COMPLEX (0, nan_value)); check ("real(catanh(0 + i NaN)) = 0", __real__ result, 0); check_isnan ("imag(catanh(0 + i NaN)) = NaN", __imag__ result); result = FUNC(catanh) (BUILD_COMPLEX (minus_zero, nan_value)); check ("real(catanh(-0 + i NaN)) = -0", __real__ result, minus_zero); check_isnan ("imag(catanh(-0 + i NaN)) = NaN", __imag__ result); result = FUNC(catanh) (BUILD_COMPLEX (plus_infty, nan_value)); check ("real(catanh(+Inf + i NaN)) = 0", __real__ result, 0); check_isnan ("imag(catanh(+Inf + i NaN)) = NaN", __imag__ result); result = FUNC(catanh) (BUILD_COMPLEX (minus_infty, nan_value)); check ("real(catanh(-Inf + i NaN)) = -0", __real__ result, minus_zero); check_isnan ("imag(catanh(-Inf + i NaN)) = NaN", __imag__ result); result = FUNC(catanh) (BUILD_COMPLEX (nan_value, 0)); check_isnan ("real(catanh(NaN + i0)) = NaN", __real__ result); check_isnan ("imag(catanh(NaN + i0)) = NaN", __imag__ result); result = FUNC(catanh) (BUILD_COMPLEX (nan_value, minus_zero)); check_isnan ("real(catanh(NaN - i0)) = NaN", __real__ result); check_isnan ("imag(catanh(NaN - i0)) = NaN", __imag__ result); result = FUNC(catanh) (BUILD_COMPLEX (nan_value, plus_infty)); check ("real(catanh(NaN + i Inf)) = +-0", FUNC(fabs) (__real__ result), 0); check ("imag(catanh(NaN + i Inf)) = pi/2", __imag__ result, M_PI_2); result = FUNC(catanh) (BUILD_COMPLEX (nan_value, minus_infty)); check ("real(catanh(NaN - i Inf)) = +-0", FUNC(fabs) (__real__ result), 0); check ("imag(catanh(NaN - i Inf)) = -pi/2", __imag__ result, -M_PI_2); result = FUNC(catanh) (BUILD_COMPLEX (10.5, nan_value)); check_isnan_maybe_exc ("real(catanh(10.5 + i NaN)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(catanh(10.5 + i NaN)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(catanh) (BUILD_COMPLEX (-10.5, nan_value)); check_isnan_maybe_exc ("real(catanh(-10.5 + i NaN)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(catanh(-10.5 + i NaN)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(catanh) (BUILD_COMPLEX (nan_value, 0.75)); check_isnan_maybe_exc ("real(catanh(NaN + i0.75)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(catanh(NaN + i0.75)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(catanh) (BUILD_COMPLEX (nan_value, -0.75)); check_isnan_maybe_exc ("real(catanh(NaN - i0.75)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(catanh(NaN - i0.75)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(catanh) (BUILD_COMPLEX (nan_value, nan_value)); check_isnan ("real(catanh(NaN + i NaN)) = NaN", __real__ result); check_isnan ("imag(catanh(NaN + i NaN)) = NaN", __imag__ result); } static void ctanh_test (void) { __complex__ MATHTYPE result; result = FUNC(ctanh) (BUILD_COMPLEX (0, 0)); check ("real(ctanh(0 + i0)) = 0", __real__ result, 0); check ("imag(ctanh(0 + i0)) = 0", __imag__ result, 0); result = FUNC(ctanh) (BUILD_COMPLEX (0, minus_zero)); check ("real(ctanh(0 - i0)) = 0", __real__ result, 0); check ("imag(ctanh(0 - i0)) = -0", __imag__ result, minus_zero); result = FUNC(ctanh) (BUILD_COMPLEX (minus_zero, 0)); check ("real(ctanh(-0 + i0)) = -0", __real__ result, minus_zero); check ("imag(ctanh(-0 + i0)) = 0", __imag__ result, 0); result = FUNC(ctanh) (BUILD_COMPLEX (minus_zero, minus_zero)); check ("real(ctanh(-0 - i0)) = -0", __real__ result, minus_zero); check ("imag(ctanh(-0 - i0)) = -0", __imag__ result, minus_zero); result = FUNC(ctanh) (BUILD_COMPLEX (plus_infty, 0)); check ("real(ctanh(+Inf + i0)) = 1", __real__ result, 1); check ("imag(ctanh(+Inf + i0)) = 0", __imag__ result, 0); result = FUNC(ctanh) (BUILD_COMPLEX (plus_infty, 1)); check ("real(ctanh(+Inf + i1)) = 1", __real__ result, 1); check ("imag(ctanh(+Inf + i1)) = 0", __imag__ result, 0); result = FUNC(ctanh) (BUILD_COMPLEX (plus_infty, minus_zero)); check ("real(ctanh(+Inf - i0)) = 1", __real__ result, 1); check ("imag(ctanh(+Inf - i0)) = -0", __imag__ result, minus_zero); result = FUNC(ctanh) (BUILD_COMPLEX (plus_infty, -1)); check ("real(ctanh(+Inf - i1)) = 1", __real__ result, 1); check ("imag(ctanh(+Inf - i1)) = -0", __imag__ result, minus_zero); result = FUNC(ctanh) (BUILD_COMPLEX (minus_infty, 0)); check ("real(ctanh(-Inf + i0)) = -1", __real__ result, -1); check ("imag(ctanh(-Inf + i0)) = 0", __imag__ result, 0); result = FUNC(ctanh) (BUILD_COMPLEX (minus_infty, 1)); check ("real(ctanh(-Inf + i1)) = -1", __real__ result, -1); check ("imag(ctanh(-Inf + i1)) = 0", __imag__ result, 0); result = FUNC(ctanh) (BUILD_COMPLEX (minus_infty, minus_zero)); check ("real(ctanh(-Inf - i0)) = -1", __real__ result, -1); check ("imag(ctanh(-Inf - i0)) = -0", __imag__ result, minus_zero); result = FUNC(ctanh) (BUILD_COMPLEX (minus_infty, -1)); check ("real(ctanh(-Inf - i1)) = -1", __real__ result, -1); check ("imag(ctanh(-Inf - i1)) = -0", __imag__ result, minus_zero); result = FUNC(ctanh) (BUILD_COMPLEX (0, plus_infty)); check_isnan_exc ("real(ctanh(0 + i Inf)) = NaN plus invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(ctanh(0 + i Inf)) = NaN plus invalid exception", __imag__ result); result = FUNC(ctanh) (BUILD_COMPLEX (2, plus_infty)); check_isnan_exc ("real(ctanh(2 + i Inf)) = NaN plus invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(ctanh(2 + i Inf)) = NaN plus invalid exception", __imag__ result); result = FUNC(ctanh) (BUILD_COMPLEX (0, minus_infty)); check_isnan_exc ("real(ctanh(0 - i Inf)) = NaN plus invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(ctanh(0 - i Inf)) = NaN plus invalid exception", __imag__ result); result = FUNC(ctanh) (BUILD_COMPLEX (2, minus_infty)); check_isnan_exc ("real(ctanh(2 - i Inf)) = NaN plus invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(ctanh(2 - i Inf)) = NaN plus invalid exception", __imag__ result); result = FUNC(ctanh) (BUILD_COMPLEX (minus_zero, plus_infty)); check_isnan_exc ("real(ctanh(-0 + i Inf)) = NaN plus invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(ctanh(-0 + i Inf)) = NaN plus invalid exception", __imag__ result); result = FUNC(ctanh) (BUILD_COMPLEX (-2, plus_infty)); check_isnan_exc ("real(ctanh(-2 + i Inf)) = NaN plus invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(ctanh(-2 + i Inf)) = NaN plus invalid exception", __imag__ result); result = FUNC(ctanh) (BUILD_COMPLEX (minus_zero, minus_infty)); check_isnan_exc ("real(ctanh(-0 - i Inf)) = NaN plus invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(ctanh(-0 - i Inf)) = NaN plus invalid exception", __imag__ result); result = FUNC(ctanh) (BUILD_COMPLEX (-2, minus_infty)); check_isnan_exc ("real(ctanh(-2 - i Inf)) = NaN plus invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(ctanh(-2 - i Inf)) = NaN plus invalid exception", __imag__ result); result = FUNC(ctanh) (BUILD_COMPLEX (plus_infty, nan_value)); check ("real(ctanh(+Inf + i NaN)) = 1", __real__ result, 1); check ("imag(ctanh(+Inf + i NaN)) = +-0", FUNC(fabs) (__imag__ result), 0); result = FUNC(ctanh) (BUILD_COMPLEX (minus_infty, nan_value)); check ("real(ctanh(-Inf + i NaN)) = -1", __real__ result, -1); check ("imag(ctanh(-Inf + i NaN)) = +-0", FUNC(fabs) (__imag__ result), 0); result = FUNC(ctanh) (BUILD_COMPLEX (nan_value, 0)); check_isnan ("real(ctanh(NaN + i0)) = NaN", __real__ result); check ("imag(ctanh(NaN + i0)) = 0", __imag__ result, 0); result = FUNC(ctanh) (BUILD_COMPLEX (nan_value, minus_zero)); check_isnan ("real(ctanh(NaN - i0)) = NaN", __real__ result); check ("imag(ctanh(NaN - i0)) = -0", __imag__ result, minus_zero); result = FUNC(ctanh) (BUILD_COMPLEX (nan_value, 0.5)); check_isnan_maybe_exc ("real(ctanh(NaN + i0.5)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(ctanh(NaN + i0.5)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(ctanh) (BUILD_COMPLEX (nan_value, -4.5)); check_isnan_maybe_exc ("real(ctanh(NaN - i4.5)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(ctanh(NaN - i4.5)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(ctanh) (BUILD_COMPLEX (0, nan_value)); check_isnan_maybe_exc ("real(ctanh(0 + i NaN)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(ctanh(0 + i NaN)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(ctanh) (BUILD_COMPLEX (5, nan_value)); check_isnan_maybe_exc ("real(ctanh(5 + i NaN)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(ctanh(5 + i NaN)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(ctanh) (BUILD_COMPLEX (minus_zero, nan_value)); check_isnan_maybe_exc ("real(ctanh(-0 + i NaN)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(ctanh(-0 + i NaN)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(ctanh) (BUILD_COMPLEX (-0.25, nan_value)); check_isnan_maybe_exc ("real(ctanh(-0.25 + i NaN)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(ctanh(-0.25 + i NaN)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(ctanh) (BUILD_COMPLEX (nan_value, nan_value)); check_isnan ("real(ctanh(NaN + i NaN)) = NaN", __real__ result); check_isnan ("imag(ctanh(NaN + i NaN)) = NaN", __imag__ result); } static void clog_test (void) { __complex__ MATHTYPE result; result = FUNC(clog) (BUILD_COMPLEX (minus_zero, 0)); check_isinfn_exc ("real(clog(-0 + i0)) = -Inf plus divide-by-zero exception", __real__ result, DIVIDE_BY_ZERO_EXCEPTION); check ("imag(clog(-0 + i0)) = pi plus divide-by-zero exception", __imag__ result, M_PI); result = FUNC(clog) (BUILD_COMPLEX (minus_zero, minus_zero)); check_isinfn_exc ("real(clog(-0 - i0)) = -Inf plus divide-by-zero exception", __real__ result, DIVIDE_BY_ZERO_EXCEPTION); check ("imag(clog(-0 - i0)) = -pi plus divide-by-zero exception", __imag__ result, -M_PI); result = FUNC(clog) (BUILD_COMPLEX (0, 0)); check_isinfn_exc ("real(clog(0 + i0)) = -Inf plus divide-by-zero exception", __real__ result, DIVIDE_BY_ZERO_EXCEPTION); check ("imag(clog(0 + i0)) = 0 plus divide-by-zero exception", __imag__ result, 0); result = FUNC(clog) (BUILD_COMPLEX (0, minus_zero)); check_isinfn_exc ("real(clog(0 - i0)) = -Inf plus divide-by-zero exception", __real__ result, DIVIDE_BY_ZERO_EXCEPTION); check ("imag(clog(0 - i0)) = -0 plus divide-by-zero exception", __imag__ result, minus_zero); result = FUNC(clog) (BUILD_COMPLEX (minus_infty, plus_infty)); check_isinfp ("real(clog(-Inf + i Inf)) = +Inf", __real__ result); check ("imag(clog(-Inf + i Inf)) = 3*pi/4", __imag__ result, M_PI - M_PI_4); result = FUNC(clog) (BUILD_COMPLEX (minus_infty, minus_infty)); check_isinfp ("real(clog(-Inf - i Inf)) = +Inf", __real__ result); check ("imag(clog(-Inf - i Inf)) = -3*pi/4", __imag__ result, M_PI_4 - M_PI); result = FUNC(clog) (BUILD_COMPLEX (plus_infty, plus_infty)); check_isinfp ("real(clog(+Inf + i Inf)) = +Inf", __real__ result); check ("imag(clog(+Inf + i Inf)) = pi/4", __imag__ result, M_PI_4); result = FUNC(clog) (BUILD_COMPLEX (plus_infty, minus_infty)); check_isinfp ("real(clog(+Inf - i Inf)) = +Inf", __real__ result); check ("imag(clog(+Inf - i Inf)) = -pi/4", __imag__ result, -M_PI_4); result = FUNC(clog) (BUILD_COMPLEX (0, plus_infty)); check_isinfp ("real(clog(0 + i Inf)) = +Inf", __real__ result); check ("imag(clog(0 + i Inf)) = pi/2", __imag__ result, M_PI_2); result = FUNC(clog) (BUILD_COMPLEX (3, plus_infty)); check_isinfp ("real(clog(3 + i Inf)) = +Inf", __real__ result); check ("imag(clog(3 + i Inf)) = pi/2", __imag__ result, M_PI_2); result = FUNC(clog) (BUILD_COMPLEX (minus_zero, plus_infty)); check_isinfp ("real(clog(-0 + i Inf)) = +Inf", __real__ result); check ("imag(clog(-0 + i Inf)) = pi/2", __imag__ result, M_PI_2); result = FUNC(clog) (BUILD_COMPLEX (-3, plus_infty)); check_isinfp ("real(clog(-3 + i Inf)) = +Inf", __real__ result); check ("imag(clog(-3 + i Inf)) = pi/2", __imag__ result, M_PI_2); result = FUNC(clog) (BUILD_COMPLEX (0, minus_infty)); check_isinfp ("real(clog(0 - i Inf)) = +Inf", __real__ result); check ("imag(clog(0 - i Inf)) = -pi/2", __imag__ result, -M_PI_2); result = FUNC(clog) (BUILD_COMPLEX (3, minus_infty)); check_isinfp ("real(clog(3 - i Inf)) = +Inf", __real__ result); check ("imag(clog(3 - i Inf)) = -pi/2", __imag__ result, -M_PI_2); result = FUNC(clog) (BUILD_COMPLEX (minus_zero, minus_infty)); check_isinfp ("real(clog(-0 - i Inf)) = +Inf", __real__ result); check ("imag(clog(-0 - i Inf)) = -pi/2", __imag__ result, -M_PI_2); result = FUNC(clog) (BUILD_COMPLEX (-3, minus_infty)); check_isinfp ("real(clog(-3 - i Inf)) = +Inf", __real__ result); check ("imag(clog(-3 - i Inf)) = -pi/2", __imag__ result, -M_PI_2); result = FUNC(clog) (BUILD_COMPLEX (minus_infty, 0)); check_isinfp ("real(clog(-Inf + i0)) = +Inf", __real__ result); check ("imag(clog(-Inf + i0)) = pi", __imag__ result, M_PI); result = FUNC(clog) (BUILD_COMPLEX (minus_infty, 1)); check_isinfp ("real(clog(-Inf + i1)) = +Inf", __real__ result); check ("imag(clog(-Inf + i1)) = pi", __imag__ result, M_PI); result = FUNC(clog) (BUILD_COMPLEX (minus_infty, minus_zero)); check_isinfp ("real(clog(-Inf - i0)) = +Inf", __real__ result); check ("imag(clog(-Inf - i0)) = -pi", __imag__ result, -M_PI); result = FUNC(clog) (BUILD_COMPLEX (minus_infty, -1)); check_isinfp ("real(clog(-Inf - i1)) = +Inf", __real__ result); check ("imag(clog(-Inf - i1)) = -pi", __imag__ result, -M_PI); result = FUNC(clog) (BUILD_COMPLEX (plus_infty, 0)); check_isinfp ("real(clog(+Inf + i0)) = +Inf", __real__ result); check ("imag(clog(+Inf + i0)) = 0", __imag__ result, 0); result = FUNC(clog) (BUILD_COMPLEX (plus_infty, 1)); check_isinfp ("real(clog(+Inf + i1)) = +Inf", __real__ result); check ("imag(clog(+Inf + i1)) = 0", __imag__ result, 0); result = FUNC(clog) (BUILD_COMPLEX (plus_infty, minus_zero)); check_isinfp ("real(clog(+Inf - i0)) = +Inf", __real__ result); check ("imag(clog(+Inf - i0)) = -0", __imag__ result, minus_zero); result = FUNC(clog) (BUILD_COMPLEX (plus_infty, -1)); check_isinfp ("real(clog(+Inf - i1)) = +Inf", __real__ result); check ("imag(clog(+Inf - i1)) = -0", __imag__ result, minus_zero); result = FUNC(clog) (BUILD_COMPLEX (plus_infty, nan_value)); check_isinfp ("real(clog(+Inf + i NaN)) = +Inf", __real__ result); check_isnan ("imag(clog(+Inf + i NaN)) = NaN", __imag__ result); result = FUNC(clog) (BUILD_COMPLEX (minus_infty, nan_value)); check_isinfp ("real(clog(-Inf + i NaN)) = +Inf", __real__ result); check_isnan ("imag(clog(-Inf + i NaN)) = NaN", __imag__ result); result = FUNC(clog) (BUILD_COMPLEX (nan_value, plus_infty)); check_isinfp ("real(clog(NaN + i Inf)) = +Inf", __real__ result); check_isnan ("imag(clog(NaN + i Inf)) = NaN", __imag__ result); result = FUNC(clog) (BUILD_COMPLEX (nan_value, minus_infty)); check_isinfp ("real(clog(NaN - i Inf)) = +Inf", __real__ result); check_isnan ("imag(clog(NaN - i Inf)) = NaN", __imag__ result); result = FUNC(clog) (BUILD_COMPLEX (0, nan_value)); check_isnan_maybe_exc ("real(clog(0 + i NaN)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(clog(0 + i NaN)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(clog) (BUILD_COMPLEX (3, nan_value)); check_isnan_maybe_exc ("real(clog(3 + i NaN)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(clog(3 + i NaN)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(clog) (BUILD_COMPLEX (minus_zero, nan_value)); check_isnan_maybe_exc ("real(clog(-0 + i NaN)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(clog(-0 + i NaN)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(clog) (BUILD_COMPLEX (-3, nan_value)); check_isnan_maybe_exc ("real(clog(-3 + i NaN)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(clog(-3 + i NaN)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(clog) (BUILD_COMPLEX (nan_value, 0)); check_isnan_maybe_exc ("real(clog(NaN + i0)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(clog(NaN + i0)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(clog) (BUILD_COMPLEX (nan_value, 5)); check_isnan_maybe_exc ("real(clog(NaN + i5)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(clog(NaN + i5)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(clog) (BUILD_COMPLEX (nan_value, minus_zero)); check_isnan_maybe_exc ("real(clog(NaN - i0)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(clog(NaN - i0)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(clog) (BUILD_COMPLEX (nan_value, -5)); check_isnan_maybe_exc ("real(clog(NaN - i5)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(clog(NaN - i5)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(clog) (BUILD_COMPLEX (nan_value, nan_value)); check_isnan ("real(clog(NaN + i NaN)) = NaN", __real__ result); check_isnan ("imag(clog(NaN + i NaN)) = NaN", __imag__ result); } static void clog10_test (void) { __complex__ MATHTYPE result; result = FUNC(clog10) (BUILD_COMPLEX (minus_zero, 0)); check_isinfn_exc ("real(clog10(-0 + i0)) = -Inf plus divide-by-zero exception", __real__ result, DIVIDE_BY_ZERO_EXCEPTION); check ("imag(clog10(-0 + i0)) = pi plus divide-by-zero exception", __imag__ result, M_PI); result = FUNC(clog10) (BUILD_COMPLEX (minus_zero, minus_zero)); check_isinfn_exc ("real(clog10(-0 - i0)) = -Inf plus divide-by-zero exception", __real__ result, DIVIDE_BY_ZERO_EXCEPTION); check ("imag(clog10(-0 - i0)) = -pi plus divide-by-zero exception", __imag__ result, -M_PI); result = FUNC(clog10) (BUILD_COMPLEX (0, 0)); check_isinfn_exc ("real(clog10(0 + i0)) = -Inf plus divide-by-zero exception", __real__ result, DIVIDE_BY_ZERO_EXCEPTION); check ("imag(clog10(0 + i0)) = 0 plus divide-by-zero exception", __imag__ result, 0); result = FUNC(clog10) (BUILD_COMPLEX (0, minus_zero)); check_isinfn_exc ("real(clog10(0 - i0)) = -Inf plus divide-by-zero exception", __real__ result, DIVIDE_BY_ZERO_EXCEPTION); check ("imag(clog10(0 - i0)) = -0 plus divide-by-zero exception", __imag__ result, minus_zero); result = FUNC(clog10) (BUILD_COMPLEX (minus_infty, plus_infty)); check_isinfp ("real(clog10(-Inf + i Inf)) = +Inf", __real__ result); check ("imag(clog10(-Inf + i Inf)) = 3*pi/4", __imag__ result, M_PI - M_PI_4); result = FUNC(clog10) (BUILD_COMPLEX (minus_infty, minus_infty)); check_isinfp ("real(clog10(-Inf - i Inf)) = +Inf", __real__ result); check ("imag(clog10(-Inf - i Inf)) = -3*pi/4", __imag__ result, M_PI_4 - M_PI); result = FUNC(clog10) (BUILD_COMPLEX (plus_infty, plus_infty)); check_isinfp ("real(clog10(+Inf + i Inf)) = +Inf", __real__ result); check ("imag(clog10(+Inf + i Inf)) = pi/4", __imag__ result, M_PI_4); result = FUNC(clog10) (BUILD_COMPLEX (plus_infty, minus_infty)); check_isinfp ("real(clog10(+Inf - i Inf)) = +Inf", __real__ result); check ("imag(clog10(+Inf - i Inf)) = -pi/4", __imag__ result, -M_PI_4); result = FUNC(clog10) (BUILD_COMPLEX (0, plus_infty)); check_isinfp ("real(clog10(0 + i Inf)) = +Inf", __real__ result); check ("imag(clog10(0 + i Inf)) = pi/2", __imag__ result, M_PI_2); result = FUNC(clog10) (BUILD_COMPLEX (3, plus_infty)); check_isinfp ("real(clog10(3 + i Inf)) = +Inf", __real__ result); check ("imag(clog10(3 + i Inf)) = pi/2", __imag__ result, M_PI_2); result = FUNC(clog10) (BUILD_COMPLEX (minus_zero, plus_infty)); check_isinfp ("real(clog10(-0 + i Inf)) = +Inf", __real__ result); check ("imag(clog10(-0 + i Inf)) = pi/2", __imag__ result, M_PI_2); result = FUNC(clog10) (BUILD_COMPLEX (-3, plus_infty)); check_isinfp ("real(clog10(-3 + i Inf)) = +Inf", __real__ result); check ("imag(clog10(-3 + i Inf)) = pi/2", __imag__ result, M_PI_2); result = FUNC(clog10) (BUILD_COMPLEX (0, minus_infty)); check_isinfp ("real(clog10(0 - i Inf)) = +Inf", __real__ result); check ("imag(clog10(0 - i Inf)) = -pi/2", __imag__ result, -M_PI_2); result = FUNC(clog10) (BUILD_COMPLEX (3, minus_infty)); check_isinfp ("real(clog10(3 - i Inf)) = +Inf", __real__ result); check ("imag(clog10(3 - i Inf)) = -pi/2", __imag__ result, -M_PI_2); result = FUNC(clog10) (BUILD_COMPLEX (minus_zero, minus_infty)); check_isinfp ("real(clog10(-0 - i Inf)) = +Inf", __real__ result); check ("imag(clog10(-0 - i Inf)) = -pi/2", __imag__ result, -M_PI_2); result = FUNC(clog10) (BUILD_COMPLEX (-3, minus_infty)); check_isinfp ("real(clog10(-3 - i Inf)) = +Inf", __real__ result); check ("imag(clog10(-3 - i Inf)) = -pi/2", __imag__ result, -M_PI_2); result = FUNC(clog10) (BUILD_COMPLEX (minus_infty, 0)); check_isinfp ("real(clog10(-Inf + i0)) = +Inf", __real__ result); check ("imag(clog10(-Inf + i0)) = pi", __imag__ result, M_PI); result = FUNC(clog10) (BUILD_COMPLEX (minus_infty, 1)); check_isinfp ("real(clog10(-Inf + i1)) = +Inf", __real__ result); check ("imag(clog10(-Inf + i1)) = pi", __imag__ result, M_PI); result = FUNC(clog10) (BUILD_COMPLEX (minus_infty, minus_zero)); check_isinfp ("real(clog10(-Inf - i0)) = +Inf", __real__ result); check ("imag(clog10(-Inf - i0)) = -pi", __imag__ result, -M_PI); result = FUNC(clog10) (BUILD_COMPLEX (minus_infty, -1)); check_isinfp ("real(clog10(-Inf - i1)) = +Inf", __real__ result); check ("imag(clog10(-Inf - i1)) = -pi", __imag__ result, -M_PI); result = FUNC(clog10) (BUILD_COMPLEX (plus_infty, 0)); check_isinfp ("real(clog10(+Inf + i0)) = +Inf", __real__ result); check ("imag(clog10(+Inf + i0)) = 0", __imag__ result, 0); result = FUNC(clog10) (BUILD_COMPLEX (plus_infty, 1)); check_isinfp ("real(clog10(+Inf + i1)) = +Inf", __real__ result); check ("imag(clog10(+Inf + i1)) = 0", __imag__ result, 0); result = FUNC(clog10) (BUILD_COMPLEX (plus_infty, minus_zero)); check_isinfp ("real(clog10(+Inf - i0)) = +Inf", __real__ result); check ("imag(clog10(+Inf - i0)) = -0", __imag__ result, minus_zero); result = FUNC(clog10) (BUILD_COMPLEX (plus_infty, -1)); check_isinfp ("real(clog10(+Inf - i1)) = +Inf", __real__ result); check ("imag(clog10(+Inf - i1)) = -0", __imag__ result, minus_zero); result = FUNC(clog10) (BUILD_COMPLEX (plus_infty, nan_value)); check_isinfp ("real(clog10(+Inf + i NaN)) = +Inf", __real__ result); check_isnan ("imag(clog10(+Inf + i NaN)) = NaN", __imag__ result); result = FUNC(clog10) (BUILD_COMPLEX (minus_infty, nan_value)); check_isinfp ("real(clog10(-Inf + i NaN)) = +Inf", __real__ result); check_isnan ("imag(clog10(-Inf + i NaN)) = NaN", __imag__ result); result = FUNC(clog10) (BUILD_COMPLEX (nan_value, plus_infty)); check_isinfp ("real(clog10(NaN + i Inf)) = +Inf", __real__ result); check_isnan ("imag(clog10(NaN + i Inf)) = NaN", __imag__ result); result = FUNC(clog10) (BUILD_COMPLEX (nan_value, minus_infty)); check_isinfp ("real(clog10(NaN - i Inf)) = +Inf", __real__ result); check_isnan ("imag(clog10(NaN - i Inf)) = NaN", __imag__ result); result = FUNC(clog10) (BUILD_COMPLEX (0, nan_value)); check_isnan_maybe_exc ("real(clog10(0 + i NaN)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(clog10(0 + i NaN)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(clog10) (BUILD_COMPLEX (3, nan_value)); check_isnan_maybe_exc ("real(clog10(3 + i NaN)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(clog10(3 + i NaN)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(clog10) (BUILD_COMPLEX (minus_zero, nan_value)); check_isnan_maybe_exc ("real(clog10(-0 + i NaN)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(clog10(-0 + i NaN)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(clog10) (BUILD_COMPLEX (-3, nan_value)); check_isnan_maybe_exc ("real(clog10(-3 + i NaN)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(clog10(-3 + i NaN)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(clog10) (BUILD_COMPLEX (nan_value, 0)); check_isnan_maybe_exc ("real(clog10(NaN + i0)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(clog10(NaN + i0)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(clog10) (BUILD_COMPLEX (nan_value, 5)); check_isnan_maybe_exc ("real(clog10(NaN + i5)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(clog10(NaN + i5)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(clog10) (BUILD_COMPLEX (nan_value, minus_zero)); check_isnan_maybe_exc ("real(clog10(NaN - i0)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(clog10(NaN - i0)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(clog10) (BUILD_COMPLEX (nan_value, -5)); check_isnan_maybe_exc ("real(clog10(NaN - i5)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(clog10(NaN - i5)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(clog10) (BUILD_COMPLEX (nan_value, nan_value)); check_isnan ("real(clog10(NaN + i NaN)) = NaN", __real__ result); check_isnan ("imag(clog10(NaN + i NaN)) = NaN", __imag__ result); } static void csqrt_test (void) { __complex__ MATHTYPE result; result = FUNC(csqrt) (BUILD_COMPLEX (0, 0)); check ("real(csqrt(0 + i0)) = 0", __real__ result, 0); check ("imag(csqrt(0 + i0)) = 0", __imag__ result, 0); result = FUNC(csqrt) (BUILD_COMPLEX (0, minus_zero)); check ("real(csqrt(0 - i0)) = 0", __real__ result, 0); check ("imag(csqrt(0 - i0)) = -0", __imag__ result, minus_zero); result = FUNC(csqrt) (BUILD_COMPLEX (minus_zero, 0)); check ("real(csqrt(-0 + i0)) = 0", __real__ result, 0); check ("imag(csqrt(-0 + i0)) = 0", __imag__ result, 0); result = FUNC(csqrt) (BUILD_COMPLEX (minus_zero, minus_zero)); check ("real(csqrt(-0 - i0)) = 0", __real__ result, 0); check ("imag(csqrt(-0 - i0)) = -0", __imag__ result, minus_zero); result = FUNC(csqrt) (BUILD_COMPLEX (minus_infty, 0)); check ("real(csqrt(-Inf + i0)) = 0", __real__ result, 0); check_isinfp ("imag(csqrt(-Inf + i0)) = +Inf", __imag__ result); result = FUNC(csqrt) (BUILD_COMPLEX (minus_infty, 6)); check ("real(csqrt(-Inf + i6)) = 0", __real__ result, 0); check_isinfp ("imag(csqrt(-Inf + i6)) = +Inf", __imag__ result); result = FUNC(csqrt) (BUILD_COMPLEX (minus_infty, minus_zero)); check ("real(csqrt(-Inf - i0)) = 0", __real__ result, 0); check_isinfn ("imag(csqrt(-Inf - i0)) = -Inf", __imag__ result); result = FUNC(csqrt) (BUILD_COMPLEX (minus_infty, -6)); check ("real(csqrt(-Inf - i6)) = 0", __real__ result, 0); check_isinfn ("imag(csqrt(-Inf - i6)) = -Inf", __imag__ result); result = FUNC(csqrt) (BUILD_COMPLEX (plus_infty, 0)); check_isinfp ("real(csqrt(+Inf + i0)) = +Inf", __real__ result); check ("imag(csqrt(+Inf + i0)) = 0", __imag__ result, 0); result = FUNC(csqrt) (BUILD_COMPLEX (plus_infty, 6)); check_isinfp ("real(csqrt(+Inf + i6)) = +Inf", __real__ result); check ("imag(csqrt(+Inf + i6)) = 0", __imag__ result, 0); result = FUNC(csqrt) (BUILD_COMPLEX (plus_infty, minus_zero)); check_isinfp ("real(csqrt(+Inf - i0)) = +Inf", __real__ result); check ("imag(csqrt(+Inf - i0)) = -0", __imag__ result, minus_zero); result = FUNC(csqrt) (BUILD_COMPLEX (plus_infty, -6)); check_isinfp ("real(csqrt(+Inf - i6)) = +Inf", __real__ result); check ("imag(csqrt(+Inf - i6)) = -0", __imag__ result, minus_zero); result = FUNC(csqrt) (BUILD_COMPLEX (0, plus_infty)); check_isinfp ("real(csqrt(0 + i Inf)) = +Inf", __real__ result); check_isinfp ("imag(csqrt(0 + i Inf)) = +Inf", __imag__ result); result = FUNC(csqrt) (BUILD_COMPLEX (4, plus_infty)); check_isinfp ("real(csqrt(4 + i Inf)) = +Inf", __real__ result); check_isinfp ("imag(csqrt(4 + i Inf)) = +Inf", __imag__ result); result = FUNC(csqrt) (BUILD_COMPLEX (plus_infty, plus_infty)); check_isinfp ("real(csqrt(+Inf + i Inf)) = +Inf", __real__ result); check_isinfp ("imag(csqrt(+Inf + i Inf)) = +Inf", __imag__ result); result = FUNC(csqrt) (BUILD_COMPLEX (minus_zero, plus_infty)); check_isinfp ("real(csqrt(-0 + i Inf)) = +Inf", __real__ result); check_isinfp ("imag(csqrt(-0 + i Inf)) = +Inf", __imag__ result); result = FUNC(csqrt) (BUILD_COMPLEX (-4, plus_infty)); check_isinfp ("real(csqrt(-4 + i Inf)) = +Inf", __real__ result); check_isinfp ("imag(csqrt(-4 + i Inf)) = +Inf", __imag__ result); result = FUNC(csqrt) (BUILD_COMPLEX (minus_infty, plus_infty)); check_isinfp ("real(csqrt(-Inf + i Inf)) = +Inf", __real__ result); check_isinfp ("imag(csqrt(-Inf + i Inf)) = +Inf", __imag__ result); result = FUNC(csqrt) (BUILD_COMPLEX (0, minus_infty)); check_isinfp ("real(csqrt(0 - i Inf)) = +Inf", __real__ result); check_isinfn ("imag(csqrt(0 - i Inf)) = -Inf", __imag__ result); result = FUNC(csqrt) (BUILD_COMPLEX (4, minus_infty)); check_isinfp ("real(csqrt(4 - i Inf)) = +Inf", __real__ result); check_isinfn ("imag(csqrt(4 - i Inf)) = -Inf", __imag__ result); result = FUNC(csqrt) (BUILD_COMPLEX (plus_infty, minus_infty)); check_isinfp ("real(csqrt(+Inf - i Inf)) = +Inf", __real__ result); check_isinfn ("imag(csqrt(+Inf - i Inf)) = -Inf", __imag__ result); result = FUNC(csqrt) (BUILD_COMPLEX (minus_zero, minus_infty)); check_isinfp ("real(csqrt(-0 - i Inf)) = +Inf", __real__ result); check_isinfn ("imag(csqrt(-0 - i Inf)) = -Inf", __imag__ result); result = FUNC(csqrt) (BUILD_COMPLEX (-4, minus_infty)); check_isinfp ("real(csqrt(-4 - i Inf)) = +Inf", __real__ result); check_isinfn ("imag(csqrt(-4 - i Inf)) = -Inf", __imag__ result); result = FUNC(csqrt) (BUILD_COMPLEX (minus_infty, minus_infty)); check_isinfp ("real(csqrt(-Inf - i Inf)) = +Inf", __real__ result); check_isinfn ("imag(csqrt(-Inf - i Inf)) = -Inf", __imag__ result); result = FUNC(csqrt) (BUILD_COMPLEX (minus_infty, nan_value)); check_isnan ("real(csqrt(-Inf + i NaN)) = NaN", __real__ result); check_isinfp ("imag(csqrt(-Inf + i NaN)) = +-Inf", FUNC(fabs) (__imag__ result)); result = FUNC(csqrt) (BUILD_COMPLEX (plus_infty, nan_value)); check_isinfp ("real(csqrt(+Inf + i NaN)) = +Inf", __real__ result); check_isnan ("imag(csqrt(+Inf + i NaN)) = NaN", __imag__ result); result = FUNC(csqrt) (BUILD_COMPLEX (0, nan_value)); check_isnan_maybe_exc ("real(csqrt(0 + i NaN)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(csqrt(0 + i NaN)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(csqrt) (BUILD_COMPLEX (1, nan_value)); check_isnan_maybe_exc ("real(csqrt(1 + i NaN)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(csqrt(1 + i NaN)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(csqrt) (BUILD_COMPLEX (minus_zero, nan_value)); check_isnan_maybe_exc ("real(csqrt(-0 + i NaN)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(csqrt(-0 + i NaN)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(csqrt) (BUILD_COMPLEX (-1, nan_value)); check_isnan_maybe_exc ("real(csqrt(-1 + i NaN)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(csqrt(-1 + i NaN)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(csqrt) (BUILD_COMPLEX (nan_value, 0)); check_isnan_maybe_exc ("real(csqrt(NaN + i0)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(csqrt(NaN + i0)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(csqrt) (BUILD_COMPLEX (nan_value, 8)); check_isnan_maybe_exc ("real(csqrt(NaN + i8)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(csqrt(NaN + i8)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(csqrt) (BUILD_COMPLEX (nan_value, minus_zero)); check_isnan_maybe_exc ("real(csqrt(NaN - i0)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(csqrt(NaN - i0)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(csqrt) (BUILD_COMPLEX (nan_value, -8)); check_isnan_maybe_exc ("real(csqrt(NaN - i8)) = NaN plus maybe invalid exception", __real__ result, INVALID_EXCEPTION); check_isnan ("imag(csqrt(NaN - i8)) = NaN plus maybe invalid exception", __imag__ result); result = FUNC(csqrt) (BUILD_COMPLEX (nan_value, nan_value)); check_isnan ("real(csqrt(NaN + i NaN)) = NaN", __real__ result); check_isnan ("imag(csqrt(NaN + i NaN)) = NaN", __imag__ result); } static void cpow_test (void) { __complex__ MATHTYPE result; result = FUNC (cpow) (BUILD_COMPLEX (1, 0), BUILD_COMPLEX (0, 0)); check ("real(cpow (1 + i0), (0 + i0)) = 0", __real__ result, 1); check ("imag(cpow (1 + i0), (0 + i0)) = 0", __imag__ result, 0); result = FUNC (cpow) (BUILD_COMPLEX (2, 0), BUILD_COMPLEX (10, 0)); check_eps ("real(cpow (2 + i0), (10 + i0)) = 1024", __real__ result, 1024, CHOOSE (2e-16L, 0, 0)); check ("imag(cpow (2 + i0), (10 + i0)) = 0", __imag__ result, 0); } static void nearbyint_test (void) { check ("nearbyint(+0) = 0", FUNC(nearbyint) (0.0), 0.0); check ("nearbyint(-0) = -0", FUNC(nearbyint) (minus_zero), minus_zero); check_isinfp ("nearbyint(+Inf) = +Inf", FUNC(nearbyint) (plus_infty)); check_isinfn ("nearbyint(-Inf) = -Inf", FUNC(nearbyint) (minus_infty)); } static void rint_test (void) { check ("rint(0) = 0", FUNC(rint) (0.0), 0.0); check ("rint(-0) = -0", FUNC(rint) (minus_zero), minus_zero); check_isinfp ("rint(+Inf) = +Inf", FUNC(rint) (plus_infty)); check_isinfn ("rint(-Inf) = -Inf", FUNC(rint) (minus_infty)); } static void lrint_test (void) { /* XXX this test is incomplete. We need to have a way to specifiy the rounding method and test the critical cases. So far, only unproblematic numbers are tested. */ check_long ("lrint(0) = 0", lrint (0.0), 0); check_long ("lrint(-0) = 0", lrint (minus_zero), 0); check_long ("lrint(0.2) = 0", lrint (0.2), 0); check_long ("lrint(-0.2) = 0", lrint (-0.2), 0); check_long ("lrint(1.4) = 1", lrint (1.4), 1); check_long ("lrint(-1.4) = -1", lrint (-1.4), -1); check_long ("lrint(8388600.3) = 8388600", lrint (8388600.3), 8388600); check_long ("lrint(-8388600.3) = -8388600", lrint (-8388600.3), -8388600); } static void llrint_test (void) { /* XXX this test is incomplete. We need to have a way to specifiy the rounding method and test the critical cases. So far, only unproblematic numbers are tested. */ check_longlong ("llrint(0) = 0", llrint (0.0), 0); check_longlong ("llrint(-0) = 0", llrint (minus_zero), 0); check_longlong ("llrint(0.2) = 0", llrint (0.2), 0); check_longlong ("llrint(-0.2) = 0", llrint (-0.2), 0); check_longlong ("llrint(1.4) = 1", llrint (1.4), 1); check_longlong ("llrint(-1.4) = -1", llrint (-1.4), -1); check_longlong ("llrint(8388600.3) = 8388600", llrint (8388600.3), 8388600); check_longlong ("llrint(-8388600.3) = -8388600", llrint (-8388600.3), -8388600); } static void round_test (void) { check ("round(0) = 0", FUNC(round) (0), 0); check ("round(-0) = -0", FUNC(round) (minus_zero), minus_zero); check ("round(0.2) = 0", FUNC(round) (0.2), 0.0); check ("round(-0.2) = -0", FUNC(round) (-0.2), minus_zero); check ("round(0.5) = 1", FUNC(round) (0.5), 1.0); check ("round(-0.5) = -1", FUNC(round) (-0.5), -1.0); check ("round(0.8) = 1", FUNC(round) (0.8), 1.0); check ("round(-0.8) = -1", FUNC(round) (-0.8), -1.0); check ("round(1.5) = 2", FUNC(round) (1.5), 2.0); check ("round(-1.5) = -2", FUNC(round) (-1.5), -2.0); check ("round(2097152.5) = 2097153", FUNC(round) (2097152.5), 2097153); check ("round(-2097152.5) = -2097153", FUNC(round) (-2097152.5), -2097153); } static void lround_test (void) { check_long ("lround(0) = 0", FUNC(lround) (0), 0); check_long ("lround(-0) = 0", FUNC(lround) (minus_zero), 0); check_long ("lround(0.2) = 0", FUNC(lround) (0.2), 0.0); check_long ("lround(-0.2) = 0", FUNC(lround) (-0.2), 0); check_long ("lround(0.5) = 1", FUNC(lround) (0.5), 1); check_long ("lround(-0.5) = -1", FUNC(lround) (-0.5), -1); check_long ("lround(0.8) = 1", FUNC(lround) (0.8), 1); check_long ("lround(-0.8) = -1", FUNC(lround) (-0.8), -1); check_long ("lround(1.5) = 2", FUNC(lround) (1.5), 2); check_long ("lround(-1.5) = -2", FUNC(lround) (-1.5), -2); check_long ("lround(22514.5) = 22514", FUNC(lround) (1.5), 2); check_long ("lround(-22514.5) = -22514", FUNC(lround) (-1.5), -2); #ifndef TEST_FLOAT check_long ("lround(2097152.5) = 2097153", FUNC(lround) (2097152.5), 2097153); check_long ("lround(-2097152.5) = -2097153", FUNC(lround) (-2097152.5), -2097153); #endif } static void llround_test (void) { check_longlong ("llround(0) = 0", FUNC(llround) (0), 0); check_longlong ("llround(-0) = 0", FUNC(llround) (minus_zero), 0); check_longlong ("llround(0.2) = 0", FUNC(llround) (0.2), 0.0); check_longlong ("llround(-0.2) = 0", FUNC(llround) (-0.2), 0); check_longlong ("llround(0.5) = 1", FUNC(llround) (0.5), 1); check_longlong ("llround(-0.5) = -1", FUNC(llround) (-0.5), -1); check_longlong ("llround(0.8) = 1", FUNC(llround) (0.8), 1); check_longlong ("llround(-0.8) = -1", FUNC(llround) (-0.8), -1); check_longlong ("llround(1.5) = 2", FUNC(llround) (1.5), 2); check_longlong ("llround(-1.5) = -2", FUNC(llround) (-1.5), -2); check_longlong ("llround(22514.5) = 22514", FUNC(llround) (1.5), 2); check_longlong ("llround(-22514.5) = -22514", FUNC(llround) (-1.5), -2); #ifndef TEST_FLOAT check_longlong ("llround(2097152.5) = 2097153", FUNC(llround) (2097152.5), 2097153); check_longlong ("llround(-2097152.5) = -2097153", FUNC(llround) (-2097152.5), -2097153); check_longlong ("llround(34359738368.5) = 34359738369", FUNC(llround) (34359738368.5), 34359738369ll); check_longlong ("llround(-34359738368.5) = -34359738369", FUNC(llround) (-34359738368.5), -34359738369ll); #endif } static void inverse_func_pair_test (const char *test_name, mathfunc f1, mathfunc inverse, MATHTYPE x, MATHTYPE epsilon) { MATHTYPE a, b, difference; int result; a = f1 (x); (void) &a; b = inverse (a); (void) &b; output_new_test (test_name); result = check_equal (b, x, epsilon, &difference); output_result (test_name, result, b, x, difference, PRINT, PRINT); } static void inverse_functions (void) { inverse_func_pair_test ("asin(sin(x)) == x", FUNC(sin), FUNC(asin), 1.0, CHOOSE (2e-18L, 0, 3e-7L)); inverse_func_pair_test ("sin(asin(x)) == x", FUNC(asin), FUNC(sin), 1.0, 0.0); inverse_func_pair_test ("acos(cos(x)) == x", FUNC(cos), FUNC(acos), 1.0, CHOOSE (4e-18L, 1e-15L, 0)); inverse_func_pair_test ("cos(acos(x)) == x", FUNC(acos), FUNC(cos), 1.0, 0.0); inverse_func_pair_test ("atan(tan(x)) == x", FUNC(tan), FUNC(atan), 1.0, CHOOSE (2e-18L, 0, 0)); inverse_func_pair_test ("tan(atan(x)) == x", FUNC(atan), FUNC(tan), 1.0, CHOOSE (2e-18L, 1e-15L, 0)); inverse_func_pair_test ("asinh(sinh(x)) == x", FUNC(sinh), FUNC(asinh), 1.0, CHOOSE (1e-18L, 0, 1e-7)); inverse_func_pair_test ("sinh(asinh(x)) == x", FUNC(asinh), FUNC(sinh), 1.0, CHOOSE (2e-18L, 0, 0)); inverse_func_pair_test ("acosh(cosh(x)) == x", FUNC(cosh), FUNC(acosh), 1.0, CHOOSE (1e-18L, 1e-15L, 0)); inverse_func_pair_test ("cosh(acosh(x)) == x", FUNC(acosh), FUNC(cosh), 1.0, 0.0); inverse_func_pair_test ("atanh(tanh(x)) == x", FUNC(tanh), FUNC(atanh), 1.0, CHOOSE (1e-18L, 1e-15L, 0)); inverse_func_pair_test ("tanh(atanh(x)) == x", FUNC(atanh), FUNC(tanh), 1.0, 0.0); } /* Test sin and cos with the identity: sin(x)^2 + cos(x)^2 = 1. */ static void identities1_test (MATHTYPE x, MATHTYPE epsilon) { MATHTYPE res1, res2, res3, diff; int result; res1 = FUNC(sin) (x); (void) &res1; res2 = FUNC(cos) (x); (void) &res2; res3 = res1 * res1 + res2 * res2; (void) &res3; output_new_test ("sin^2 + cos^2 == 1"); result = check_equal (res3, 1.0, epsilon, &diff); output_result_ext ("sin^2 + cos^2 == 1", result, res3, 1.0, diff, x, PRINT, PRINT); } /* Test sin, cos, tan with the following relation: tan = sin/cos. */ static void identities2_test (MATHTYPE x, MATHTYPE epsilon) { #ifndef TEST_INLINE MATHTYPE res1, res2, res3, res4, diff; int result; res1 = FUNC(sin) (x); (void) &res1; res2 = FUNC(cos) (x); (void) &res2; res3 = FUNC(tan) (x); (void) &res3; res4 = res1 / res2; (void) &res4; output_new_test ("sin/cos == tan"); result = check_equal (res4, res3, epsilon, &diff); output_result_ext ("sin/cos == tan", result, res4, res3, diff, x, PRINT, PRINT); #endif } /* Test cosh and sinh with the identity cosh^2 - sinh^2 = 1. */ static void identities3_test (MATHTYPE x, MATHTYPE epsilon) { MATHTYPE res1, res2, res3, diff; int result; res1 = FUNC(sinh) (x); (void) &res1; res2 = FUNC(cosh) (x); (void) &res2; res3 = res2 * res2 - res1 * res1; (void) &res3; output_new_test ("cosh^2 - sinh^2 == 1"); result = check_equal (res3, 1.0, epsilon, &diff); output_result_ext ("cosh^2 - sinh^2 == 1", result, res3, 1.0, diff, x, PRINT, PRINT); } static void identities (void) { identities1_test (0.2L, CHOOSE (1e-18L, 0, 2e-7)); identities1_test (0.9L, CHOOSE (1e-18L, 0, 1e-7)); identities1_test (0, 0); identities1_test (-1, CHOOSE (1e-18L, 0, 1e-7)); identities2_test (0.2L, CHOOSE (1e-19L, 1e-16, 0)); identities2_test (0.9L, CHOOSE (0, 1e-15, 2e-7)); identities2_test (0, 0); identities2_test (-1, CHOOSE (1e-18L, 1e-15, 2e-7)); identities3_test (0.2L, CHOOSE (1e-18L, 0, 1e-7)); identities3_test (0.9L, CHOOSE (1e-18L, 1e-15, 1e-6)); identities3_test (0, CHOOSE (0, 0, 1e-6)); identities3_test (-1, CHOOSE (1e-18L, 7e-16, 1e-6)); } /* Let's test that basic arithmetic is working tests: Infinity and NaN */ static void basic_tests (void) { /* variables are declared volatile to forbid some compiler optimizations */ volatile MATHTYPE Inf_var, NaN_var, zero_var, one_var; MATHTYPE x1, x2; zero_var = 0.0; one_var = 1.0; NaN_var = nan_value; Inf_var = one_var / zero_var; (void) &zero_var; (void) &one_var; (void) &NaN_var; (void) &Inf_var; /* Clear all exceptions. The previous computations raised exceptions. */ feclearexcept (FE_ALL_EXCEPT); check_isinfp ("isinf (inf) == +1", Inf_var); check_isinfn ("isinf (-inf) == -1", -Inf_var); check_bool ("!isinf (1)", !(FUNC(isinf) (one_var))); check_bool ("!isinf (NaN)", !(FUNC(isinf) (NaN_var))); check_isnan ("isnan (NaN)", NaN_var); check_isnan ("isnan (-NaN)", -NaN_var); check_bool ("!isnan (1)", !(FUNC(isnan) (one_var))); check_bool ("!isnan (inf)", !(FUNC(isnan) (Inf_var))); check_bool ("inf == inf", Inf_var == Inf_var); check_bool ("-inf == -inf", -Inf_var == -Inf_var); check_bool ("inf != -inf", Inf_var != -Inf_var); check_bool ("NaN != NaN", NaN_var != NaN_var); /* the same tests but this time with NAN from NAN is a double const */ check_bool ("isnan (NAN)", isnan (NAN)); check_bool ("isnan (-NAN)", isnan (-NAN)); check_bool ("!isinf (NAN)", !(isinf (NAN))); check_bool ("!isinf (-NAN)", !(isinf (-NAN))); check_bool ("NAN != NAN", NAN != NAN); /* And again with the value returned by the `nan' function. */ check_bool ("isnan (NAN)", FUNC(isnan) (FUNC(nan) (""))); check_bool ("isnan (-NAN)", FUNC(isnan) (-FUNC(nan) (""))); check_bool ("!isinf (NAN)", !(FUNC(isinf) (FUNC(nan) ("")))); check_bool ("!isinf (-NAN)", !(FUNC(isinf) (-FUNC(nan) ("")))); check_bool ("NAN != NAN", FUNC(nan) ("") != FUNC(nan) ("")); /* test if EPSILON is ok */ x1 = MATHCONST (1.0); x2 = x1 + CHOOSE (LDBL_EPSILON, DBL_EPSILON, FLT_EPSILON); check_bool ("1 != 1+EPSILON", x1 != x2); x1 = MATHCONST (1.0); x2 = x1 - CHOOSE (LDBL_EPSILON, DBL_EPSILON, FLT_EPSILON); check_bool ("1 != 1-EPSILON", x1 != x2); /* test if HUGE_VALx is ok */ x1 = CHOOSE (HUGE_VALL, HUGE_VAL, HUGE_VALF); check_bool ("isinf (HUGE_VALx) == +1", ISINF (x1) == +1); x1 = -CHOOSE (HUGE_VALL, HUGE_VAL, HUGE_VALF); check_bool ("isinf (-HUGE_VALx) == -1", ISINF (x1) == -1); } static void initialize (void) { fpstack_test ("start *init*"); plus_zero = 0.0; nan_value = plus_zero / plus_zero; /* Suppress GCC warning */ minus_zero = FUNC (copysign) (0.0, -1.0); plus_infty = CHOOSE (HUGE_VALL, HUGE_VAL, HUGE_VALF); minus_infty = -CHOOSE (HUGE_VALL, HUGE_VAL, HUGE_VALF); (void) &plus_zero; (void) &nan_value; (void) &minus_zero; (void) &plus_infty; (void) &minus_infty; /* Clear all exceptions. From now on we must not get random exceptions. */ feclearexcept (FE_ALL_EXCEPT); /* Test to make sure we start correctly. */ fpstack_test ("end *init*"); } static struct option long_options[] = { {"verbose", optional_argument, NULL, 'v'}, {"silent", no_argument, NULL, 's'}, {0, 0, 0, 0} }; static void parse_options (int argc, char *argv[]) { int c; int option_index; verbose = 1; while (1) { c = getopt_long (argc, argv, "v::s", long_options, &option_index); /* Detect the end of the options. */ if (c == -1) break; switch (c) { case 'v': if (optarg) verbose = (unsigned int) strtoul (optarg, NULL, 0); else verbose = 4; break; case 's': verbose = 0; default: break; } } } int main (int argc, char *argv[]) { parse_options (argc, argv); initialize (); printf (TEST_MSG); basic_tests (); /* keep the tests a wee bit ordered (according to ISO 9X) */ /* classification functions */ fpclassify_test (); isfinite_test (); isnormal_test (); signbit_test (); /* trigonometric functions */ acos_test (); asin_test (); atan_test (); atan2_test (); cos_test (); sin_test (); sincos_test (); tan_test (); /* hyperbolic functions */ acosh_test (); asinh_test (); atanh_test (); cosh_test (); sinh_test (); tanh_test (); /* exponential and logarithmic functions */ exp_test (); exp2_test (); expm1_test (); frexp_test (); ldexp_test (); log_test (); log10_test (); log1p_test (); log2_test (); logb_test (); modf_test (); ilogb_test (); scalb_test (); scalbn_test (); /* power and absolute value functions */ cbrt_test (); fabs_test (); hypot_test (); pow_test (); sqrt_test (); /* error and gamma functions */ erf_test (); erfc_test (); gamma_test (); lgamma_test (); /* nearest integer functions */ ceil_test (); floor_test (); nearbyint_test (); rint_test (); lrint_test (); llrint_test (); round_test (); lround_test (); llround_test (); trunc_test (); /* remainder functions */ fmod_test (); remainder_test (); remquo_test (); /* manipulation functions */ copysign_test (); nextafter_test (); /* maximum, minimum and positive difference functions */ fdim_test (); fmin_test (); fmax_test (); /* complex functions */ cexp_test (); csin_test (); csinh_test (); ccos_test (); ccosh_test (); clog_test (); clog10_test (); cacos_test (); cacosh_test (); casin_test (); casinh_test (); catan_test (); catanh_test (); ctanh_test (); csqrt_test (); cpow_test (); /* special tests */ identities (); inverse_functions (); if (noErrors) { printf ("\n%d errors occured.\n", noErrors); exit (1); } printf ("\n All tests passed successfully.\n"); exit (0); }