← Back to branch summary

~ubuntu-branches/ubuntu/precise/kompozer/precise

« back to all changes in this revision

Viewing changes to mozilla/js/src/fdlibm/k_standard.c

  • Committer: Bazaar Package Importer
  • Author(s): Anthony Yarusso
  • Date: 2007-08-27 01:11:03 UTC
  • Revision ID: james.westby@ubuntu.com-20070827011103-2jgf4s6532gqu2ka
Tags: upstream-0.7.10
Import upstream version 0.7.10

Show diffs side-by-side

added added

removed removed

Lines of Context:
mozilla/js/src/fdlibm/k_standard.c
 
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
}