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