tools/regression/lib/msun/test-ctrig.c

   1 /*-
   2  * Copyright (c) 2008-2011 David Schultz <das@FreeBSD.org>
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 /*
  28  * Tests for csin[h](), ccos[h](), and ctan[h]().
  29  */
  30
  31 #include <sys/cdefs.h>
  32 __FBSDID("$FreeBSD$");
  33
  34 #include <assert.h>
  35 #include <complex.h>
  36 #include <fenv.h>
  37 #include <float.h>
  38 #include <math.h>
  39 #include <stdio.h>
  40
  41 #include "test-utils.h"
  42
  43 #pragma STDC FENV_ACCESS        ON
  44 #pragma STDC CX_LIMITED_RANGE   OFF
  45
  46 /*
  47  * Test that a function returns the correct value and sets the
  48  * exception flags correctly. The exceptmask specifies which
  49  * exceptions we should check. We need to be lenient for several
  50  * reasons, but mainly because on some architectures it's impossible
  51  * to raise FE_OVERFLOW without raising FE_INEXACT.
  52  *
  53  * These are macros instead of functions so that assert provides more
  54  * meaningful error messages.
  55  *
  56  * XXX The volatile here is to avoid gcc's bogus constant folding and work
  57  *     around the lack of support for the FENV_ACCESS pragma.
  58  */
  59 #define test_p(func, z, result, exceptmask, excepts, checksign) do {    \
  60         volatile long double complex _d = z;                            \
  61         debug("  testing %s(%Lg + %Lg I) == %Lg + %Lg I\n", #func,      \
  62             creall(_d), cimagl(_d), creall(result), cimagl(result));    \
  63         assert(feclearexcept(FE_ALL_EXCEPT) == 0);                      \
  64         assert(cfpequal_cs((func)(_d), (result), (checksign)));         \
  65         assert(((void)(func), fetestexcept(exceptmask) == (excepts)));  \
  66 } while (0)
  67
  68 /*
  69  * Test within a given tolerance.  The tolerance indicates relative error
  70  * in ulps.  If result is 0, however, it measures absolute error in units
  71  * of <format>_EPSILON.
  72  */
  73 #define test_p_tol(func, z, result, tol)                        do {    \
  74         volatile long double complex _d = z;                            \
  75         debug("  testing %s(%Lg + %Lg I) ~= %Lg + %Lg I\n", #func,      \
  76             creall(_d), cimagl(_d), creall(result), cimagl(result));    \
  77         assert(cfpequal_tol((func)(_d), (result), (tol), FPE_ABS_ZERO)); \
  78 } while (0)
  79
  80 /* These wrappers apply the identities f(conj(z)) = conj(f(z)). */
  81 #define test(func, z, result, exceptmask, excepts, checksign)   do {    \
  82         test_p(func, z, result, exceptmask, excepts, checksign);        \
  83         test_p(func, conjl(z), conjl(result), exceptmask, excepts, checksign); \
  84 } while (0)
  85 #define test_tol(func, z, result, tol)                          do {    \
  86         test_p_tol(func, z, result, tol);                               \
  87         test_p_tol(func, conjl(z), conjl(result), tol);                 \
  88 } while (0)
  89 #define test_odd_tol(func, z, result, tol)                      do {    \
  90         test_tol(func, z, result, tol);                                 \
  91         test_tol(func, -(z), -(result), tol);                           \
  92 } while (0)
  93 #define test_even_tol(func, z, result, tol)                     do {    \
  94         test_tol(func, z, result, tol);                                 \
  95         test_tol(func, -(z), result, tol);                              \
  96 } while (0)
  97
  98 /* Test the given function in all precisions. */
  99 #define testall(func, x, result, exceptmask, excepts, checksign) do {   \
 100         test(func, x, result, exceptmask, excepts, checksign);          \
 101         test(func##f, x, result, exceptmask, excepts, checksign);       \
 102 } while (0)
 103 #define testall_odd(func, x, result, exceptmask, excepts, checksign) do { \
 104         testall(func, x, result, exceptmask, excepts, checksign);       \
 105         testall(func, -x, -result, exceptmask, excepts, checksign);     \
 106 } while (0)
 107 #define testall_even(func, x, result, exceptmask, excepts, checksign) do { \
 108         testall(func, x, result, exceptmask, excepts, checksign);       \
 109         testall(func, -x, result, exceptmask, excepts, checksign);      \
 110 } while (0)
 111
 112 /*
 113  * Test the given function in all precisions, within a given tolerance.
 114  * The tolerance is specified in ulps.
 115  */
 116 #define testall_tol(func, x, result, tol)                          do { \
 117         test_tol(func, x, result, tol * DBL_ULP());                     \
 118         test_tol(func##f, x, result, tol * FLT_ULP());                  \
 119 } while (0)
 120 #define testall_odd_tol(func, x, result, tol)                      do { \
 121         test_odd_tol(func, x, result, tol * DBL_ULP());                 \
 122         test_odd_tol(func##f, x, result, tol * FLT_ULP());              \
 123 } while (0)
 124 #define testall_even_tol(func, x, result, tol)                     do { \
 125         test_even_tol(func, x, result, tol * DBL_ULP());                \
 126         test_even_tol(func##f, x, result, tol * FLT_ULP());             \
 127 } while (0)
 128
 129
 130 /* Tests for 0 */
 131 void
 132 test_zero(void)
 133 {
 134         long double complex zero = CMPLXL(0.0, 0.0);
 135
 136         /* csinh(0) = ctanh(0) = 0; ccosh(0) = 1 (no exceptions raised) */
 137         testall_odd(csinh, zero, zero, ALL_STD_EXCEPT, 0, CS_BOTH);
 138         testall_odd(csin, zero, zero, ALL_STD_EXCEPT, 0, CS_BOTH);
 139         testall_even(ccosh, zero, 1.0, ALL_STD_EXCEPT, 0, CS_BOTH);
 140         testall_even(ccos, zero, CMPLXL(1.0, -0.0), ALL_STD_EXCEPT, 0, CS_BOTH);
 141         testall_odd(ctanh, zero, zero, ALL_STD_EXCEPT, 0, CS_BOTH);
 142         testall_odd(ctan, zero, zero, ALL_STD_EXCEPT, 0, CS_BOTH);
 143 }
 144
 145 /*
 146  * Tests for NaN inputs.
 147  */
 148 void
 149 test_nan()
 150 {
 151         long double complex nan_nan = CMPLXL(NAN, NAN);
 152         long double complex z;
 153
 154         /*
 155          * IN           CSINH           CCOSH           CTANH
 156          * NaN,NaN      NaN,NaN         NaN,NaN         NaN,NaN
 157          * finite,NaN   NaN,NaN [inval] NaN,NaN [inval] NaN,NaN [inval]
 158          * NaN,finite   NaN,NaN [inval] NaN,NaN [inval] NaN,NaN [inval]
 159          * NaN,Inf      NaN,NaN [inval] NaN,NaN [inval] NaN,NaN [inval]
 160          * Inf,NaN      +-Inf,NaN       Inf,NaN         1,+-0
 161          * 0,NaN        +-0,NaN         NaN,+-0         NaN,NaN [inval]
 162          * NaN,0        NaN,0           NaN,+-0         NaN,0
 163          */
 164         z = nan_nan;
 165         testall_odd(csinh, z, nan_nan, ALL_STD_EXCEPT, 0, 0);
 166         testall_even(ccosh, z, nan_nan, ALL_STD_EXCEPT, 0, 0);
 167         testall_odd(ctanh, z, nan_nan, ALL_STD_EXCEPT, 0, 0);
 168         testall_odd(csin, z, nan_nan, ALL_STD_EXCEPT, 0, 0);
 169         testall_even(ccos, z, nan_nan, ALL_STD_EXCEPT, 0, 0);
 170         testall_odd(ctan, z, nan_nan, ALL_STD_EXCEPT, 0, 0);
 171
 172         z = CMPLXL(42, NAN);
 173         testall_odd(csinh, z, nan_nan, OPT_INVALID, 0, 0);
 174         testall_even(ccosh, z, nan_nan, OPT_INVALID, 0, 0);
 175         /* XXX We allow a spurious inexact exception here. */
 176         testall_odd(ctanh, z, nan_nan, OPT_INVALID & ~FE_INEXACT, 0, 0);
 177         testall_odd(csin, z, nan_nan, OPT_INVALID, 0, 0);
 178         testall_even(ccos, z, nan_nan, OPT_INVALID, 0, 0);
 179         testall_odd(ctan, z, nan_nan, OPT_INVALID, 0, 0);
 180
 181         z = CMPLXL(NAN, 42);
 182         testall_odd(csinh, z, nan_nan, OPT_INVALID, 0, 0);
 183         testall_even(ccosh, z, nan_nan, OPT_INVALID, 0, 0);
 184         testall_odd(ctanh, z, nan_nan, OPT_INVALID, 0, 0);
 185         testall_odd(csin, z, nan_nan, OPT_INVALID, 0, 0);
 186         testall_even(ccos, z, nan_nan, OPT_INVALID, 0, 0);
 187         /* XXX We allow a spurious inexact exception here. */
 188         testall_odd(ctan, z, nan_nan, OPT_INVALID & ~FE_INEXACT, 0, 0);
 189
 190         z = CMPLXL(NAN, INFINITY);
 191         testall_odd(csinh, z, nan_nan, OPT_INVALID, 0, 0);
 192         testall_even(ccosh, z, nan_nan, OPT_INVALID, 0, 0);
 193         testall_odd(ctanh, z, nan_nan, OPT_INVALID, 0, 0);
 194         testall_odd(csin, z, CMPLXL(NAN, INFINITY), ALL_STD_EXCEPT, 0, 0);
 195         testall_even(ccos, z, CMPLXL(INFINITY, NAN), ALL_STD_EXCEPT, 0,
 196             CS_IMAG);
 197         testall_odd(ctan, z, CMPLXL(0, 1), ALL_STD_EXCEPT, 0, CS_IMAG);
 198
 199         z = CMPLXL(INFINITY, NAN);
 200         testall_odd(csinh, z, CMPLXL(INFINITY, NAN), ALL_STD_EXCEPT, 0, 0);
 201         testall_even(ccosh, z, CMPLXL(INFINITY, NAN), ALL_STD_EXCEPT, 0,
 202                      CS_REAL);
 203         testall_odd(ctanh, z, CMPLXL(1, 0), ALL_STD_EXCEPT, 0, CS_REAL);
 204         testall_odd(csin, z, nan_nan, OPT_INVALID, 0, 0);
 205         testall_even(ccos, z, nan_nan, OPT_INVALID, 0, 0);
 206         testall_odd(ctan, z, nan_nan, OPT_INVALID, 0, 0);
 207
 208         z = CMPLXL(0, NAN);
 209         testall_odd(csinh, z, CMPLXL(0, NAN), ALL_STD_EXCEPT, 0, 0);
 210         testall_even(ccosh, z, CMPLXL(NAN, 0), ALL_STD_EXCEPT, 0, 0);
 211         testall_odd(ctanh, z, nan_nan, OPT_INVALID, 0, 0);
 212         testall_odd(csin, z, CMPLXL(0, NAN), ALL_STD_EXCEPT, 0, CS_REAL);
 213         testall_even(ccos, z, CMPLXL(NAN, 0), ALL_STD_EXCEPT, 0, 0);
 214         testall_odd(ctan, z, CMPLXL(0, NAN), ALL_STD_EXCEPT, 0, CS_REAL);
 215
 216         z = CMPLXL(NAN, 0);
 217         testall_odd(csinh, z, CMPLXL(NAN, 0), ALL_STD_EXCEPT, 0, CS_IMAG);
 218         testall_even(ccosh, z, CMPLXL(NAN, 0), ALL_STD_EXCEPT, 0, 0);
 219         testall_odd(ctanh, z, CMPLXL(NAN, 0), ALL_STD_EXCEPT, 0, CS_IMAG);
 220         testall_odd(csin, z, CMPLXL(NAN, 0), ALL_STD_EXCEPT, 0, 0);
 221         testall_even(ccos, z, CMPLXL(NAN, 0), ALL_STD_EXCEPT, 0, 0);
 222         testall_odd(ctan, z, nan_nan, OPT_INVALID, 0, 0);
 223 }
 224
 225 void
 226 test_inf(void)
 227 {
 228         static const long double finites[] = {
 229             0, M_PI / 4, 3 * M_PI / 4, 5 * M_PI / 4,
 230         };
 231         long double complex z, c, s;
 232         int i;
 233
 234         /*
 235          * IN           CSINH           CCOSH           CTANH
 236          * Inf,Inf      +-Inf,NaN inval +-Inf,NaN inval 1,+-0
 237          * Inf,finite   Inf cis(finite) Inf cis(finite) 1,0 sin(2 finite)
 238          * 0,Inf        +-0,NaN inval   NaN,+-0 inval   NaN,NaN inval
 239          * finite,Inf   NaN,NaN inval   NaN,NaN inval   NaN,NaN inval
 240          */
 241         z = CMPLXL(INFINITY, INFINITY);
 242         testall_odd(csinh, z, CMPLXL(INFINITY, NAN),
 243                     ALL_STD_EXCEPT, FE_INVALID, 0);
 244         testall_even(ccosh, z, CMPLXL(INFINITY, NAN),
 245                      ALL_STD_EXCEPT, FE_INVALID, 0);
 246         testall_odd(ctanh, z, CMPLXL(1, 0), ALL_STD_EXCEPT, 0, CS_REAL);
 247         testall_odd(csin, z, CMPLXL(NAN, INFINITY),
 248                     ALL_STD_EXCEPT, FE_INVALID, 0);
 249         testall_even(ccos, z, CMPLXL(INFINITY, NAN),
 250                      ALL_STD_EXCEPT, FE_INVALID, 0);
 251         testall_odd(ctan, z, CMPLXL(0, 1), ALL_STD_EXCEPT, 0, CS_REAL);
 252
 253         /* XXX We allow spurious inexact exceptions here (hard to avoid). */
 254         for (i = 0; i < sizeof(finites) / sizeof(finites[0]); i++) {
 255                 z = CMPLXL(INFINITY, finites[i]);
 256                 c = INFINITY * cosl(finites[i]);
 257                 s = finites[i] == 0 ? finites[i] : INFINITY * sinl(finites[i]);
 258                 testall_odd(csinh, z, CMPLXL(c, s), OPT_INEXACT, 0, CS_BOTH);
 259                 testall_even(ccosh, z, CMPLXL(c, s), OPT_INEXACT, 0, CS_BOTH);
 260                 testall_odd(ctanh, z, CMPLXL(1, 0 * sin(finites[i] * 2)),
 261                             OPT_INEXACT, 0, CS_BOTH);
 262                 z = CMPLXL(finites[i], INFINITY);
 263                 testall_odd(csin, z, CMPLXL(s, c), OPT_INEXACT, 0, CS_BOTH);
 264                 testall_even(ccos, z, CMPLXL(c, -s), OPT_INEXACT, 0, CS_BOTH);
 265                 testall_odd(ctan, z, CMPLXL(0 * sin(finites[i] * 2), 1),
 266                             OPT_INEXACT, 0, CS_BOTH);
 267         }
 268
 269         z = CMPLXL(0, INFINITY);
 270         testall_odd(csinh, z, CMPLXL(0, NAN), ALL_STD_EXCEPT, FE_INVALID, 0);
 271         testall_even(ccosh, z, CMPLXL(NAN, 0), ALL_STD_EXCEPT, FE_INVALID, 0);
 272         testall_odd(ctanh, z, CMPLXL(NAN, NAN), ALL_STD_EXCEPT, FE_INVALID, 0);
 273         z = CMPLXL(INFINITY, 0);
 274         testall_odd(csin, z, CMPLXL(NAN, 0), ALL_STD_EXCEPT, FE_INVALID, 0);
 275         testall_even(ccos, z, CMPLXL(NAN, 0), ALL_STD_EXCEPT, FE_INVALID, 0);
 276         testall_odd(ctan, z, CMPLXL(NAN, NAN), ALL_STD_EXCEPT, FE_INVALID, 0);
 277
 278         z = CMPLXL(42, INFINITY);
 279         testall_odd(csinh, z, CMPLXL(NAN, NAN), ALL_STD_EXCEPT, FE_INVALID, 0);
 280         testall_even(ccosh, z, CMPLXL(NAN, NAN), ALL_STD_EXCEPT, FE_INVALID, 0);
 281         /* XXX We allow a spurious inexact exception here. */
 282         testall_odd(ctanh, z, CMPLXL(NAN, NAN), OPT_INEXACT, FE_INVALID, 0);
 283         z = CMPLXL(INFINITY, 42);
 284         testall_odd(csin, z, CMPLXL(NAN, NAN), ALL_STD_EXCEPT, FE_INVALID, 0);
 285         testall_even(ccos, z, CMPLXL(NAN, NAN), ALL_STD_EXCEPT, FE_INVALID, 0);
 286         /* XXX We allow a spurious inexact exception here. */
 287         testall_odd(ctan, z, CMPLXL(NAN, NAN), OPT_INEXACT, FE_INVALID, 0);
 288 }
 289
 290 /* Tests along the real and imaginary axes. */
 291 void
 292 test_axes(void)
 293 {
 294         static const long double nums[] = {
 295             M_PI / 4, M_PI / 2, 3 * M_PI / 4,
 296             5 * M_PI / 4, 3 * M_PI / 2, 7 * M_PI / 4,
 297         };
 298         long double complex z;
 299         int i;
 300
 301         for (i = 0; i < sizeof(nums) / sizeof(nums[0]); i++) {
 302                 /* Real axis */
 303                 z = CMPLXL(nums[i], 0.0);
 304                 test_odd_tol(csinh, z, CMPLXL(sinh(nums[i]), 0), DBL_ULP());
 305                 test_even_tol(ccosh, z, CMPLXL(cosh(nums[i]), 0), DBL_ULP());
 306                 test_odd_tol(ctanh, z, CMPLXL(tanh(nums[i]), 0), DBL_ULP());
 307                 test_odd_tol(csin, z, CMPLXL(sin(nums[i]),
 308                     copysign(0, cos(nums[i]))), DBL_ULP());
 309                 test_even_tol(ccos, z, CMPLXL(cos(nums[i]),
 310                     -copysign(0, sin(nums[i]))), DBL_ULP());
 311                 test_odd_tol(ctan, z, CMPLXL(tan(nums[i]), 0), DBL_ULP());
 312
 313                 test_odd_tol(csinhf, z, CMPLXL(sinhf(nums[i]), 0), FLT_ULP());
 314                 test_even_tol(ccoshf, z, CMPLXL(coshf(nums[i]), 0), FLT_ULP());
 315                 printf("%a %a\n", creal(z), cimag(z));
 316                 printf("%a %a\n", creal(ctanhf(z)), cimag(ctanhf(z)));
 317                 printf("%a\n", nextafterf(tanhf(nums[i]), INFINITY));
 318                 test_odd_tol(ctanhf, z, CMPLXL(tanhf(nums[i]), 0),
 319                              1.3 * FLT_ULP());
 320                 test_odd_tol(csinf, z, CMPLXL(sinf(nums[i]),
 321                     copysign(0, cosf(nums[i]))), FLT_ULP());
 322                 test_even_tol(ccosf, z, CMPLXL(cosf(nums[i]),
 323                     -copysign(0, sinf(nums[i]))), 2 * FLT_ULP());
 324                 test_odd_tol(ctanf, z, CMPLXL(tanf(nums[i]), 0), FLT_ULP());
 325
 326                 /* Imaginary axis */
 327                 z = CMPLXL(0.0, nums[i]);
 328                 test_odd_tol(csinh, z, CMPLXL(copysign(0, cos(nums[i])),
 329                                                  sin(nums[i])), DBL_ULP());
 330                 test_even_tol(ccosh, z, CMPLXL(cos(nums[i]),
 331                     copysign(0, sin(nums[i]))), DBL_ULP());
 332                 test_odd_tol(ctanh, z, CMPLXL(0, tan(nums[i])), DBL_ULP());
 333                 test_odd_tol(csin, z, CMPLXL(0, sinh(nums[i])), DBL_ULP());
 334                 test_even_tol(ccos, z, CMPLXL(cosh(nums[i]), -0.0), DBL_ULP());
 335                 test_odd_tol(ctan, z, CMPLXL(0, tanh(nums[i])), DBL_ULP());
 336
 337                 test_odd_tol(csinhf, z, CMPLXL(copysign(0, cosf(nums[i])),
 338                                                  sinf(nums[i])), FLT_ULP());
 339                 test_even_tol(ccoshf, z, CMPLXL(cosf(nums[i]),
 340                     copysign(0, sinf(nums[i]))), FLT_ULP());
 341                 test_odd_tol(ctanhf, z, CMPLXL(0, tanf(nums[i])), FLT_ULP());
 342                 test_odd_tol(csinf, z, CMPLXL(0, sinhf(nums[i])), FLT_ULP());
 343                 test_even_tol(ccosf, z, CMPLXL(coshf(nums[i]), -0.0),
 344                               FLT_ULP());
 345                 test_odd_tol(ctanf, z, CMPLXL(0, tanhf(nums[i])),
 346                              1.3 * FLT_ULP());
 347         }
 348 }
 349
 350 void
 351 test_small(void)
 352 {
 353         /*
 354          * z =  0.5 + i Pi/4
 355          *     sinh(z) = (sinh(0.5) + i cosh(0.5)) * sqrt(2)/2
 356          *     cosh(z) = (cosh(0.5) + i sinh(0.5)) * sqrt(2)/2
 357          *     tanh(z) = (2cosh(0.5)sinh(0.5) + i) / (2 cosh(0.5)**2 - 1)
 358          * z = -0.5 + i Pi/2
 359          *     sinh(z) = cosh(0.5)
 360          *     cosh(z) = -i sinh(0.5)
 361          *     tanh(z) = -coth(0.5)
 362          * z =  1.0 + i 3Pi/4
 363          *     sinh(z) = (-sinh(1) + i cosh(1)) * sqrt(2)/2
 364          *     cosh(z) = (-cosh(1) + i sinh(1)) * sqrt(2)/2
 365          *     tanh(z) = (2cosh(1)sinh(1) - i) / (2cosh(1)**2 - 1)
 366          */
 367         static const struct {
 368                 long double a, b;
 369                 long double sinh_a, sinh_b;
 370                 long double cosh_a, cosh_b;
 371                 long double tanh_a, tanh_b;
 372         } tests[] = {
 373                 {  0.5L,
 374                    0.78539816339744830961566084581987572L,
 375                    0.36847002415910435172083660522240710L,
 376                    0.79735196663945774996093142586179334L,
 377                    0.79735196663945774996093142586179334L,
 378                    0.36847002415910435172083660522240710L,
 379                    0.76159415595576488811945828260479359L,
 380                    0.64805427366388539957497735322615032L },
 381                 { -0.5L,
 382                    1.57079632679489661923132169163975144L,
 383                    0.0L,
 384                    1.12762596520638078522622516140267201L,
 385                    0.0L,
 386                   -0.52109530549374736162242562641149156L,
 387                   -2.16395341373865284877000401021802312L,
 388                    0.0L },
 389                 {  1.0L,
 390                    2.35619449019234492884698253745962716L,
 391                   -0.83099273328405698212637979852748608L,
 392                    1.09112278079550143030545602018565236L,
 393                   -1.09112278079550143030545602018565236L,
 394                    0.83099273328405698212637979852748609L,
 395                    0.96402758007581688394641372410092315L,
 396                   -0.26580222883407969212086273981988897L }
 397         };
 398         long double complex z;
 399         int i;
 400
 401         for (i = 0; i < sizeof(tests) / sizeof(tests[0]); i++) {
 402                 z = CMPLXL(tests[i].a, tests[i].b);
 403                 testall_odd_tol(csinh, z,
 404                     CMPLXL(tests[i].sinh_a, tests[i].sinh_b), 1.1);
 405                 testall_even_tol(ccosh, z,
 406                     CMPLXL(tests[i].cosh_a, tests[i].cosh_b), 1.1);
 407                 testall_odd_tol(ctanh, z,
 408                     CMPLXL(tests[i].tanh_a, tests[i].tanh_b), 1.4);
 409         }
 410 }
 411
 412 /* Test inputs that might cause overflow in a sloppy implementation. */
 413 void
 414 test_large(void)
 415 {
 416         long double complex z;
 417
 418         /* tanh() uses a threshold around x=22, so check both sides. */
 419         z = CMPLXL(21, 0.78539816339744830961566084581987572L);
 420         testall_odd_tol(ctanh, z,
 421             CMPLXL(1.0, 1.14990445285871196133287617611468468e-18L), 1.2);
 422         z++;
 423         testall_odd_tol(ctanh, z,
 424             CMPLXL(1.0, 1.55622644822675930314266334585597964e-19L), 1);
 425
 426         z = CMPLXL(355, 0.78539816339744830961566084581987572L);
 427         test_odd_tol(ctanh, z,
 428                      CMPLXL(1.0, 8.95257245135025991216632140458264468e-309L),
 429                      DBL_ULP());
 430         z = CMPLXL(30, 0x1p1023L);
 431         test_odd_tol(ctanh, z,
 432                      CMPLXL(1.0, -1.62994325413993477997492170229268382e-26L),
 433                      DBL_ULP());
 434         z = CMPLXL(1, 0x1p1023L);
 435         test_odd_tol(ctanh, z,
 436                      CMPLXL(0.878606311888306869546254022621986509L,
 437                             -0.225462792499754505792678258169527424L),
 438                      DBL_ULP());
 439
 440         z = CMPLXL(710.6, 0.78539816339744830961566084581987572L);
 441         test_odd_tol(csinh, z,
 442             CMPLXL(1.43917579766621073533185387499658944e308L,
 443                    1.43917579766621073533185387499658944e308L), DBL_ULP());
 444         test_even_tol(ccosh, z,
 445             CMPLXL(1.43917579766621073533185387499658944e308L,
 446                    1.43917579766621073533185387499658944e308L), DBL_ULP());
 447
 448         z = CMPLXL(1500, 0.78539816339744830961566084581987572L);
 449         testall_odd(csinh, z, CMPLXL(INFINITY, INFINITY), OPT_INEXACT,
 450             FE_OVERFLOW, CS_BOTH);
 451         testall_even(ccosh, z, CMPLXL(INFINITY, INFINITY), OPT_INEXACT,
 452             FE_OVERFLOW, CS_BOTH);
 453 }
 454
 455 int
 456 main(int argc, char *argv[])
 457 {
 458
 459         printf("1..6\n");
 460
 461         test_zero();
 462         printf("ok 1 - ctrig zero\n");
 463
 464         test_nan();
 465         printf("ok 2 - ctrig nan\n");
 466
 467         test_inf();
 468         printf("ok 3 - ctrig inf\n");
 469
 470         test_axes();
 471         printf("ok 4 - ctrig axes\n");
 472
 473         test_small();
 474         printf("ok 5 - ctrig small\n");
 475
 476         test_large();
 477         printf("ok 6 - ctrig large\n");
 478
 479         return (0);
 480 }