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