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

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

Parent Directory Parent Directory | Revision Log Revision Log


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

1 siliconforks 2 /* -*- 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