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