/[jscoverage]/trunk/js/src/fdlibm/k_standard.c
ViewVC logotype

Contents of /trunk/js/src/fdlibm/k_standard.c

Parent Directory Parent Directory | Revision Log Revision Log


Revision 2 - (show annotations)
Wed Aug 1 13:51:53 2007 UTC (12 years, 1 month ago) by siliconforks
File MIME type: text/plain
File size: 20792 byte(s)
Initial import.

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

  ViewVC Help
Powered by ViewVC 1.1.24