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)
14static 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
36static const double zero = 0.0; /* used as const */
37#else
38static 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 * 50-- tgamma(+-0)
94 */
95
96
97double
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}
974