Subversion Repositories or1k

/* Copyright (C) 1997, 1998, 1999, 2000, 2001 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 Lesser General Public

   License as published by the Free Software Foundation; either

   version 2.1 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

   Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public

   License along with the GNU C Library; 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 is processed by a perl script.  The resulting 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)

   FLOAT:          floating point type to test

   - TEST_MSG:     informal message to be displayed

   CHOOSE(Clongdouble,Cdouble,Cfloat,Cinlinelongdouble,Cinlinedouble,Cinlinefloat):

   chooses one of the parameters as delta for testing

   equality

   PRINTF_EXPR     Floating point conversion specification to print a variable

   of type FLOAT with printf.  PRINTF_EXPR just contains

   the specifier, not the percent and width arguments,

   e.g. "f".

   PRINTF_XEXPR    Like PRINTF_EXPR, but print in hexadecimal format.

   PRINTF_NEXPR Like PRINTF_EXPR, but print nice.  */

/* This testsuite has currently tests for:

   acos, acosh, asin, asinh, atan, atan2, atanh,

   cbrt, ceil, copysign, cos, cosh, erf, erfc, exp, exp10, exp2, expm1,

   fabs, fdim, floor, fma, fmax, fmin, fmod, fpclassify,

   frexp, gamma, hypot,

   ilogb, isfinite, isinf, isnan, isnormal,

   isless, islessequal, isgreater, isgreaterequal, islessgreater, isunordered,

   j0, j1, jn,

   ldexp, lgamma, log, log10, log1p, log2, logb,

   modf, nearbyint, nextafter,

   pow, remainder, remquo, rint, lrint, llrint,

   round, lround, llround,

   scalb, scalbn, scalbln, signbit, sin, sincos, sinh, sqrt, tan, tanh, tgamma, trunc,

   y0, y1, yn

   and for the following complex math functions:

   cabs, cacos, cacosh, carg, casin, casinh, catan, catanh,

   ccos, ccosh, cexp, clog, cpow, cproj, csin, csinh, csqrt, ctan, ctanh.

   At the moment the following functions aren't tested:

   drem, significand, nan

   Parameter handling is primitive in the moment:

   --verbose=[0..3] for different levels of output:

   0: only error count

   1: basic report on failed tests (default)

   2: full report on all tests

   -v for full output (equals --verbose=3)

   -u for generation of an ULPs file

 */

/* "Philosophy":

   This suite tests some aspects of the correct implementation of

   mathematical functions in libm.  Some simple, specific parameters

   are tested for correctness but there's no exhaustive

   testing.  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 C99.

   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.

   To Do: All parameter should be numbers that can be represented as

   exact floating point values.  Currently some values cannot be represented

   exactly and therefore the result is not the expected result.

*/

#ifndef _GNU_SOURCE

# define _GNU_SOURCE

#endif

#include "libm-test-ulps.h"

#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include 

#include 

//#include 

#define feclearexcept(X)

#define fetestexcept(X)     0

/* Possible exceptions */

#define NO_EXCEPTION                    0x0

#define INVALID_EXCEPTION               0x1

#define DIVIDE_BY_ZERO_EXCEPTION        0x2

/* The next flags signals that those exceptions are allowed but not required.   */

#define INVALID_EXCEPTION_OK            0x4

#define DIVIDE_BY_ZERO_EXCEPTION_OK     0x8

#define EXCEPTIONS_OK INVALID_EXCEPTION_OK+DIVIDE_BY_ZERO_EXCEPTION_OK

/* Some special test flags, passed togther with exceptions.  */

#define IGNORE_ZERO_INF_SIGN            0x10

/* Various constants (we must supply them precalculated for accuracy).  */

#define M_PI_6l                 .52359877559829887307710723054658383L

#define M_E2l                   7.389056098930650227230427460575008L

#define M_E3l                   20.085536923187667740928529654581719L

#define M_2_SQRT_PIl            3.5449077018110320545963349666822903L   /* 2 sqrt (M_PIl)  */

#define M_SQRT_PIl              1.7724538509055160272981674833411451L   /* sqrt (M_PIl)  */

#define M_LOG_SQRT_PIl          0.57236494292470008707171367567652933L  /* log(sqrt(M_PIl))  */

#define M_LOG_2_SQRT_PIl        1.265512123484645396488945797134706L    /* log(2*sqrt(M_PIl))  */

#define M_PI_34l                (M_PIl - M_PI_4l)               /* 3*pi/4 */

#define M_PI_34_LOG10El         (M_PIl - M_PI_4l) * M_LOG10El

#define M_PI2_LOG10El           M_PI_2l * M_LOG10El

#define M_PI4_LOG10El           M_PI_4l * M_LOG10El

#define M_PI_LOG10El            M_PIl * M_LOG10El

static FILE *ulps_file; /* File to document difference.  */

static int output_ulps; /* Should ulps printed?  */

static int noErrors;    /* number of errors */

static int noTests;     /* number of tests (without testing exceptions) */

static int noExcTests;  /* number of tests for exception flags */

static int noXFails;    /* number of expected failures.  */

static int noXPasses;   /* number of unexpected passes.  */

static int verbose;

static int output_max_error;    /* Should the maximal errors printed?  */

static int output_points;       /* Should the single function results printed?  */

static int ignore_max_ulp;      /* Should we ignore max_ulp?  */

static FLOAT minus_zero, plus_zero;

static FLOAT plus_infty, minus_infty, nan_value;

static FLOAT max_error, real_max_error, imag_max_error;

#define BUILD_COMPLEX(real, imag) \

  ({ __complex__ FLOAT __retval;                                              \

     __real__ __retval = (real);                                              \

     __imag__ __retval = (imag);                                              \

     __retval; })

#define BUILD_COMPLEX_INT(real, imag) \

  ({ __complex__ int __retval;                                                \

     __real__ __retval = (real);                                              \

     __imag__ __retval = (imag);                                              \

     __retval; })

#define MANT_DIG CHOOSE ((LDBL_MANT_DIG-1), (DBL_MANT_DIG-1), (FLT_MANT_DIG-1),  \

                         (LDBL_MANT_DIG-1), (DBL_MANT_DIG-1), (FLT_MANT_DIG-1))

static void

init_max_error (void)

{

  max_error = 0;

  real_max_error = 0;

  imag_max_error = 0;

  feclearexcept (FE_ALL_EXCEPT);

}

static void

set_max_error (FLOAT current, FLOAT *curr_max_error)

{

  if (current > *curr_max_error)

    *curr_max_error = current;

}

/* Should the message print to screen?  This depends on the verbose flag,

   and the test status.  */

static int

print_screen (int ok, int xfail)

{

  if (output_points

      && (verbose > 1

          || (verbose == 1 && ok == xfail)))

    return 1;

  return 0;

}

/* Should the message print to screen?  This depends on the verbose flag,

   and the test status.  */

static int

print_screen_max_error (int ok, int xfail)

{

  if (output_max_error

      && (verbose > 1

          || ((verbose == 1) && (ok == xfail))))

    return 1;

  return 0;

}

/* Update statistic counters.  */

static void

update_stats (int ok, int xfail)

{

  ++noTests;

  if (ok && xfail)

    ++noXPasses;

  else if (!ok && xfail)

    ++noXFails;

  else if (!ok && !xfail)

    ++noErrors;

}

static void

print_ulps (const char *test_name, FLOAT ulp)

{

  if (output_ulps)

    {

      fprintf (ulps_file, "Test \"%s\":\n", test_name);

      fprintf (ulps_file, "%s: %.0" PRINTF_NEXPR "\n",

               CHOOSE("ldouble", "double", "float",

                      "ildouble", "idouble", "ifloat"),

               FUNC(ceil) (ulp));

    }

}

static void

print_function_ulps (const char *function_name, FLOAT ulp)

{

  if (output_ulps)

    {

      fprintf (ulps_file, "Function: \"%s\":\n", function_name);

      fprintf (ulps_file, "%s: %.0" PRINTF_NEXPR "\n",

               CHOOSE("ldouble", "double", "float",

                      "ildouble", "idouble", "ifloat"),

               FUNC(ceil) (ulp));

    }

}

static void

print_complex_function_ulps (const char *function_name, FLOAT real_ulp,

                             FLOAT imag_ulp)

{

  if (output_ulps)

    {

      if (real_ulp != 0.0)

        {

          fprintf (ulps_file, "Function: Real part of \"%s\":\n", function_name);

          fprintf (ulps_file, "%s: %.0" PRINTF_NEXPR "\n",

                   CHOOSE("ldouble", "double", "float",

                          "ildouble", "idouble", "ifloat"),

                   FUNC(ceil) (real_ulp));

        }

      if (imag_ulp != 0.0)

        {

          fprintf (ulps_file, "Function: Imaginary part of \"%s\":\n", function_name);

          fprintf (ulps_file, "%s: %.0" PRINTF_NEXPR "\n",

                   CHOOSE("ldouble", "double", "float",

                          "ildouble", "idouble", "ifloat"),

                   FUNC(ceil) (imag_ulp));

        }

    }

}

/* 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 (%d, should be %d)\n",

              test_name, sw, old_stack);

      ++noErrors;

      old_stack = sw;

    }

#endif

}

static void

print_max_error (const char *func_name, FLOAT allowed, int xfail)

{

  int ok = 0;

  if (max_error == 0.0 || (max_error <= allowed && !ignore_max_ulp))

    {

      ok = 1;

    }

  if (!ok)

    print_function_ulps (func_name, max_error);

  if (print_screen_max_error (ok, xfail))

    {

      printf ("Maximal error of `%s'\n", func_name);

      printf (" is      : %.0" PRINTF_NEXPR " ulp\n", FUNC(ceil) (max_error));

      printf (" accepted: %.0" PRINTF_NEXPR " ulp\n", FUNC(ceil) (allowed));

    }

  update_stats (ok, xfail);

}

static void

print_complex_max_error (const char *func_name, __complex__ FLOAT allowed,

                         __complex__ int xfail)

{

  int ok = 0;

  if ((real_max_error == 0 && imag_max_error == 0)

      || (real_max_error <= __real__ allowed

          && imag_max_error <= __imag__ allowed

          && !ignore_max_ulp))

    {

      ok = 1;

    }

  if (!ok)

    print_complex_function_ulps (func_name, real_max_error, imag_max_error);

  if (print_screen_max_error (ok, xfail))

    {

      printf ("Maximal error of real part of: %s\n", func_name);

      printf (" is      : %.0" PRINTF_NEXPR " ulp\n",

              FUNC(ceil) (real_max_error));

      printf (" accepted: %.0" PRINTF_NEXPR " ulp\n",

              FUNC(ceil) (__real__ allowed));

      printf ("Maximal error of imaginary part of: %s\n", func_name);

      printf (" is      : %.0" PRINTF_NEXPR " ulp\n",

              FUNC(ceil) (imag_max_error));

      printf (" accepted: %.0" PRINTF_NEXPR " ulp\n",

              FUNC(ceil) (__imag__ allowed));

    }

  update_stats (ok, xfail);

}

/* Test whether a given exception was raised.  */

static void

test_single_exception (const char *test_name,

                       int exception,

                       int exc_flag,

                       int fe_flag,

                       const char *flag_name)

{

#ifndef TEST_INLINE

  int ok = 1;

  if (exception & exc_flag)

    {

      if (fetestexcept (fe_flag))

        {

          if (print_screen (1, 0))

            printf ("Pass: %s: Exception \"%s\" set\n", test_name, flag_name);

        }

      else

        {

          ok = 0;

          if (print_screen (0, 0))

            printf ("Failure: %s: Exception \"%s\" not set\n",

                    test_name, flag_name);

        }

    }

  else

    {

      if (fetestexcept (fe_flag))

        {

          ok = 0;

          if (print_screen (0, 0))

            printf ("Failure: %s: Exception \"%s\" set\n",

                    test_name, flag_name);

        }

      else

        {

          if (print_screen (1, 0))

            printf ("%s: Exception \"%s\" not set\n", test_name,

                    flag_name);

        }

    }

  if (!ok)

    ++noErrors;

#endif

}

/* Test whether exceptions given by EXCEPTION are raised.  Ignore thereby

   allowed but not required exceptions.

*/

static void

test_exceptions (const char *test_name, int exception)

{

  ++noExcTests;

#ifdef FE_DIVBYZERO

  if ((exception & DIVIDE_BY_ZERO_EXCEPTION_OK) == 0)

    test_single_exception (test_name, exception,

                           DIVIDE_BY_ZERO_EXCEPTION, FE_DIVBYZERO,

                           "Divide by zero");

#endif

#ifdef FE_INVALID

  if ((exception & INVALID_EXCEPTION_OK) == 0)

    test_single_exception (test_name, exception, INVALID_EXCEPTION, FE_INVALID,

                         "Invalid operation");

#endif

  feclearexcept (FE_ALL_EXCEPT);

}

static void

check_float_internal (const char *test_name, FLOAT computed, FLOAT expected,

                      FLOAT max_ulp, int xfail, int exceptions,

                      FLOAT *curr_max_error)

{

  int ok = 0;

  int print_diff = 0;

  FLOAT diff = 0;

  FLOAT ulp = 0;

  test_exceptions (test_name, exceptions);

  if (isnan (computed) && isnan (expected))

    ok = 1;

  else if (isinf (computed) && isinf (expected))

    {

      /* Test for sign of infinities.  */

      if ((exceptions & IGNORE_ZERO_INF_SIGN) == 0

          && signbit (computed) != signbit (expected))

        {

          ok = 0;

          printf ("infinity has wrong sign.\n");

        }

      else

        ok = 1;

    }

  /* Don't calc ulp for NaNs or infinities.  */

  else if (isinf (computed) || isnan (computed) || isinf (expected) || isnan (expected))

    ok = 0;

  else

    {

      diff = FUNC(fabs) (computed - expected);

      /* ilogb (0) isn't allowed.  */

      if (expected == 0.0)

        ulp = diff / FUNC(ldexp) (1.0, - MANT_DIG);

      else

        ulp = diff / FUNC(ldexp) (1.0, FUNC(ilogb) (expected) - MANT_DIG);

      set_max_error (ulp, curr_max_error);

      print_diff = 1;

      if ((exceptions & IGNORE_ZERO_INF_SIGN) == 0

          && computed == 0.0 && expected == 0.0

          && signbit(computed) != signbit (expected))

        ok = 0;

      else if (ulp == 0.0 || (ulp <= max_ulp && !ignore_max_ulp))

        ok = 1;

      else

        {

          ok = 0;

          print_ulps (test_name, ulp);

        }

    }

  if (print_screen (ok, xfail))

    {

      if (!ok)

        printf ("Failure: ");

      printf ("Test: %s\n", test_name);

      printf ("Result:\n");

      printf (" is:         % .20" PRINTF_EXPR "  % .20" PRINTF_XEXPR "\n",

              computed, computed);

      printf (" should be:  % .20" PRINTF_EXPR "  % .20" PRINTF_XEXPR "\n",

              expected, expected);

      if (print_diff)

        {

          printf (" difference: % .20" PRINTF_EXPR "  % .20" PRINTF_XEXPR

                  "\n", diff, diff);

          printf (" ulp       : % .4" PRINTF_NEXPR "\n", ulp);

          printf (" max.ulp   : % .4" PRINTF_NEXPR "\n", max_ulp);

        }

    }

  update_stats (ok, xfail);

  fpstack_test (test_name);

}

static void

check_float (const char *test_name, FLOAT computed, FLOAT expected,

             FLOAT max_ulp, int xfail, int exceptions)

{

  check_float_internal (test_name, computed, expected, max_ulp, xfail,

                        exceptions, &max_error);

}

static void

check_complex (const char *test_name, __complex__ FLOAT computed,

               __complex__ FLOAT expected,

               __complex__ FLOAT max_ulp, __complex__ int xfail,

               int exception)

{

  FLOAT part_comp, part_exp, part_max_ulp;

  int part_xfail;

  char str[200];

  sprintf (str, "Real part of: %s", test_name);

  part_comp = __real__ computed;

  part_exp = __real__ expected;

  part_max_ulp = __real__ max_ulp;

  part_xfail = __real__ xfail;

  check_float_internal (str, part_comp, part_exp, part_max_ulp, part_xfail,

                        exception, &real_max_error);

  sprintf (str, "Imaginary part of: %s", test_name);

  part_comp = __imag__ computed;

  part_exp = __imag__ expected;

  part_max_ulp = __imag__ max_ulp;

  part_xfail = __imag__ xfail;

  /* Don't check again for exceptions, just pass through the

     zero/inf sign test.  */

  check_float_internal (str, part_comp, part_exp, part_max_ulp, part_xfail,

                        exception & IGNORE_ZERO_INF_SIGN,

                        &imag_max_error);

}

/* Check that computed and expected values are equal (int values).  */

static void

check_int (const char *test_name, int computed, int expected, int max_ulp,

           int xfail, int exceptions)

{

  int diff = computed - expected;

  int ok = 0;

  test_exceptions (test_name, exceptions);

  noTests++;

  if (abs (diff) <= max_ulp)

    ok = 1;

  if (!ok)

    print_ulps (test_name, diff);

  if (print_screen (ok, xfail))

    {

      if (!ok)

        printf ("Failure: ");

      printf ("Test: %s\n", test_name);

      printf ("Result:\n");

      printf (" is:         %d\n", computed);

      printf (" should be:  %d\n", expected);

    }

  update_stats (ok, xfail);

  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 max_ulp, int xfail, int exceptions)

{

  long int diff = computed - expected;

  int ok = 0;

  test_exceptions (test_name, exceptions);

  noTests++;

  if (labs (diff) <= max_ulp)

    ok = 1;

  if (!ok)

    print_ulps (test_name, diff);

  if (print_screen (ok, xfail))

    {

      if (!ok)

        printf ("Failure: ");

      printf ("Test: %s\n", test_name);

      printf ("Result:\n");

      printf (" is:         %ld\n", computed);

      printf (" should be:  %ld\n", expected);

    }

  update_stats (ok, xfail);

  fpstack_test (test_name);

}

/* Check that computed value is true/false.  */

static void

check_bool (const char *test_name, int computed, int expected,

            long int max_ulp, int xfail, int exceptions)

{

  int ok = 0;

  test_exceptions (test_name, exceptions);

  noTests++;

  if ((computed == 0) == (expected == 0))

    ok = 1;

  if (print_screen (ok, xfail))

    {

      if (!ok)

        printf ("Failure: ");

      printf ("Test: %s\n", test_name);

      printf ("Result:\n");

      printf (" is:         %d\n", computed);

      printf (" should be:  %d\n", expected);

    }

  update_stats (ok, xfail);

  fpstack_test (test_name);

}

/* check that computed and expected values are equal (long int values) */

static void

check_longlong (const char *test_name, long long int computed,

                long long int expected,

                long long int max_ulp, int xfail,

                int exceptions)

{

  long long int diff = computed - expected;

  int ok = 0;

  test_exceptions (test_name, exceptions);

  noTests++;

  if (llabs (diff) <= max_ulp)

    ok = 1;

  if (!ok)

    print_ulps (test_name, diff);

  if (print_screen (ok, xfail))

    {

      if (!ok)

        printf ("Failure:");

      printf ("Test: %s\n", test_name);

      printf ("Result:\n");

      printf (" is:         %lld\n", computed);

      printf (" should be:  %lld\n", expected);

    }

  update_stats (ok, xfail);

  fpstack_test (test_name);

}

/* This is to prevent messages from the SVID libm emulation.  */

int

matherr (struct exception *x __attribute__ ((unused)))

{

  return 1;

}

/****************************************************************************

  Tests for single functions of libm.

  Please keep them alphabetically sorted!

****************************************************************************/

static void

acos_test (void)

{

  errno = 0;

  FUNC(acos) (0);

  if (errno == ENOSYS)

    /* Function not implemented.  */

    return;

  START (acos);

  TEST_f_f (acos, plus_infty, nan_value, INVALID_EXCEPTION);

  TEST_f_f (acos, minus_infty, nan_value, INVALID_EXCEPTION);

  TEST_f_f (acos, nan_value, nan_value);

  /* |x| > 1: */

  TEST_f_f (acos, 1.1L, nan_value, INVALID_EXCEPTION);

  TEST_f_f (acos, -1.1L, nan_value, INVALID_EXCEPTION);

  TEST_f_f (acos, 0, M_PI_2l);

  TEST_f_f (acos, minus_zero, M_PI_2l);

  TEST_f_f (acos, 1, 0);

  TEST_f_f (acos, -1, M_PIl);

  TEST_f_f (acos, 0.5, M_PI_6l*2.0);

  TEST_f_f (acos, -0.5, M_PI_6l*4.0);

  TEST_f_f (acos, 0.7L, 0.79539883018414355549096833892476432L);

  END (acos);

}

static void

acosh_test (void)

{

  errno = 0;

  FUNC(acosh) (7);

  if (errno == ENOSYS)

    /* Function not implemented.  */

    return;

  START (acosh);

  TEST_f_f (acosh, plus_infty, plus_infty);

  TEST_f_f (acosh, minus_infty, nan_value, INVALID_EXCEPTION);

  /* x < 1:  */

  TEST_f_f (acosh, -1.1L, nan_value, INVALID_EXCEPTION);

  TEST_f_f (acosh, 1, 0);

  TEST_f_f (acosh, 7, 2.633915793849633417250092694615937L);

  END (acosh);

}

static void

asin_test (void)

{

  errno = 0;

  FUNC(asin) (0);

  if (errno == ENOSYS)

    /* Function not implemented.  */

    return;

  START (asin);

  TEST_f_f (asin, plus_infty, nan_value, INVALID_EXCEPTION);

  TEST_f_f (asin, minus_infty, nan_value, INVALID_EXCEPTION);

  TEST_f_f (asin, nan_value, nan_value);

  /* asin x == NaN plus invalid exception for |x| > 1.  */

  TEST_f_f (asin, 1.1L, nan_value, INVALID_EXCEPTION);

  TEST_f_f (asin, -1.1L, nan_value, INVALID_EXCEPTION);

  TEST_f_f (asin, 0, 0);

  TEST_f_f (asin, minus_zero, minus_zero);

  TEST_f_f (asin, 0.5, M_PI_6l);

  TEST_f_f (asin, -0.5, -M_PI_6l);

  TEST_f_f (asin, 1.0, M_PI_2l);

  TEST_f_f (asin, -1.0, -M_PI_2l);

  TEST_f_f (asin, 0.7L, 0.77539749661075306374035335271498708L);

  END (asin);

}

static void

asinh_test (void)

{

  errno = 0;

  FUNC(asinh) (0.7L);

  if (errno == ENOSYS)

    /* Function not implemented.  */

    return;

  START (asinh);

  TEST_f_f (asinh, 0, 0);

  TEST_f_f (asinh, minus_zero, minus_zero);

#ifndef TEST_INLINE

  TEST_f_f (asinh, plus_infty, plus_infty);

  TEST_f_f (asinh, minus_infty, minus_infty);

#endif

  TEST_f_f (asinh, nan_value, nan_value);

  TEST_f_f (asinh, 0.7L, 0.652666566082355786L);

  END (asinh);

}

static void

atan_test (void)

{

  errno = 0;

  FUNC(atan) (0);

  if (errno == ENOSYS)

    /* Function not implemented.  */

    return;

  START (atan);

  TEST_f_f (atan, 0, 0);

  TEST_f_f (atan, minus_zero, minus_zero);

  TEST_f_f (atan, plus_infty, M_PI_2l);

  TEST_f_f (atan, minus_infty, -M_PI_2l);

  TEST_f_f (atan, nan_value, nan_value);

  TEST_f_f (atan, 1, M_PI_4l);

  TEST_f_f (atan, -1, -M_PI_4l);

  TEST_f_f (atan, 0.7L, 0.61072596438920861654375887649023613L);

  END (atan);

}

static void

atanh_test (void)

{

  errno = 0;

  FUNC(atanh) (0.7L);

  if (errno == ENOSYS)

    /* Function not implemented.  */

    return;

  START (atanh);

  TEST_f_f (atanh, 0, 0);

  TEST_f_f (atanh, minus_zero, minus_zero);

  TEST_f_f (atanh, 1, plus_infty, DIVIDE_BY_ZERO_EXCEPTION);

  TEST_f_f (atanh, -1, minus_infty, DIVIDE_BY_ZERO_EXCEPTION);

  TEST_f_f (atanh, nan_value, nan_value);

  /* atanh (x) == NaN plus invalid exception if |x| > 1.  */

  TEST_f_f (atanh, 1.1L, nan_value, INVALID_EXCEPTION);

  TEST_f_f (atanh, -1.1L, nan_value, INVALID_EXCEPTION);

  TEST_f_f (atanh, 0.7L, 0.8673005276940531944L);

  END (atanh);

}

static void

atan2_test (void)

{

  errno = 0;

  FUNC(atan2) (-0, 1);

  if (errno == ENOSYS)

    /* Function not implemented.  */

    return;

  START (atan2);

  /* atan2 (0,x) == 0 for x > 0.  */

  TEST_ff_f (atan2, 0, 1, 0);

  /* atan2 (-0,x) == -0 for x > 0.  */

  TEST_ff_f (atan2, minus_zero, 1, minus_zero);

  TEST_ff_f (atan2, 0, 0, 0);

  TEST_ff_f (atan2, minus_zero, 0, minus_zero);

  /* atan2 (+0,x) == +pi for x < 0.  */

  TEST_ff_f (atan2, 0, -1, M_PIl);

  /* atan2 (-0,x) == -pi for x < 0.  */

  TEST_ff_f (atan2, minus_zero, -1, -M_PIl);

  TEST_ff_f (atan2, 0, minus_zero, M_PIl);

  TEST_ff_f (atan2, minus_zero, minus_zero, -M_PIl);

  /* atan2 (y,+0) == pi/2 for y > 0.  */

  TEST_ff_f (atan2, 1, 0, M_PI_2l);

  /* atan2 (y,-0) == pi/2 for y > 0.  */

  TEST_ff_f (atan2, 1, minus_zero, M_PI_2l);

  /* atan2 (y,+0) == -pi/2 for y < 0.  */

  TEST_ff_f (atan2, -1, 0, -M_PI_2l);

  /* atan2 (y,-0) == -pi/2 for y < 0.  */

  TEST_ff_f (atan2, -1, minus_zero, -M_PI_2l);

  /* atan2 (y,inf) == +0 for finite y > 0.  */

  TEST_ff_f (atan2, 1, plus_infty, 0);

  /* atan2 (y,inf) == -0 for finite y < 0.  */

  TEST_ff_f (atan2, -1, plus_infty, minus_zero);

  /* atan2(+inf, x) == pi/2 for finite x.  */

  TEST_ff_f (atan2, plus_infty, -1, M_PI_2l);

  /* atan2(-inf, x) == -pi/2 for finite x.  */

  TEST_ff_f (atan2, minus_infty, 1, -M_PI_2l);

  /* atan2 (y,-inf) == +pi for finite y > 0.  */

  TEST_ff_f (atan2, 1, minus_infty, M_PIl);

  /* atan2 (y,-inf) == -pi for finite y < 0.  */

  TEST_ff_f (atan2, -1, minus_infty, -M_PIl);

  TEST_ff_f (atan2, plus_infty, plus_infty, M_PI_4l);

  TEST_ff_f (atan2, minus_infty, plus_infty, -M_PI_4l);

  TEST_ff_f (atan2, plus_infty, minus_infty, M_PI_34l);

  TEST_ff_f (atan2, minus_infty, minus_infty, -M_PI_34l);

  TEST_ff_f (atan2, nan_value, nan_value, nan_value);