sysdeps/ieee754/k_standard.c

   1 /* @(#)k_standard.c 5.1 93/09/24 */
   2 /*
   3  * ====================================================
   4  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
   5  *
   6  * Developed at SunPro, a Sun Microsystems, Inc. business.
   7  * Permission to use, copy, modify, and distribute this
   8  * software is freely granted, provided that this notice
   9  * is preserved.
  10  * ====================================================
  11  */
  12
  13 #if defined(LIBM_SCCS) && !defined(lint)
  14 static char rcsid[] = "$NetBSD: k_standard.c,v 1.6 1995/05/10 20:46:35 jtc Exp $";
  15 #endif
  16
  17 #include <math.h>
  18 #include <math_private.h>
  19 #include <math-svid-compat.h>
  20 #include <errno.h>
  21
  22 #include <assert.h>
  23
  24 #if LIBM_SVID_COMPAT
  25
  26 # ifndef _USE_WRITE
  27 #  include <stdio.h>                    /* fputs(), stderr */
  28 #  define       WRITE2(u,v)     fputs(u, stderr)
  29 # else  /* !defined(_USE_WRITE) */
  30 #  include <unistd.h>                   /* write */
  31 #  define       WRITE2(u,v)     write(2, u, v)
  32 #  undef fflush
  33 # endif /* !defined(_USE_WRITE) */
  34
  35 /* XXX gcc versions until now don't delay the 0.0/0.0 division until
  36    runtime but produce NaN at compile time.  This is wrong since the
  37    exceptions are not set correctly.  */
  38 # if 0
  39 static const double zero = 0.0; /* used as const */
  40 # else
  41 static double zero = 0.0;       /* used as const */
  42 # endif
  43
  44 /*
  45  * Standard conformance (non-IEEE) on exception cases.
  46  * Mapping:
  47  *      1 -- acos(|x|>1)
  48  *      2 -- asin(|x|>1)
  49  *      3 -- atan2(+-0,+-0)
  50  *      4 -- hypot overflow
  51  *      5 -- cosh overflow
  52  *      6 -- exp overflow
  53  *      7 -- exp underflow
  54  *      8 -- y0(0)
  55  *      9 -- y0(-ve)
  56  *      10-- y1(0)
  57  *      11-- y1(-ve)
  58  *      12-- yn(0)
  59  *      13-- yn(-ve)
  60  *      14-- lgamma(finite) overflow
  61  *      15-- lgamma(-integer)
  62  *      16-- log(0)
  63  *      17-- log(x<0)
  64  *      18-- log10(0)
  65  *      19-- log10(x<0)
  66  *      21-- pow(x,y) overflow
  67  *      22-- pow(x,y) underflow
  68  *      23-- pow(0,negative)
  69  *      24-- pow(neg,non-integral)
  70  *      25-- sinh(finite) overflow
  71  *      26-- sqrt(negative)
  72  *      27-- fmod(x,0)
  73  *      28-- remainder(x,0)
  74  *      29-- acosh(x<1)
  75  *      30-- atanh(|x|>1)
  76  *      31-- atanh(|x|=1)
  77  *      32-- scalb overflow
  78  *      33-- scalb underflow
  79  *      34-- j0(|x|>X_TLOSS)
  80  *      35-- y0(x>X_TLOSS)
  81  *      36-- j1(|x|>X_TLOSS)
  82  *      37-- y1(x>X_TLOSS)
  83  *      38-- jn(|x|>X_TLOSS, n)
  84  *      39-- yn(x>X_TLOSS, n)
  85  *      40-- tgamma(finite) overflow
  86  *      41-- tgamma(-integer)
  87  *      43-- +0**neg
  88  *      44-- exp2 overflow
  89  *      45-- exp2 underflow
  90  *      46-- exp10 overflow
  91  *      47-- exp10 underflow
  92  *      48-- log2(0)
  93  *      49-- log2(x<0)
  94  *      50-- tgamma(+-0)
  95  */
  96
  97
  98 double
  99 __kernel_standard(double x, double y, int type)
 100 {
 101         struct exception exc;
 102 # ifndef HUGE_VAL       /* this is the only routine that uses HUGE_VAL */
 103 # define HUGE_VAL inf
 104         double inf = 0.0;
 105
 106         SET_HIGH_WORD(inf,0x7ff00000);  /* set inf to infinite */
 107 # endif
 108
 109         /* The SVID struct exception uses a field "char *name;".  */
 110 # define CSTR(func) ((char *) (type < 100                               \
 111                               ? func                                    \
 112                               : (type < 200 ? func "f" : func "l")))
 113
 114 # ifdef _USE_WRITE
 115         (void) fflush(stdout);
 116 # endif
 117         exc.arg1 = x;
 118         exc.arg2 = y;
 119         switch(type) {
 120             case 1:
 121             case 101:
 122             case 201:
 123                 /* acos(|x|>1) */
 124                 exc.type = DOMAIN;
 125                 exc.name = CSTR ("acos");
 126                 if (_LIB_VERSION == _SVID_)
 127                   exc.retval = HUGE;
 128                 else
 129                   exc.retval = NAN;
 130                 if (_LIB_VERSION == _POSIX_)
 131                   __set_errno (EDOM);
 132                 else if (!matherr(&exc)) {
 133                   if(_LIB_VERSION == _SVID_) {
 134                     (void) WRITE2("acos: DOMAIN error\n", 19);
 135                   }
 136                   __set_errno (EDOM);
 137                 }
 138                 break;
 139             case 2:
 140             case 102:
 141             case 202:
 142                 /* asin(|x|>1) */
 143                 exc.type = DOMAIN;
 144                 exc.name = CSTR ("asin");
 145                 if (_LIB_VERSION == _SVID_)
 146                   exc.retval = HUGE;
 147                 else
 148                   exc.retval = NAN;
 149                 if(_LIB_VERSION == _POSIX_)
 150                   __set_errno (EDOM);
 151                 else if (!matherr(&exc)) {
 152                   if(_LIB_VERSION == _SVID_) {
 153                         (void) WRITE2("asin: DOMAIN error\n", 19);
 154                   }
 155                   __set_errno (EDOM);
 156                 }
 157                 break;
 158             case 3:
 159             case 103:
 160             case 203:
 161                 /* atan2(+-0,+-0) */
 162                 exc.arg1 = y;
 163                 exc.arg2 = x;
 164                 exc.type = DOMAIN;
 165                 exc.name = CSTR ("atan2");
 166                 assert (_LIB_VERSION == _SVID_);
 167                 exc.retval = HUGE;
 168                 if(_LIB_VERSION == _POSIX_)
 169                   __set_errno (EDOM);
 170                 else if (!matherr(&exc)) {
 171                   if(_LIB_VERSION == _SVID_) {
 172                         (void) WRITE2("atan2: DOMAIN error\n", 20);
 173                       }
 174                   __set_errno (EDOM);
 175                 }
 176                 break;
 177             case 4:
 178             case 104:
 179             case 204:
 180                 /* hypot(finite,finite) overflow */
 181                 exc.type = OVERFLOW;
 182                 exc.name = CSTR ("hypot");
 183                 if (_LIB_VERSION == _SVID_)
 184                   exc.retval = HUGE;
 185                 else
 186                   exc.retval = HUGE_VAL;
 187                 if (_LIB_VERSION == _POSIX_)
 188                   __set_errno (ERANGE);
 189                 else if (!matherr(&exc)) {
 190                         __set_errno (ERANGE);
 191                 }
 192                 break;
 193             case 5:
 194             case 105:
 195             case 205:
 196                 /* cosh(finite) overflow */
 197                 exc.type = OVERFLOW;
 198                 exc.name = CSTR ("cosh");
 199                 if (_LIB_VERSION == _SVID_)
 200                   exc.retval = HUGE;
 201                 else
 202                   exc.retval = HUGE_VAL;
 203                 if (_LIB_VERSION == _POSIX_)
 204                   __set_errno (ERANGE);
 205                 else if (!matherr(&exc)) {
 206                         __set_errno (ERANGE);
 207                 }
 208                 break;
 209             case 6:
 210             case 106:
 211             case 206:
 212                 /* exp(finite) overflow */
 213                 exc.type = OVERFLOW;
 214                 exc.name = CSTR ("exp");
 215                 if (_LIB_VERSION == _SVID_)
 216                   exc.retval = HUGE;
 217                 else
 218                   exc.retval = HUGE_VAL;
 219                 if (_LIB_VERSION == _POSIX_)
 220                   __set_errno (ERANGE);
 221                 else if (!matherr(&exc)) {
 222                         __set_errno (ERANGE);
 223                 }
 224                 break;
 225             case 7:
 226             case 107:
 227             case 207:
 228                 /* exp(finite) underflow */
 229                 exc.type = UNDERFLOW;
 230                 exc.name = CSTR ("exp");
 231                 exc.retval = zero;
 232                 if (_LIB_VERSION == _POSIX_)
 233                   __set_errno (ERANGE);
 234                 else if (!matherr(&exc)) {
 235                         __set_errno (ERANGE);
 236                 }
 237                 break;
 238             case 8:
 239             case 108:
 240             case 208:
 241                 /* y0(0) = -inf */
 242                 exc.type = DOMAIN;      /* should be SING for IEEE */
 243                 exc.name = CSTR ("y0");
 244                 if (_LIB_VERSION == _SVID_)
 245                   exc.retval = -HUGE;
 246                 else
 247                   exc.retval = -HUGE_VAL;
 248                 if (_LIB_VERSION == _POSIX_)
 249                   __set_errno (ERANGE);
 250                 else if (!matherr(&exc)) {
 251                   if (_LIB_VERSION == _SVID_) {
 252                         (void) WRITE2("y0: DOMAIN error\n", 17);
 253                       }
 254                   __set_errno (EDOM);
 255                 }
 256                 break;
 257             case 9:
 258             case 109:
 259             case 209:
 260                 /* y0(x<0) = NaN */
 261                 exc.type = DOMAIN;
 262                 exc.name = CSTR ("y0");
 263                 if (_LIB_VERSION == _SVID_)
 264                   exc.retval = -HUGE;
 265                 else
 266                   exc.retval = NAN;
 267                 if (_LIB_VERSION == _POSIX_)
 268                   __set_errno (EDOM);
 269                 else if (!matherr(&exc)) {
 270                   if (_LIB_VERSION == _SVID_) {
 271                         (void) WRITE2("y0: DOMAIN error\n", 17);
 272                       }
 273                   __set_errno (EDOM);
 274                 }
 275                 break;
 276             case 10:
 277             case 110:
 278             case 210:
 279                 /* y1(0) = -inf */
 280                 exc.type = DOMAIN;      /* should be SING for IEEE */
 281                 exc.name = CSTR ("y1");
 282                 if (_LIB_VERSION == _SVID_)
 283                   exc.retval = -HUGE;
 284                 else
 285                   exc.retval = -HUGE_VAL;
 286                 if (_LIB_VERSION == _POSIX_)
 287                   __set_errno (ERANGE);
 288                 else if (!matherr(&exc)) {
 289                   if (_LIB_VERSION == _SVID_) {
 290                         (void) WRITE2("y1: DOMAIN error\n", 17);
 291                       }
 292                   __set_errno (EDOM);
 293                 }
 294                 break;
 295             case 11:
 296             case 111:
 297             case 211:
 298                 /* y1(x<0) = NaN */
 299                 exc.type = DOMAIN;
 300                 exc.name = CSTR ("y1");
 301                 if (_LIB_VERSION == _SVID_)
 302                   exc.retval = -HUGE;
 303                 else
 304                   exc.retval = NAN;
 305                 if (_LIB_VERSION == _POSIX_)
 306                   __set_errno (EDOM);
 307                 else if (!matherr(&exc)) {
 308                   if (_LIB_VERSION == _SVID_) {
 309                         (void) WRITE2("y1: DOMAIN error\n", 17);
 310                       }
 311                   __set_errno (EDOM);
 312                 }
 313                 break;
 314             case 12:
 315             case 112:
 316             case 212:
 317                 /* yn(n,0) = -inf */
 318                 exc.type = DOMAIN;      /* should be SING for IEEE */
 319                 exc.name = CSTR ("yn");
 320                 if (_LIB_VERSION == _SVID_)
 321                   exc.retval = -HUGE;
 322                 else
 323                   exc.retval = ((x < 0 && ((int) x & 1) != 0)
 324                                 ? HUGE_VAL
 325                                 : -HUGE_VAL);
 326                 if (_LIB_VERSION == _POSIX_)
 327                   __set_errno (ERANGE);
 328                 else if (!matherr(&exc)) {
 329                   if (_LIB_VERSION == _SVID_) {
 330                         (void) WRITE2("yn: DOMAIN error\n", 17);
 331                       }
 332                   __set_errno (EDOM);
 333                 }
 334                 break;
 335             case 13:
 336             case 113:
 337             case 213:
 338                 /* yn(x<0) = NaN */
 339                 exc.type = DOMAIN;
 340                 exc.name = CSTR ("yn");
 341                 if (_LIB_VERSION == _SVID_)
 342                   exc.retval = -HUGE;
 343                 else
 344                   exc.retval = NAN;
 345                 if (_LIB_VERSION == _POSIX_)
 346                   __set_errno (EDOM);
 347                 else if (!matherr(&exc)) {
 348                   if (_LIB_VERSION == _SVID_) {
 349                         (void) WRITE2("yn: DOMAIN error\n", 17);
 350                       }
 351                   __set_errno (EDOM);
 352                 }
 353                 break;
 354             case 14:
 355             case 114:
 356             case 214:
 357                 /* lgamma(finite) overflow */
 358                 exc.type = OVERFLOW;
 359                 exc.name = CSTR ("lgamma");
 360                 if (_LIB_VERSION == _SVID_)
 361                   exc.retval = HUGE;
 362                 else
 363                   exc.retval = HUGE_VAL;
 364                 if (_LIB_VERSION == _POSIX_)
 365                         __set_errno (ERANGE);
 366                 else if (!matherr(&exc)) {
 367                         __set_errno (ERANGE);
 368                 }
 369                 break;
 370             case 15:
 371             case 115:
 372             case 215:
 373                 /* lgamma(-integer) or lgamma(0) */
 374                 exc.type = SING;
 375                 exc.name = CSTR ("lgamma");
 376                 if (_LIB_VERSION == _SVID_)
 377                   exc.retval = HUGE;
 378                 else
 379                   exc.retval = HUGE_VAL;
 380                 if (_LIB_VERSION == _POSIX_)
 381                   __set_errno (ERANGE);
 382                 else if (!matherr(&exc)) {
 383                   if (_LIB_VERSION == _SVID_) {
 384                         (void) WRITE2("lgamma: SING error\n", 19);
 385                       }
 386                   __set_errno (EDOM);
 387                 }
 388                 break;
 389             case 16:
 390             case 116:
 391             case 216:
 392                 /* log(0) */
 393                 exc.type = SING;
 394                 exc.name = CSTR ("log");
 395                 if (_LIB_VERSION == _SVID_)
 396                   exc.retval = -HUGE;
 397                 else
 398                   exc.retval = -HUGE_VAL;
 399                 if (_LIB_VERSION == _POSIX_)
 400                   __set_errno (ERANGE);
 401                 else if (!matherr(&exc)) {
 402                   if (_LIB_VERSION == _SVID_) {
 403                         (void) WRITE2("log: SING error\n", 16);
 404                       }
 405                   __set_errno (EDOM);
 406                 }
 407                 break;
 408             case 17:
 409             case 117:
 410             case 217:
 411                 /* log(x<0) */
 412                 exc.type = DOMAIN;
 413                 exc.name = CSTR ("log");
 414                 if (_LIB_VERSION == _SVID_)
 415                   exc.retval = -HUGE;
 416                 else
 417                   exc.retval = NAN;
 418                 if (_LIB_VERSION == _POSIX_)
 419                   __set_errno (EDOM);
 420                 else if (!matherr(&exc)) {
 421                   if (_LIB_VERSION == _SVID_) {
 422                         (void) WRITE2("log: DOMAIN error\n", 18);
 423                       }
 424                   __set_errno (EDOM);
 425                 }
 426                 break;
 427             case 18:
 428             case 118:
 429             case 218:
 430                 /* log10(0) */
 431                 exc.type = SING;
 432                 exc.name = CSTR ("log10");
 433                 if (_LIB_VERSION == _SVID_)
 434                   exc.retval = -HUGE;
 435                 else
 436                   exc.retval = -HUGE_VAL;
 437                 if (_LIB_VERSION == _POSIX_)
 438                   __set_errno (ERANGE);
 439                 else if (!matherr(&exc)) {
 440                   if (_LIB_VERSION == _SVID_) {
 441                         (void) WRITE2("log10: SING error\n", 18);
 442                       }
 443                   __set_errno (EDOM);
 444                 }
 445                 break;
 446             case 19:
 447             case 119:
 448             case 219:
 449                 /* log10(x<0) */
 450                 exc.type = DOMAIN;
 451                 exc.name = CSTR ("log10");
 452                 if (_LIB_VERSION == _SVID_)
 453                   exc.retval = -HUGE;
 454                 else
 455                   exc.retval = NAN;
 456                 if (_LIB_VERSION == _POSIX_)
 457                   __set_errno (EDOM);
 458                 else if (!matherr(&exc)) {
 459                   if (_LIB_VERSION == _SVID_) {
 460                         (void) WRITE2("log10: DOMAIN error\n", 20);
 461                       }
 462                   __set_errno (EDOM);
 463                 }
 464                 break;
 465             case 21:
 466             case 121:
 467             case 221:
 468                 /* pow(x,y) overflow */
 469                 exc.type = OVERFLOW;
 470                 exc.name = CSTR ("pow");
 471                 if (_LIB_VERSION == _SVID_) {
 472                   exc.retval = HUGE;
 473                   y *= 0.5;
 474                   if(x<zero&&__rint(y)!=y) exc.retval = -HUGE;
 475                 } else {
 476                   exc.retval = HUGE_VAL;
 477                   y *= 0.5;
 478                   if(x<zero&&__rint(y)!=y) exc.retval = -HUGE_VAL;
 479                 }
 480                 if (_LIB_VERSION == _POSIX_)
 481                   __set_errno (ERANGE);
 482                 else if (!matherr(&exc)) {
 483                         __set_errno (ERANGE);
 484                 }
 485                 break;
 486             case 22:
 487             case 122:
 488             case 222:
 489                 /* pow(x,y) underflow */
 490                 exc.type = UNDERFLOW;
 491                 exc.name = CSTR ("pow");
 492                 exc.retval =  zero;
 493                 y *= 0.5;
 494                 if (x < zero && __rint (y) != y)
 495                   exc.retval = -zero;
 496                 if (_LIB_VERSION == _POSIX_)
 497                   __set_errno (ERANGE);
 498                 else if (!matherr(&exc)) {
 499                         __set_errno (ERANGE);
 500                 }
 501                 break;
 502             case 23:
 503             case 123:
 504             case 223:
 505                 /* -0**neg */
 506                 exc.type = DOMAIN;
 507                 exc.name = CSTR ("pow");
 508                 if (_LIB_VERSION == _SVID_)
 509                   exc.retval = zero;
 510                 else
 511                   exc.retval = -HUGE_VAL;
 512                 if (_LIB_VERSION == _POSIX_)
 513                   __set_errno (ERANGE);
 514                 else if (!matherr(&exc)) {
 515                   if (_LIB_VERSION == _SVID_) {
 516                         (void) WRITE2("pow(0,neg): DOMAIN error\n", 25);
 517                       }
 518                   __set_errno (EDOM);
 519                 }
 520                 break;
 521             case 43:
 522             case 143:
 523             case 243:
 524                 /* +0**neg */
 525                 exc.type = DOMAIN;
 526                 exc.name = CSTR ("pow");
 527                 if (_LIB_VERSION == _SVID_)
 528                   exc.retval = zero;
 529                 else
 530                   exc.retval = HUGE_VAL;
 531                 if (_LIB_VERSION == _POSIX_)
 532                   __set_errno (ERANGE);
 533                 else if (!matherr(&exc)) {
 534                   if (_LIB_VERSION == _SVID_) {
 535                         (void) WRITE2("pow(0,neg): DOMAIN error\n", 25);
 536                       }
 537                   __set_errno (EDOM);
 538                 }
 539                 break;
 540             case 24:
 541             case 124:
 542             case 224:
 543                 /* neg**non-integral */
 544                 exc.type = DOMAIN;
 545                 exc.name = CSTR ("pow");
 546                 if (_LIB_VERSION == _SVID_)
 547                     exc.retval = zero;
 548                 else
 549                     exc.retval = zero/zero;     /* X/Open allow NaN */
 550                 if (_LIB_VERSION == _POSIX_)
 551                    __set_errno (EDOM);
 552                 else if (!matherr(&exc)) {
 553                   if (_LIB_VERSION == _SVID_) {
 554                         (void) WRITE2("neg**non-integral: DOMAIN error\n", 32);
 555                       }
 556                   __set_errno (EDOM);
 557                 }
 558                 break;
 559             case 25:
 560             case 125:
 561             case 225:
 562                 /* sinh(finite) overflow */
 563                 exc.type = OVERFLOW;
 564                 exc.name = CSTR ("sinh");
 565                 if (_LIB_VERSION == _SVID_)
 566                   exc.retval = ( (x>zero) ? HUGE : -HUGE);
 567                 else
 568                   exc.retval = ( (x>zero) ? HUGE_VAL : -HUGE_VAL);
 569                 if (_LIB_VERSION == _POSIX_)
 570                   __set_errno (ERANGE);
 571                 else if (!matherr(&exc)) {
 572                         __set_errno (ERANGE);
 573                 }
 574                 break;
 575             case 26:
 576             case 126:
 577             case 226:
 578                 /* sqrt(x<0) */
 579                 exc.type = DOMAIN;
 580                 exc.name = CSTR ("sqrt");
 581                 if (_LIB_VERSION == _SVID_)
 582                   exc.retval = zero;
 583                 else
 584                   exc.retval = zero/zero;
 585                 if (_LIB_VERSION == _POSIX_)
 586                   __set_errno (EDOM);
 587                 else if (!matherr(&exc)) {
 588                   if (_LIB_VERSION == _SVID_) {
 589                         (void) WRITE2("sqrt: DOMAIN error\n", 19);
 590                       }
 591                   __set_errno (EDOM);
 592                 }
 593                 break;
 594             case 27:
 595             case 127:
 596             case 227:
 597                 /* fmod(x,0) */
 598                 exc.type = DOMAIN;
 599                 exc.name = CSTR ("fmod");
 600                 if (_LIB_VERSION == _SVID_)
 601                     exc.retval = x;
 602                 else
 603                     exc.retval = zero/zero;
 604                 if (_LIB_VERSION == _POSIX_)
 605                   __set_errno (EDOM);
 606                 else if (!matherr(&exc)) {
 607                   if (_LIB_VERSION == _SVID_) {
 608                     (void) WRITE2("fmod:  DOMAIN error\n", 20);
 609                   }
 610                   __set_errno (EDOM);
 611                 }
 612                 break;
 613             case 28:
 614             case 128:
 615             case 228:
 616                 /* remainder(x,0) */
 617                 exc.type = DOMAIN;
 618                 exc.name = CSTR ("remainder");
 619                 exc.retval = zero/zero;
 620                 if (_LIB_VERSION == _POSIX_)
 621                   __set_errno (EDOM);
 622                 else if (!matherr(&exc)) {
 623                   if (_LIB_VERSION == _SVID_) {
 624                     (void) WRITE2("remainder: DOMAIN error\n", 24);
 625                   }
 626                   __set_errno (EDOM);
 627                 }
 628                 break;
 629             case 29:
 630             case 129:
 631             case 229:
 632                 /* acosh(x<1) */
 633                 exc.type = DOMAIN;
 634                 exc.name = CSTR ("acosh");
 635                 exc.retval = zero/zero;
 636                 if (_LIB_VERSION == _POSIX_)
 637                   __set_errno (EDOM);
 638                 else if (!matherr(&exc)) {
 639                   if (_LIB_VERSION == _SVID_) {
 640                     (void) WRITE2("acosh: DOMAIN error\n", 20);
 641                   }
 642                   __set_errno (EDOM);
 643                 }
 644                 break;
 645             case 30:
 646             case 130:
 647             case 230:
 648                 /* atanh(|x|>1) */
 649                 exc.type = DOMAIN;
 650                 exc.name = CSTR ("atanh");
 651                 exc.retval = zero/zero;
 652                 if (_LIB_VERSION == _POSIX_)
 653                   __set_errno (EDOM);
 654                 else if (!matherr(&exc)) {
 655                   if (_LIB_VERSION == _SVID_) {
 656                     (void) WRITE2("atanh: DOMAIN error\n", 20);
 657                   }
 658                   __set_errno (EDOM);
 659                 }
 660                 break;
 661             case 31:
 662             case 131:
 663             case 231:
 664                 /* atanh(|x|=1) */
 665                 exc.type = SING;
 666                 exc.name = CSTR ("atanh");
 667                 exc.retval = x/zero;    /* sign(x)*inf */
 668                 if (_LIB_VERSION == _POSIX_)
 669                   __set_errno (ERANGE);
 670                 else if (!matherr(&exc)) {
 671                   if (_LIB_VERSION == _SVID_) {
 672                     (void) WRITE2("atanh: SING error\n", 18);
 673                   }
 674                   __set_errno (EDOM);
 675                 }
 676                 break;
 677             case 32:
 678             case 132:
 679             case 232:
 680                 /* scalb overflow; SVID also returns +-HUGE_VAL */
 681                 exc.type = OVERFLOW;
 682                 exc.name = CSTR ("scalb");
 683                 exc.retval = x > zero ? HUGE_VAL : -HUGE_VAL;
 684                 if (_LIB_VERSION == _POSIX_)
 685                   __set_errno (ERANGE);
 686                 else if (!matherr(&exc)) {
 687                         __set_errno (ERANGE);
 688                 }
 689                 break;
 690             case 33:
 691             case 133:
 692             case 233:
 693                 /* scalb underflow */
 694                 exc.type = UNDERFLOW;
 695                 exc.name = CSTR ("scalb");
 696                 exc.retval = __copysign(zero,x);
 697                 if (_LIB_VERSION == _POSIX_)
 698                   __set_errno (ERANGE);
 699                 else if (!matherr(&exc)) {
 700                         __set_errno (ERANGE);
 701                 }
 702                 break;
 703             case 34:
 704             case 134:
 705             case 234:
 706                 /* j0(|x|>X_TLOSS) */
 707                 exc.type = TLOSS;
 708                 exc.name = CSTR ("j0");
 709                 exc.retval = zero;
 710                 if (_LIB_VERSION == _POSIX_)
 711                         __set_errno (ERANGE);
 712                 else if (!matherr(&exc)) {
 713                         if (_LIB_VERSION == _SVID_) {
 714                                 (void) WRITE2(exc.name, 2);
 715                                 (void) WRITE2(": TLOSS error\n", 14);
 716                         }
 717                         __set_errno (ERANGE);
 718                 }
 719                 break;
 720             case 35:
 721             case 135:
 722             case 235:
 723                 /* y0(x>X_TLOSS) */
 724                 exc.type = TLOSS;
 725                 exc.name = CSTR ("y0");
 726                 exc.retval = zero;
 727                 if (_LIB_VERSION == _POSIX_)
 728                         __set_errno (ERANGE);
 729                 else if (!matherr(&exc)) {
 730                         if (_LIB_VERSION == _SVID_) {
 731                                 (void) WRITE2(exc.name, 2);
 732                                 (void) WRITE2(": TLOSS error\n", 14);
 733                         }
 734                         __set_errno (ERANGE);
 735                 }
 736                 break;
 737             case 36:
 738             case 136:
 739             case 236:
 740                 /* j1(|x|>X_TLOSS) */
 741                 exc.type = TLOSS;
 742                 exc.name = CSTR ("j1");
 743                 exc.retval = zero;
 744                 if (_LIB_VERSION == _POSIX_)
 745                         __set_errno (ERANGE);
 746                 else if (!matherr(&exc)) {
 747                         if (_LIB_VERSION == _SVID_) {
 748                                 (void) WRITE2(exc.name, 2);
 749                                 (void) WRITE2(": TLOSS error\n", 14);
 750                         }
 751                         __set_errno (ERANGE);
 752                 }
 753                 break;
 754             case 37:
 755             case 137:
 756             case 237:
 757                 /* y1(x>X_TLOSS) */
 758                 exc.type = TLOSS;
 759                 exc.name = CSTR ("y1");
 760                 exc.retval = zero;
 761                 if (_LIB_VERSION == _POSIX_)
 762                         __set_errno (ERANGE);
 763                 else if (!matherr(&exc)) {
 764                         if (_LIB_VERSION == _SVID_) {
 765                                 (void) WRITE2(exc.name, 2);
 766                                 (void) WRITE2(": TLOSS error\n", 14);
 767                         }
 768                         __set_errno (ERANGE);
 769                 }
 770                 break;
 771             case 38:
 772             case 138:
 773             case 238:
 774                 /* jn(|x|>X_TLOSS) */
 775                 exc.type = TLOSS;
 776                 exc.name = CSTR ("jn");
 777                 exc.retval = zero;
 778                 if (_LIB_VERSION == _POSIX_)
 779                         __set_errno (ERANGE);
 780                 else if (!matherr(&exc)) {
 781                         if (_LIB_VERSION == _SVID_) {
 782                                 (void) WRITE2(exc.name, 2);
 783                                 (void) WRITE2(": TLOSS error\n", 14);
 784                         }
 785                         __set_errno (ERANGE);
 786                 }
 787                 break;
 788             case 39:
 789             case 139:
 790             case 239:
 791                 /* yn(x>X_TLOSS) */
 792                 exc.type = TLOSS;
 793                 exc.name = CSTR ("yn");
 794                 exc.retval = zero;
 795                 if (_LIB_VERSION == _POSIX_)
 796                         __set_errno (ERANGE);
 797                 else if (!matherr(&exc)) {
 798                         if (_LIB_VERSION == _SVID_) {
 799                                 (void) WRITE2(exc.name, 2);
 800                                 (void) WRITE2(": TLOSS error\n", 14);
 801                         }
 802                         __set_errno (ERANGE);
 803                 }
 804                 break;
 805             case 40:
 806             case 140:
 807             case 240:
 808                 /* tgamma(finite) overflow */
 809                 exc.type = OVERFLOW;
 810                 exc.name = CSTR ("tgamma");
 811                 exc.retval = __copysign (HUGE_VAL, x);
 812                 if (_LIB_VERSION == _POSIX_)
 813                   __set_errno (ERANGE);
 814                 else if (!matherr(&exc)) {
 815                   __set_errno (ERANGE);
 816                 }
 817                 break;
 818             case 41:
 819             case 141:
 820             case 241:
 821                 /* tgamma(-integer) */
 822                 exc.type = SING;
 823                 exc.name = CSTR ("tgamma");
 824                 exc.retval = NAN;
 825                 if (_LIB_VERSION == _POSIX_)
 826                   __set_errno (EDOM);
 827                 else if (!matherr(&exc)) {
 828                   if (_LIB_VERSION == _SVID_) {
 829                         (void) WRITE2("tgamma: SING error\n", 18);
 830                         exc.retval = HUGE_VAL;
 831                       }
 832                   __set_errno (EDOM);
 833                 }
 834                 break;
 835
 836             case 44:
 837             case 144:
 838             case 244:
 839                 /* exp(finite) overflow */
 840                 exc.type = OVERFLOW;
 841                 exc.name = CSTR ("exp2");
 842                 if (_LIB_VERSION == _SVID_)
 843                   exc.retval = HUGE;
 844                 else
 845                   exc.retval = HUGE_VAL;
 846                 if (_LIB_VERSION == _POSIX_)
 847                   __set_errno (ERANGE);
 848                 else if (!matherr(&exc)) {
 849                         __set_errno (ERANGE);
 850                 }
 851                 break;
 852             case 45:
 853             case 145:
 854             case 245:
 855                 /* exp(finite) underflow */
 856                 exc.type = UNDERFLOW;
 857                 exc.name = CSTR ("exp2");
 858                 exc.retval = zero;
 859                 if (_LIB_VERSION == _POSIX_)
 860                   __set_errno (ERANGE);
 861                 else if (!matherr(&exc)) {
 862                         __set_errno (ERANGE);
 863                 }
 864                 break;
 865
 866             case 46:
 867             case 146:
 868             case 246:
 869                 /* exp(finite) overflow */
 870                 exc.type = OVERFLOW;
 871                 exc.name = CSTR ("exp10");
 872                 if (_LIB_VERSION == _SVID_)
 873                   exc.retval = HUGE;
 874                 else
 875                   exc.retval = HUGE_VAL;
 876                 if (_LIB_VERSION == _POSIX_)
 877                   __set_errno (ERANGE);
 878                 else if (!matherr(&exc)) {
 879                         __set_errno (ERANGE);
 880                 }
 881                 break;
 882             case 47:
 883             case 147:
 884             case 247:
 885                 /* exp(finite) underflow */
 886                 exc.type = UNDERFLOW;
 887                 exc.name = CSTR ("exp10");
 888                 exc.retval = zero;
 889                 if (_LIB_VERSION == _POSIX_)
 890                   __set_errno (ERANGE);
 891                 else if (!matherr(&exc)) {
 892                         __set_errno (ERANGE);
 893                 }
 894                 break;
 895             case 48:
 896             case 148:
 897             case 248:
 898                 /* log2(0) */
 899                 exc.type = SING;
 900                 exc.name = CSTR ("log2");
 901                 if (_LIB_VERSION == _SVID_)
 902                   exc.retval = -HUGE;
 903                 else
 904                   exc.retval = -HUGE_VAL;
 905                 if (_LIB_VERSION == _POSIX_)
 906                   __set_errno (ERANGE);
 907                 else if (!matherr(&exc)) {
 908                   __set_errno (EDOM);
 909                 }
 910                 break;
 911             case 49:
 912             case 149:
 913             case 249:
 914                 /* log2(x<0) */
 915                 exc.type = DOMAIN;
 916                 exc.name = CSTR ("log2");
 917                 if (_LIB_VERSION == _SVID_)
 918                   exc.retval = -HUGE;
 919                 else
 920                   exc.retval = NAN;
 921                 if (_LIB_VERSION == _POSIX_)
 922                   __set_errno (EDOM);
 923                 else if (!matherr(&exc)) {
 924                   __set_errno (EDOM);
 925                 }
 926                 break;
 927             case 50:
 928             case 150:
 929             case 250:
 930                 /* tgamma(+-0) */
 931                 exc.type = SING;
 932                 exc.name = CSTR ("tgamma");
 933                 exc.retval = __copysign (HUGE_VAL, x);
 934                 if (_LIB_VERSION == _POSIX_)
 935                   __set_errno (ERANGE);
 936                 else if (!matherr(&exc)) {
 937                   if (_LIB_VERSION == _SVID_)
 938                     (void) WRITE2("tgamma: SING error\n", 18);
 939                   __set_errno (ERANGE);
 940                 }
 941                 break;
 942
 943                 /* #### Last used is 50/150/250 ### */
 944
 945             default:
 946                 __builtin_unreachable ();
 947         }
 948         return exc.retval;
 949 }
 950 #endif