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