lib/libm/src/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 #include <sys/cdefs.h>
  14 #if defined(LIBM_SCCS) && !defined(lint)
  15 __RCSID("$NetBSD: k_standard.c,v 1.16 2010/09/01 10:44:28 drochner Exp $");
  16 #endif
  17
  18 #include "math.h"
  19 #include "math_private.h"
  20 #include <errno.h>
  21
  22 #ifndef _USE_WRITE
  23 #include <stdio.h>                      /* fputs(), stderr */
  24 #define WRITE2(u,v)     fputs(u, stderr)
  25 #else   /* !defined(_USE_WRITE) */
  26 #include <unistd.h>                     /* write */
  27 #define WRITE2(u,v)     write(2, u, v)
  28 #undef fflush
  29 #endif  /* !defined(_USE_WRITE) */
  30
  31 static const double zero = 0.0; /* used as const */
  32
  33 /*
  34  * Standard conformance (non-IEEE) on exception cases.
  35  * Mapping:
  36  *      1 -- acos(|x|>1)
  37  *      2 -- asin(|x|>1)
  38  *      3 -- atan2(+-0,+-0)
  39  *      4 -- hypot overflow
  40  *      5 -- cosh overflow
  41  *      6 -- exp overflow
  42  *      7 -- exp underflow
  43  *      8 -- y0(0)
  44  *      9 -- y0(-ve)
  45  *      10-- y1(0)
  46  *      11-- y1(-ve)
  47  *      12-- yn(0)
  48  *      13-- yn(-ve)
  49  *      14-- lgamma(finite) overflow
  50  *      15-- lgamma(-integer)
  51  *      16-- log(0)
  52  *      17-- log(x<0)
  53  *      18-- log10(0)
  54  *      19-- log10(x<0)
  55  *      20-- pow(0.0,0.0)
  56  *      21-- pow(x,y) overflow
  57  *      22-- pow(x,y) underflow
  58  *      23-- pow(0,negative)
  59  *      24-- pow(neg,non-integral)
  60  *      25-- sinh(finite) overflow
  61  *      26-- sqrt(negative)
  62  *      27-- fmod(x,0)
  63  *      28-- remainder(x,0)
  64  *      29-- acosh(x<1)
  65  *      30-- atanh(|x|>1)
  66  *      31-- atanh(|x|=1)
  67  *      32-- scalb overflow
  68  *      33-- scalb underflow
  69  *      34-- j0(|x|>X_TLOSS)
  70  *      35-- y0(x>X_TLOSS)
  71  *      36-- j1(|x|>X_TLOSS)
  72  *      37-- y1(x>X_TLOSS)
  73  *      38-- jn(|x|>X_TLOSS, n)
  74  *      39-- yn(x>X_TLOSS, n)
  75  *      40-- gamma(finite) overflow
  76  *      41-- gamma(-integer)
  77  *      42-- pow(NaN,0.0)
  78  *      48-- log2(0)
  79  *      49-- log2(x<0)
  80  */
  81
  82
  83 double
  84 __kernel_standard(double x, double y, int type)
  85 {
  86         struct exception exc;
  87 #ifndef HUGE_VAL        /* this is the only routine that uses HUGE_VAL */
  88 #define HUGE_VAL inf
  89         double inf = 0.0;
  90
  91         SET_HIGH_WORD(inf,0x7ff00000);  /* set inf to infinite */
  92 #endif
  93
  94 #ifdef _USE_WRITE
  95         (void) fflush(stdout);
  96 #endif
  97         exc.arg1 = x;
  98         exc.arg2 = y;
  99         switch(type) {
 100             case 1:
 101             case 101:
 102                 /* acos(|x|>1) */
 103                 exc.type = DOMAIN;
 104                 exc.name = type < 100 ? "acos" : "acosf";
 105                 exc.retval = zero;
 106                 if (_LIB_VERSION == _POSIX_) {
 107                   exc.retval = zero/zero;
 108                   errno = EDOM;
 109                 } else if (!matherr(&exc)) {
 110                   if(_LIB_VERSION == _SVID_) {
 111                     (void) WRITE2("acos: DOMAIN error\n", 19);
 112                   }
 113                   errno = EDOM;
 114                 }
 115                 break;
 116             case 2:
 117             case 102:
 118                 /* asin(|x|>1) */
 119                 exc.type = DOMAIN;
 120                 exc.name = type < 100 ? "asin" : "asinf";
 121                 exc.retval = zero;
 122                 if(_LIB_VERSION == _POSIX_) {
 123                   exc.retval = zero/zero;
 124                   errno = EDOM;
 125                 } else if (!matherr(&exc)) {
 126                   if(_LIB_VERSION == _SVID_) {
 127                         (void) WRITE2("asin: DOMAIN error\n", 19);
 128                   }
 129                   errno = EDOM;
 130                 }
 131                 break;
 132             case 3:
 133             case 103:
 134                 /* atan2(+-0,+-0) */
 135                 exc.arg1 = y;
 136                 exc.arg2 = x;
 137                 exc.type = DOMAIN;
 138                 exc.name = type < 100 ? "atan2" : "atan2f";
 139                 exc.retval = zero;
 140                 if(_LIB_VERSION == _POSIX_) {
 141                   exc.retval = copysign(signbit(y) ? M_PI : zero, x);
 142                 } else if (!matherr(&exc)) {
 143                   if(_LIB_VERSION == _SVID_) {
 144                         (void) WRITE2("atan2: DOMAIN error\n", 20);
 145                       }
 146                   errno = EDOM;
 147                 }
 148                 break;
 149             case 4:
 150             case 104:
 151                 /* hypot(finite,finite) overflow */
 152                 exc.type = OVERFLOW;
 153                 exc.name = type < 100 ? "hypot" : "hypotf";
 154                 if (_LIB_VERSION == _SVID_)
 155                   exc.retval = HUGE;
 156                 else
 157                   exc.retval = HUGE_VAL;
 158                 if (_LIB_VERSION == _POSIX_)
 159                   errno = ERANGE;
 160                 else if (!matherr(&exc)) {
 161                         errno = ERANGE;
 162                 }
 163                 break;
 164             case 5:
 165             case 105:
 166                 /* cosh(finite) overflow */
 167                 exc.type = OVERFLOW;
 168                 exc.name = type < 100 ? "cosh" : "coshf";
 169                 if (_LIB_VERSION == _SVID_)
 170                   exc.retval = HUGE;
 171                 else
 172                   exc.retval = HUGE_VAL;
 173                 if (_LIB_VERSION == _POSIX_)
 174                   errno = ERANGE;
 175                 else if (!matherr(&exc)) {
 176                         errno = ERANGE;
 177                 }
 178                 break;
 179             case 6:
 180             case 106:
 181                 /* exp(finite) overflow */
 182                 exc.type = OVERFLOW;
 183                 exc.name = type < 100 ? "exp" : "expf";
 184                 if (_LIB_VERSION == _SVID_)
 185                   exc.retval = HUGE;
 186                 else
 187                   exc.retval = HUGE_VAL;
 188                 if (_LIB_VERSION == _POSIX_)
 189                   errno = ERANGE;
 190                 else if (!matherr(&exc)) {
 191                         errno = ERANGE;
 192                 }
 193                 break;
 194             case 7:
 195             case 107:
 196                 /* exp(finite) underflow */
 197                 exc.type = UNDERFLOW;
 198                 exc.name = type < 100 ? "exp" : "expf";
 199                 exc.retval = zero;
 200                 if (_LIB_VERSION == _POSIX_)
 201                   errno = ERANGE;
 202                 else if (!matherr(&exc)) {
 203                         errno = ERANGE;
 204                 }
 205                 break;
 206             case 8:
 207             case 108:
 208                 /* y0(0) = -inf */
 209                 exc.type = DOMAIN;      /* should be SING for IEEE */
 210                 exc.name = type < 100 ? "y0" : "y0f";
 211                 if (_LIB_VERSION == _SVID_)
 212                   exc.retval = -HUGE;
 213                 else
 214                   exc.retval = -HUGE_VAL;
 215                 if (_LIB_VERSION == _POSIX_)
 216                   errno = EDOM;
 217                 else if (!matherr(&exc)) {
 218                   if (_LIB_VERSION == _SVID_) {
 219                         (void) WRITE2("y0: DOMAIN error\n", 17);
 220                       }
 221                   errno = EDOM;
 222                 }
 223                 break;
 224             case 9:
 225             case 109:
 226                 /* y0(x<0) = NaN */
 227                 exc.type = DOMAIN;
 228                 exc.name = type < 100 ? "y0" : "y0f";
 229                 if (_LIB_VERSION == _SVID_)
 230                   exc.retval = -HUGE;
 231                 else
 232                   exc.retval = -HUGE_VAL;
 233                 if (_LIB_VERSION == _POSIX_)
 234                   errno = EDOM;
 235                 else if (!matherr(&exc)) {
 236                   if (_LIB_VERSION == _SVID_) {
 237                         (void) WRITE2("y0: DOMAIN error\n", 17);
 238                       }
 239                   errno = EDOM;
 240                 }
 241                 break;
 242             case 10:
 243             case 110:
 244                 /* y1(0) = -inf */
 245                 exc.type = DOMAIN;      /* should be SING for IEEE */
 246                 exc.name = type < 100 ? "y1" : "y1f";
 247                 if (_LIB_VERSION == _SVID_)
 248                   exc.retval = -HUGE;
 249                 else
 250                   exc.retval = -HUGE_VAL;
 251                 if (_LIB_VERSION == _POSIX_)
 252                   errno = EDOM;
 253                 else if (!matherr(&exc)) {
 254                   if (_LIB_VERSION == _SVID_) {
 255                         (void) WRITE2("y1: DOMAIN error\n", 17);
 256                       }
 257                   errno = EDOM;
 258                 }
 259                 break;
 260             case 11:
 261             case 111:
 262                 /* y1(x<0) = NaN */
 263                 exc.type = DOMAIN;
 264                 exc.name = type < 100 ? "y1" : "y1f";
 265                 if (_LIB_VERSION == _SVID_)
 266                   exc.retval = -HUGE;
 267                 else
 268                   exc.retval = -HUGE_VAL;
 269                 if (_LIB_VERSION == _POSIX_)
 270                   errno = EDOM;
 271                 else if (!matherr(&exc)) {
 272                   if (_LIB_VERSION == _SVID_) {
 273                         (void) WRITE2("y1: DOMAIN error\n", 17);
 274                       }
 275                   errno = EDOM;
 276                 }
 277                 break;
 278             case 12:
 279             case 112:
 280                 /* yn(n,0) = -inf */
 281                 exc.type = DOMAIN;      /* should be SING for IEEE */
 282                 exc.name = type < 100 ? "yn" : "ynf";
 283                 if (_LIB_VERSION == _SVID_)
 284                   exc.retval = -HUGE;
 285                 else
 286                   exc.retval = -HUGE_VAL;
 287                 if (_LIB_VERSION == _POSIX_)
 288                   errno = EDOM;
 289                 else if (!matherr(&exc)) {
 290                   if (_LIB_VERSION == _SVID_) {
 291                         (void) WRITE2("yn: DOMAIN error\n", 17);
 292                       }
 293                   errno = EDOM;
 294                 }
 295                 break;
 296             case 13:
 297             case 113:
 298                 /* yn(x<0) = NaN */
 299                 exc.type = DOMAIN;
 300                 exc.name = type < 100 ? "yn" : "ynf";
 301                 if (_LIB_VERSION == _SVID_)
 302                   exc.retval = -HUGE;
 303                 else
 304                   exc.retval = -HUGE_VAL;
 305                 if (_LIB_VERSION == _POSIX_)
 306                   errno = EDOM;
 307                 else if (!matherr(&exc)) {
 308                   if (_LIB_VERSION == _SVID_) {
 309                         (void) WRITE2("yn: DOMAIN error\n", 17);
 310                       }
 311                   errno = EDOM;
 312                 }
 313                 break;
 314             case 14:
 315             case 114:
 316                 /* lgamma(finite) overflow */
 317                 exc.type = OVERFLOW;
 318                 exc.name = type < 100 ? "lgamma" : "lgammaf";
 319                 if (_LIB_VERSION == _SVID_)
 320                   exc.retval = HUGE;
 321                 else
 322                   exc.retval = HUGE_VAL;
 323                 if (_LIB_VERSION == _POSIX_)
 324                         errno = ERANGE;
 325                 else if (!matherr(&exc)) {
 326                         errno = ERANGE;
 327                 }
 328                 break;
 329             case 15:
 330             case 115:
 331                 /* lgamma(-integer) or lgamma(0) */
 332                 exc.type = SING;
 333                 exc.name = type < 100 ? "lgamma" : "lgammaf";
 334                 if (_LIB_VERSION == _SVID_)
 335                   exc.retval = HUGE;
 336                 else
 337                   exc.retval = HUGE_VAL;
 338                 if (_LIB_VERSION == _POSIX_)
 339                   errno = EDOM;
 340                 else if (!matherr(&exc)) {
 341                   if (_LIB_VERSION == _SVID_) {
 342                         (void) WRITE2("lgamma: SING error\n", 19);
 343                       }
 344                   errno = EDOM;
 345                 }
 346                 break;
 347             case 16:
 348             case 116:
 349                 /* log(0) */
 350                 exc.type = SING;
 351                 exc.name = type < 100 ? "log" : "logf";
 352                 if (_LIB_VERSION == _SVID_)
 353                   exc.retval = -HUGE;
 354                 else
 355                   exc.retval = -HUGE_VAL;
 356                 if (_LIB_VERSION == _POSIX_)
 357                   errno = ERANGE;
 358                 else if (!matherr(&exc)) {
 359                   if (_LIB_VERSION == _SVID_) {
 360                         (void) WRITE2("log: SING error\n", 16);
 361                       }
 362                   errno = EDOM;
 363                 }
 364                 break;
 365             case 17:
 366             case 117:
 367                 /* log(x<0) */
 368                 exc.type = DOMAIN;
 369                 exc.name = type < 100 ? "log" : "logf";
 370                 if (_LIB_VERSION == _SVID_)
 371                   exc.retval = -HUGE;
 372                 else
 373                   exc.retval = -HUGE_VAL;
 374                 if (_LIB_VERSION == _POSIX_)
 375                   errno = EDOM;
 376                 else if (!matherr(&exc)) {
 377                   if (_LIB_VERSION == _SVID_) {
 378                         (void) WRITE2("log: DOMAIN error\n", 18);
 379                       }
 380                   errno = EDOM;
 381                 }
 382                 break;
 383             case 18:
 384             case 118:
 385                 /* log10(0) */
 386                 exc.type = SING;
 387                 exc.name = type < 100 ? "log10" : "log10f";
 388                 if (_LIB_VERSION == _SVID_)
 389                   exc.retval = -HUGE;
 390                 else
 391                   exc.retval = -HUGE_VAL;
 392                 if (_LIB_VERSION == _POSIX_)
 393                   errno = ERANGE;
 394                 else if (!matherr(&exc)) {
 395                   if (_LIB_VERSION == _SVID_) {
 396                         (void) WRITE2("log10: SING error\n", 18);
 397                       }
 398                   errno = EDOM;
 399                 }
 400                 break;
 401             case 19:
 402             case 119:
 403                 /* log10(x<0) */
 404                 exc.type = DOMAIN;
 405                 exc.name = type < 100 ? "log10" : "log10f";
 406                 if (_LIB_VERSION == _SVID_)
 407                   exc.retval = -HUGE;
 408                 else
 409                   exc.retval = -HUGE_VAL;
 410                 if (_LIB_VERSION == _POSIX_)
 411                   errno = EDOM;
 412                 else if (!matherr(&exc)) {
 413                   if (_LIB_VERSION == _SVID_) {
 414                         (void) WRITE2("log10: DOMAIN error\n", 20);
 415                       }
 416                   errno = EDOM;
 417                 }
 418                 break;
 419             case 20:
 420             case 120:
 421                 /* pow(0.0,0.0) */
 422                 /* error only if _LIB_VERSION == _SVID_ */
 423                 exc.type = DOMAIN;
 424                 exc.name = type < 100 ? "pow" : "powf";
 425                 exc.retval = zero;
 426                 if (_LIB_VERSION != _SVID_) exc.retval = 1.0;
 427                 else if (!matherr(&exc)) {
 428                         (void) WRITE2("pow(0,0): DOMAIN error\n", 23);
 429                         errno = EDOM;
 430                 }
 431                 break;
 432             case 21:
 433             case 121:
 434                 /* pow(x,y) overflow */
 435                 exc.type = OVERFLOW;
 436                 exc.name = type < 100 ? "pow" : "powf";
 437                 if (_LIB_VERSION == _SVID_) {
 438                   exc.retval = HUGE;
 439                   y *= 0.5;
 440                   if(x<zero&&rint(y)!=y) exc.retval = -HUGE;
 441                 } else {
 442                   exc.retval = HUGE_VAL;
 443                   y *= 0.5;
 444                   if(x<zero&&rint(y)!=y) exc.retval = -HUGE_VAL;
 445                 }
 446                 if (_LIB_VERSION == _POSIX_)
 447                   errno = ERANGE;
 448                 else if (!matherr(&exc)) {
 449                         errno = ERANGE;
 450                 }
 451                 break;
 452             case 22:
 453             case 122:
 454                 /* pow(x,y) underflow */
 455                 exc.type = UNDERFLOW;
 456                 exc.name = type < 100 ? "pow" : "powf";
 457                 exc.retval =  zero;
 458                 if (_LIB_VERSION == _POSIX_)
 459                   errno = ERANGE;
 460                 else if (!matherr(&exc)) {
 461                         errno = ERANGE;
 462                 }
 463                 break;
 464             case 23:
 465             case 123:
 466                 /* 0**neg */
 467                 exc.type = DOMAIN;
 468                 exc.name = type < 100 ? "pow" : "powf";
 469                 if (_LIB_VERSION == _SVID_)
 470                   exc.retval = zero;
 471                 else
 472                   exc.retval = -HUGE_VAL;
 473                 if (_LIB_VERSION == _POSIX_)
 474                   errno = EDOM;
 475                 else if (!matherr(&exc)) {
 476                   if (_LIB_VERSION == _SVID_) {
 477                         (void) WRITE2("pow(0,neg): DOMAIN error\n", 25);
 478                       }
 479                   errno = EDOM;
 480                 }
 481                 break;
 482             case 24:
 483             case 124:
 484                 /* neg**non-integral */
 485                 exc.type = DOMAIN;
 486                 exc.name = type < 100 ? "pow" : "powf";
 487                 if (_LIB_VERSION == _SVID_)
 488                     exc.retval = zero;
 489                 else
 490                     exc.retval = zero/zero;     /* X/Open allow NaN */
 491                 if (_LIB_VERSION == _POSIX_)
 492                    errno = EDOM;
 493                 else if (!matherr(&exc)) {
 494                   if (_LIB_VERSION == _SVID_) {
 495                         (void) WRITE2("neg**non-integral: DOMAIN error\n", 32);
 496                       }
 497                   errno = EDOM;
 498                 }
 499                 break;
 500             case 25:
 501             case 125:
 502                 /* sinh(finite) overflow */
 503                 exc.type = OVERFLOW;
 504                 exc.name = type < 100 ? "sinh" : "sinhf";
 505                 if (_LIB_VERSION == _SVID_)
 506                   exc.retval = ( (x>zero) ? HUGE : -HUGE);
 507                 else
 508                   exc.retval = ( (x>zero) ? HUGE_VAL : -HUGE_VAL);
 509                 if (_LIB_VERSION == _POSIX_)
 510                   errno = ERANGE;
 511                 else if (!matherr(&exc)) {
 512                         errno = ERANGE;
 513                 }
 514                 break;
 515             case 26:
 516             case 126:
 517                 /* sqrt(x<0) */
 518                 exc.type = DOMAIN;
 519                 exc.name = type < 100 ? "sqrt" : "sqrtf";
 520                 if (_LIB_VERSION == _SVID_)
 521                   exc.retval = zero;
 522                 else
 523                   exc.retval = zero/zero;
 524                 if (_LIB_VERSION == _POSIX_)
 525                   errno = EDOM;
 526                 else if (!matherr(&exc)) {
 527                   if (_LIB_VERSION == _SVID_) {
 528                         (void) WRITE2("sqrt: DOMAIN error\n", 19);
 529                       }
 530                   errno = EDOM;
 531                 }
 532                 break;
 533             case 27:
 534             case 127:
 535                 /* fmod(x,0) */
 536                 exc.type = DOMAIN;
 537                 exc.name = type < 100 ? "fmod" : "fmodf";
 538                 if (_LIB_VERSION == _SVID_)
 539                     exc.retval = x;
 540                 else
 541                     exc.retval = zero/zero;
 542                 if (_LIB_VERSION == _POSIX_)
 543                   errno = EDOM;
 544                 else if (!matherr(&exc)) {
 545                   if (_LIB_VERSION == _SVID_) {
 546                     (void) WRITE2("fmod:  DOMAIN error\n", 20);
 547                   }
 548                   errno = EDOM;
 549                 }
 550                 break;
 551             case 28:
 552             case 128:
 553                 /* remainder(x,0) */
 554                 exc.type = DOMAIN;
 555                 exc.name = type < 100 ? "remainder" : "remainderf";
 556                 exc.retval = zero/zero;
 557                 if (_LIB_VERSION == _POSIX_)
 558                   errno = EDOM;
 559                 else if (!matherr(&exc)) {
 560                   if (_LIB_VERSION == _SVID_) {
 561                     (void) WRITE2("remainder: DOMAIN error\n", 24);
 562                   }
 563                   errno = EDOM;
 564                 }
 565                 break;
 566             case 29:
 567             case 129:
 568                 /* acosh(x<1) */
 569                 exc.type = DOMAIN;
 570                 exc.name = type < 100 ? "acosh" : "acoshf";
 571                 exc.retval = zero/zero;
 572                 if (_LIB_VERSION == _POSIX_)
 573                   errno = EDOM;
 574                 else if (!matherr(&exc)) {
 575                   if (_LIB_VERSION == _SVID_) {
 576                     (void) WRITE2("acosh: DOMAIN error\n", 20);
 577                   }
 578                   errno = EDOM;
 579                 }
 580                 break;
 581             case 30:
 582             case 130:
 583                 /* atanh(|x|>1) */
 584                 exc.type = DOMAIN;
 585                 exc.name = type < 100 ? "atanh" : "atanhf";
 586                 exc.retval = zero/zero;
 587                 if (_LIB_VERSION == _POSIX_)
 588                   errno = EDOM;
 589                 else if (!matherr(&exc)) {
 590                   if (_LIB_VERSION == _SVID_) {
 591                     (void) WRITE2("atanh: DOMAIN error\n", 20);
 592                   }
 593                   errno = EDOM;
 594                 }
 595                 break;
 596             case 31:
 597             case 131:
 598                 /* atanh(|x|=1) */
 599                 exc.type = SING;
 600                 exc.name = type < 100 ? "atanh" : "atanhf";
 601                 exc.retval = x/zero;    /* sign(x)*inf */
 602                 if (_LIB_VERSION == _POSIX_)
 603                   errno = EDOM;
 604                 else if (!matherr(&exc)) {
 605                   if (_LIB_VERSION == _SVID_) {
 606                     (void) WRITE2("atanh: SING error\n", 18);
 607                   }
 608                   errno = EDOM;
 609                 }
 610                 break;
 611             case 32:
 612             case 132:
 613                 /* scalb overflow; SVID also returns +-HUGE_VAL */
 614                 exc.type = OVERFLOW;
 615                 exc.name = type < 100 ? "scalb" : "scalbf";
 616                 exc.retval = x > zero ? HUGE_VAL : -HUGE_VAL;
 617                 if (_LIB_VERSION == _POSIX_)
 618                   errno = ERANGE;
 619                 else if (!matherr(&exc)) {
 620                         errno = ERANGE;
 621                 }
 622                 break;
 623             case 33:
 624             case 133:
 625                 /* scalb underflow */
 626                 exc.type = UNDERFLOW;
 627                 exc.name = type < 100 ? "scalb" : "scalbf";
 628                 exc.retval = copysign(zero,x);
 629                 if (_LIB_VERSION == _POSIX_)
 630                   errno = ERANGE;
 631                 else if (!matherr(&exc)) {
 632                         errno = ERANGE;
 633                 }
 634                 break;
 635             case 34:
 636             case 134:
 637                 /* j0(|x|>X_TLOSS) */
 638                 exc.type = TLOSS;
 639                 exc.name = type < 100 ? "j0" : "j0f";
 640                 exc.retval = zero;
 641                 if (_LIB_VERSION == _POSIX_)
 642                         errno = ERANGE;
 643                 else if (!matherr(&exc)) {
 644                         if (_LIB_VERSION == _SVID_) {
 645                                 (void) WRITE2(exc.name, 2);
 646                                 (void) WRITE2(": TLOSS error\n", 14);
 647                         }
 648                         errno = ERANGE;
 649                 }
 650                 break;
 651             case 35:
 652             case 135:
 653                 /* y0(x>X_TLOSS) */
 654                 exc.type = TLOSS;
 655                 exc.name = type < 100 ? "y0" : "y0f";
 656                 exc.retval = zero;
 657                 if (_LIB_VERSION == _POSIX_)
 658                         errno = ERANGE;
 659                 else if (!matherr(&exc)) {
 660                         if (_LIB_VERSION == _SVID_) {
 661                                 (void) WRITE2(exc.name, 2);
 662                                 (void) WRITE2(": TLOSS error\n", 14);
 663                         }
 664                         errno = ERANGE;
 665                 }
 666                 break;
 667             case 36:
 668             case 136:
 669                 /* j1(|x|>X_TLOSS) */
 670                 exc.type = TLOSS;
 671                 exc.name = type < 100 ? "j1" : "j1f";
 672                 exc.retval = zero;
 673                 if (_LIB_VERSION == _POSIX_)
 674                         errno = ERANGE;
 675                 else if (!matherr(&exc)) {
 676                         if (_LIB_VERSION == _SVID_) {
 677                                 (void) WRITE2(exc.name, 2);
 678                                 (void) WRITE2(": TLOSS error\n", 14);
 679                         }
 680                         errno = ERANGE;
 681                 }
 682                 break;
 683             case 37:
 684             case 137:
 685                 /* y1(x>X_TLOSS) */
 686                 exc.type = TLOSS;
 687                 exc.name = type < 100 ? "y1" : "y1f";
 688                 exc.retval = zero;
 689                 if (_LIB_VERSION == _POSIX_)
 690                         errno = ERANGE;
 691                 else if (!matherr(&exc)) {
 692                         if (_LIB_VERSION == _SVID_) {
 693                                 (void) WRITE2(exc.name, 2);
 694                                 (void) WRITE2(": TLOSS error\n", 14);
 695                         }
 696                         errno = ERANGE;
 697                 }
 698                 break;
 699             case 38:
 700             case 138:
 701                 /* jn(|x|>X_TLOSS) */
 702                 exc.type = TLOSS;
 703                 exc.name = type < 100 ? "jn" : "jnf";
 704                 exc.retval = zero;
 705                 if (_LIB_VERSION == _POSIX_)
 706                         errno = ERANGE;
 707                 else if (!matherr(&exc)) {
 708                         if (_LIB_VERSION == _SVID_) {
 709                                 (void) WRITE2(exc.name, 2);
 710                                 (void) WRITE2(": TLOSS error\n", 14);
 711                         }
 712                         errno = ERANGE;
 713                 }
 714                 break;
 715             case 39:
 716             case 139:
 717                 /* yn(x>X_TLOSS) */
 718                 exc.type = TLOSS;
 719                 exc.name = type < 100 ? "yn" : "ynf";
 720                 exc.retval = zero;
 721                 if (_LIB_VERSION == _POSIX_)
 722                         errno = ERANGE;
 723                 else if (!matherr(&exc)) {
 724                         if (_LIB_VERSION == _SVID_) {
 725                                 (void) WRITE2(exc.name, 2);
 726                                 (void) WRITE2(": TLOSS error\n", 14);
 727                         }
 728                         errno = ERANGE;
 729                 }
 730                 break;
 731             case 40:
 732             case 140:
 733                 /* gamma(finite) overflow */
 734                 exc.type = OVERFLOW;
 735                 exc.name = type < 100 ? "gamma" : "gammaf";
 736                 if (_LIB_VERSION == _SVID_)
 737                   exc.retval = HUGE;
 738                 else
 739                   exc.retval = HUGE_VAL;
 740                 if (_LIB_VERSION == _POSIX_)
 741                   errno = ERANGE;
 742                 else if (!matherr(&exc)) {
 743                   errno = ERANGE;
 744                 }
 745                 break;
 746             case 41:
 747             case 141:
 748                 /* gamma(-integer) or gamma(0) */
 749                 exc.type = SING;
 750                 exc.name = type < 100 ? "gamma" : "gammaf";
 751                 if (_LIB_VERSION == _SVID_)
 752                   exc.retval = HUGE;
 753                 else
 754                   exc.retval = HUGE_VAL;
 755                 if (_LIB_VERSION == _POSIX_)
 756                   errno = EDOM;
 757                 else if (!matherr(&exc)) {
 758                   if (_LIB_VERSION == _SVID_) {
 759                         (void) WRITE2("gamma: SING error\n", 18);
 760                       }
 761                   errno = EDOM;
 762                 }
 763                 break;
 764             case 42:
 765             case 142:
 766                 /* pow(NaN,0.0) */
 767                 /* error only if _LIB_VERSION == _SVID_ & _XOPEN_ */
 768                 exc.type = DOMAIN;
 769                 exc.name = type < 100 ? "pow" : "powf";
 770                 exc.retval = x;
 771                 if (_LIB_VERSION == _IEEE_ ||
 772                     _LIB_VERSION == _POSIX_) exc.retval = 1.0;
 773                 else if (!matherr(&exc)) {
 774                         errno = EDOM;
 775                 }
 776                 break;
 777             case 48:
 778             case 148:
 779                 /* log2(0) */
 780                 exc.type = SING;
 781                 exc.name = type < 100 ? "log2" : "log2f";
 782                 if (_LIB_VERSION == _SVID_)
 783                   exc.retval = -HUGE;
 784                 else
 785                   exc.retval = -HUGE_VAL;
 786                 if (_LIB_VERSION == _POSIX_)
 787                   errno = ERANGE;
 788                 else if (!matherr(&exc)) {
 789                   if (_LIB_VERSION == _SVID_) {
 790                         (void) WRITE2("log2: SING error\n", 18);
 791                       }
 792                   errno = EDOM;
 793                 }
 794                 break;
 795             case 49:
 796             case 149:
 797                 /* log2(x<0) */
 798                 exc.type = DOMAIN;
 799                 exc.name = type < 100 ? "log2" : "log2f";
 800                 if (_LIB_VERSION == _SVID_)
 801                   exc.retval = -HUGE;
 802                 else
 803                   exc.retval = -HUGE_VAL;
 804                 if (_LIB_VERSION == _POSIX_)
 805                   errno = EDOM;
 806                 else if (!matherr(&exc)) {
 807                   if (_LIB_VERSION == _SVID_) {
 808                         (void) WRITE2("log2: DOMAIN error\n", 20);
 809                       }
 810                   errno = EDOM;
 811                 }
 812                 break;
 813         }
 814         return exc.retval;
 815 }