base/math/k_standard.c

Go to the documentation of this file.
00001 /* @(#)k_standard.c 5.1 93/09/24 */
00002 /*
00003  * ====================================================
00004  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
00005  *
00006  * Developed at SunPro, a Sun Microsystems, Inc. business.
00007  * Permission to use, copy, modify, and distribute this
00008  * software is freely granted, provided that this notice 
00009  * is preserved.
00010  * ====================================================
00011  */
00012 
00013 #if defined(LIBM_SCCS) && !defined(lint)
00014 static char rcsid[] = "$NetBSD: k_standard.c,v 1.6 1995/05/10 20:46:35 jtc Exp $";
00015 #endif
00016 
00017 #include "math.h"
00018 #include "mathP.h"
00019 #include <linux/errno.h>        /* FIXME */
00020 
00021 extern int libm_errno;
00022 
00023 extern int printk(const char *, ...);
00024 
00025 #define WRITE2(u,v) printk("%.*s",v,u)
00026 
00027 #ifdef __STDC__
00028 static const double zero = 0.0; /* used as const */
00029 #else
00030 static double zero = 0.0;   /* used as const */
00031 #endif
00032 
00033 /* 
00034  * Standard conformance (non-IEEE) on exception cases.
00035  * Mapping:
00036  *  1 -- acos(|x|>1)
00037  *  2 -- asin(|x|>1)
00038  *  3 -- atan2(+-0,+-0)
00039  *  4 -- hypot overflow
00040  *  5 -- cosh overflow
00041  *  6 -- exp overflow
00042  *  7 -- exp underflow
00043  *  8 -- y0(0)
00044  *  9 -- y0(-ve)
00045  *  10-- y1(0)
00046  *  11-- y1(-ve)
00047  *  12-- yn(0)
00048  *  13-- yn(-ve)
00049  *  14-- lgamma(finite) overflow
00050  *  15-- lgamma(-integer)
00051  *  16-- log(0)
00052  *  17-- log(x<0)
00053  *  18-- log10(0)
00054  *  19-- log10(x<0)
00055  *  20-- pow(0.0,0.0)
00056  *  21-- pow(x,y) overflow
00057  *  22-- pow(x,y) underflow
00058  *  23-- pow(0,negative) 
00059  *  24-- pow(neg,non-integral)
00060  *  25-- sinh(finite) overflow
00061  *  26-- sqrt(negative)
00062  *      27-- fmod(x,0)
00063  *      28-- remainder(x,0)
00064  *  29-- acosh(x<1)
00065  *  30-- atanh(|x|>1)
00066  *  31-- atanh(|x|=1)
00067  *  32-- scalb overflow
00068  *  33-- scalb underflow
00069  *  34-- j0(|x|>X_TLOSS)
00070  *  35-- y0(x>X_TLOSS)
00071  *  36-- j1(|x|>X_TLOSS)
00072  *  37-- y1(x>X_TLOSS)
00073  *  38-- jn(|x|>X_TLOSS, n)
00074  *  39-- yn(x>X_TLOSS, n)
00075  *  40-- gamma(finite) overflow
00076  *  41-- gamma(-integer)
00077  *  42-- pow(NaN,0.0)
00078  */
00079 
00080 
00081 #ifdef __STDC__
00082     double __kernel_standard(double x, double y, int type) 
00083 #else
00084     double __kernel_standard(x,y,type) 
00085     double x,y; int type;
00086 #endif
00087 {
00088     struct exception exc;
00089 #ifndef HUGE_VAL    /* this is the only routine that uses HUGE_VAL */ 
00090 #define HUGE_VAL inf
00091     double inf = 0.0;
00092 
00093     SET_HIGH_WORD(inf,0x7ff00000);  /* set inf to infinite */
00094 #endif
00095 
00096     exc.arg1 = x;
00097     exc.arg2 = y;
00098     switch(type) {
00099         case 1:
00100         case 101:
00101         /* acos(|x|>1) */
00102         exc.type = DOMAIN;
00103         exc.name = type < 100 ? "acos" : "acosf";
00104         exc.retval = zero;
00105         if (_LIB_VERSION == _POSIX_)
00106           libm_errno = EDOM;
00107         else if (!matherr(&exc)) {
00108           if(_LIB_VERSION == _SVID_) {
00109             (void) WRITE2("acos: DOMAIN error\n", 19);
00110           }
00111           libm_errno = EDOM;
00112         }
00113         break;
00114         case 2:
00115         case 102:
00116         /* asin(|x|>1) */
00117         exc.type = DOMAIN;
00118         exc.name = type < 100 ? "asin" : "asinf";
00119         exc.retval = zero;
00120         if(_LIB_VERSION == _POSIX_)
00121           libm_errno = EDOM;
00122         else if (!matherr(&exc)) {
00123           if(_LIB_VERSION == _SVID_) {
00124                 (void) WRITE2("asin: DOMAIN error\n", 19);
00125           }
00126           libm_errno = EDOM;
00127         }
00128         break;
00129         case 3:
00130         case 103:
00131         /* atan2(+-0,+-0) */
00132         exc.arg1 = y;
00133         exc.arg2 = x;
00134         exc.type = DOMAIN;
00135         exc.name = type < 100 ? "atan2" : "atan2f";
00136         exc.retval = zero;
00137         if(_LIB_VERSION == _POSIX_)
00138           libm_errno = EDOM;
00139         else if (!matherr(&exc)) {
00140           if(_LIB_VERSION == _SVID_) {
00141             (void) WRITE2("atan2: DOMAIN error\n", 20);
00142               }
00143           libm_errno = EDOM;
00144         }
00145         break;
00146         case 4:
00147         case 104:
00148         /* hypot(finite,finite) overflow */
00149         exc.type = OVERFLOW;
00150         exc.name = type < 100 ? "hypot" : "hypotf";
00151         if (_LIB_VERSION == _SVID_)
00152           exc.retval = HUGE;
00153         else
00154           exc.retval = HUGE_VAL;
00155         if (_LIB_VERSION == _POSIX_)
00156           libm_errno = ERANGE;
00157         else if (!matherr(&exc)) {
00158             libm_errno = ERANGE;
00159         }
00160         break;
00161         case 5:
00162         case 105:
00163         /* cosh(finite) overflow */
00164         exc.type = OVERFLOW;
00165         exc.name = type < 100 ? "cosh" : "coshf";
00166         if (_LIB_VERSION == _SVID_)
00167           exc.retval = HUGE;
00168         else
00169           exc.retval = HUGE_VAL;
00170         if (_LIB_VERSION == _POSIX_)
00171           libm_errno = ERANGE;
00172         else if (!matherr(&exc)) {
00173             libm_errno = ERANGE;
00174         }
00175         break;
00176         case 6:
00177         case 106:
00178         /* exp(finite) overflow */
00179         exc.type = OVERFLOW;
00180         exc.name = type < 100 ? "exp" : "expf";
00181         if (_LIB_VERSION == _SVID_)
00182           exc.retval = HUGE;
00183         else
00184           exc.retval = HUGE_VAL;
00185         if (_LIB_VERSION == _POSIX_)
00186           libm_errno = ERANGE;
00187         else if (!matherr(&exc)) {
00188             libm_errno = ERANGE;
00189         }
00190         break;
00191         case 7:
00192         case 107:
00193         /* exp(finite) underflow */
00194         exc.type = UNDERFLOW;
00195         exc.name = type < 100 ? "exp" : "expf";
00196         exc.retval = zero;
00197         if (_LIB_VERSION == _POSIX_)
00198           libm_errno = ERANGE;
00199         else if (!matherr(&exc)) {
00200             libm_errno = ERANGE;
00201         }
00202         break;
00203         case 8:
00204         case 108:
00205         /* y0(0) = -inf */
00206         exc.type = DOMAIN;  /* should be SING for IEEE */
00207         exc.name = type < 100 ? "y0" : "y0f";
00208         if (_LIB_VERSION == _SVID_)
00209           exc.retval = -HUGE;
00210         else
00211           exc.retval = -HUGE_VAL;
00212         if (_LIB_VERSION == _POSIX_)
00213           libm_errno = EDOM;
00214         else if (!matherr(&exc)) {
00215           if (_LIB_VERSION == _SVID_) {
00216             (void) WRITE2("y0: DOMAIN error\n", 17);
00217               }
00218           libm_errno = EDOM;
00219         }
00220         break;
00221         case 9:
00222         case 109:
00223         /* y0(x<0) = NaN */
00224         exc.type = DOMAIN;
00225         exc.name = type < 100 ? "y0" : "y0f";
00226         if (_LIB_VERSION == _SVID_)
00227           exc.retval = -HUGE;
00228         else
00229           exc.retval = -HUGE_VAL;
00230         if (_LIB_VERSION == _POSIX_)
00231           libm_errno = EDOM;
00232         else if (!matherr(&exc)) {
00233           if (_LIB_VERSION == _SVID_) {
00234             (void) WRITE2("y0: DOMAIN error\n", 17);
00235               }
00236           libm_errno = EDOM;
00237         }
00238         break;
00239         case 10:
00240         case 110:
00241         /* y1(0) = -inf */
00242         exc.type = DOMAIN;  /* should be SING for IEEE */
00243         exc.name = type < 100 ? "y1" : "y1f";
00244         if (_LIB_VERSION == _SVID_)
00245           exc.retval = -HUGE;
00246         else
00247           exc.retval = -HUGE_VAL;
00248         if (_LIB_VERSION == _POSIX_)
00249           libm_errno = EDOM;
00250         else if (!matherr(&exc)) {
00251           if (_LIB_VERSION == _SVID_) {
00252             (void) WRITE2("y1: DOMAIN error\n", 17);
00253               }
00254           libm_errno = EDOM;
00255         }
00256         break;
00257         case 11:
00258         case 111:
00259         /* y1(x<0) = NaN */
00260         exc.type = DOMAIN;
00261         exc.name = type < 100 ? "y1" : "y1f";
00262         if (_LIB_VERSION == _SVID_)
00263           exc.retval = -HUGE;
00264         else
00265           exc.retval = -HUGE_VAL;
00266         if (_LIB_VERSION == _POSIX_)
00267           libm_errno = EDOM;
00268         else if (!matherr(&exc)) {
00269           if (_LIB_VERSION == _SVID_) {
00270             (void) WRITE2("y1: DOMAIN error\n", 17);
00271               }
00272           libm_errno = EDOM;
00273         }
00274         break;
00275         case 12:
00276         case 112:
00277         /* yn(n,0) = -inf */
00278         exc.type = DOMAIN;  /* should be SING for IEEE */
00279         exc.name = type < 100 ? "yn" : "ynf";
00280         if (_LIB_VERSION == _SVID_)
00281           exc.retval = -HUGE;
00282         else
00283           exc.retval = -HUGE_VAL;
00284         if (_LIB_VERSION == _POSIX_)
00285           libm_errno = EDOM;
00286         else if (!matherr(&exc)) {
00287           if (_LIB_VERSION == _SVID_) {
00288             (void) WRITE2("yn: DOMAIN error\n", 17);
00289               }
00290           libm_errno = EDOM;
00291         }
00292         break;
00293         case 13:
00294         case 113:
00295         /* yn(x<0) = NaN */
00296         exc.type = DOMAIN;
00297         exc.name = type < 100 ? "yn" : "ynf";
00298         if (_LIB_VERSION == _SVID_)
00299           exc.retval = -HUGE;
00300         else
00301           exc.retval = -HUGE_VAL;
00302         if (_LIB_VERSION == _POSIX_)
00303           libm_errno = EDOM;
00304         else if (!matherr(&exc)) {
00305           if (_LIB_VERSION == _SVID_) {
00306             (void) WRITE2("yn: DOMAIN error\n", 17);
00307               }
00308           libm_errno = EDOM;
00309         }
00310         break;
00311         case 14:
00312         case 114:
00313         /* lgamma(finite) overflow */
00314         exc.type = OVERFLOW;
00315         exc.name = type < 100 ? "lgamma" : "lgammaf";
00316                 if (_LIB_VERSION == _SVID_)
00317                   exc.retval = HUGE;
00318                 else
00319                   exc.retval = HUGE_VAL;
00320                 if (_LIB_VERSION == _POSIX_)
00321             libm_errno = ERANGE;
00322                 else if (!matherr(&exc)) {
00323                         libm_errno = ERANGE;
00324         }
00325         break;
00326         case 15:
00327         case 115:
00328         /* lgamma(-integer) or lgamma(0) */
00329         exc.type = SING;
00330         exc.name = type < 100 ? "lgamma" : "lgammaf";
00331                 if (_LIB_VERSION == _SVID_)
00332                   exc.retval = HUGE;
00333                 else
00334                   exc.retval = HUGE_VAL;
00335         if (_LIB_VERSION == _POSIX_)
00336           libm_errno = EDOM;
00337         else if (!matherr(&exc)) {
00338           if (_LIB_VERSION == _SVID_) {
00339             (void) WRITE2("lgamma: SING error\n", 19);
00340               }
00341           libm_errno = EDOM;
00342         }
00343         break;
00344         case 16:
00345         case 116:
00346         /* log(0) */
00347         exc.type = SING;
00348         exc.name = type < 100 ? "log" : "logf";
00349         if (_LIB_VERSION == _SVID_)
00350           exc.retval = -HUGE;
00351         else
00352           exc.retval = -HUGE_VAL;
00353         if (_LIB_VERSION == _POSIX_)
00354           libm_errno = ERANGE;
00355         else if (!matherr(&exc)) {
00356           if (_LIB_VERSION == _SVID_) {
00357             (void) WRITE2("log: SING error\n", 16);
00358               }
00359           libm_errno = EDOM;
00360         }
00361         break;
00362         case 17:
00363         case 117:
00364         /* log(x<0) */
00365         exc.type = DOMAIN;
00366         exc.name = type < 100 ? "log" : "logf";
00367         if (_LIB_VERSION == _SVID_)
00368           exc.retval = -HUGE;
00369         else
00370           exc.retval = -HUGE_VAL;
00371         if (_LIB_VERSION == _POSIX_)
00372           libm_errno = EDOM;
00373         else if (!matherr(&exc)) {
00374           if (_LIB_VERSION == _SVID_) {
00375             (void) WRITE2("log: DOMAIN error\n", 18);
00376               }
00377           libm_errno = EDOM;
00378         }
00379         break;
00380         case 18:
00381         case 118:
00382         /* log10(0) */
00383         exc.type = SING;
00384         exc.name = type < 100 ? "log10" : "log10f";
00385         if (_LIB_VERSION == _SVID_)
00386           exc.retval = -HUGE;
00387         else
00388           exc.retval = -HUGE_VAL;
00389         if (_LIB_VERSION == _POSIX_)
00390           libm_errno = ERANGE;
00391         else if (!matherr(&exc)) {
00392           if (_LIB_VERSION == _SVID_) {
00393             (void) WRITE2("log10: SING error\n", 18);
00394               }
00395           libm_errno = EDOM;
00396         }
00397         break;
00398         case 19:
00399         case 119:
00400         /* log10(x<0) */
00401         exc.type = DOMAIN;
00402         exc.name = type < 100 ? "log10" : "log10f";
00403         if (_LIB_VERSION == _SVID_)
00404           exc.retval = -HUGE;
00405         else
00406           exc.retval = -HUGE_VAL;
00407         if (_LIB_VERSION == _POSIX_)
00408           libm_errno = EDOM;
00409         else if (!matherr(&exc)) {
00410           if (_LIB_VERSION == _SVID_) {
00411             (void) WRITE2("log10: DOMAIN error\n", 20);
00412               }
00413           libm_errno = EDOM;
00414         }
00415         break;
00416         case 20:
00417         case 120:
00418         /* pow(0.0,0.0) */
00419         /* error only if _LIB_VERSION == _SVID_ */
00420         exc.type = DOMAIN;
00421         exc.name = type < 100 ? "pow" : "powf";
00422         exc.retval = zero;
00423         if (_LIB_VERSION != _SVID_) exc.retval = 1.0;
00424         else if (!matherr(&exc)) {
00425             (void) WRITE2("pow(0,0): DOMAIN error\n", 23);
00426             libm_errno = EDOM;
00427         }
00428         break;
00429         case 21:
00430         case 121:
00431         /* pow(x,y) overflow */
00432         exc.type = OVERFLOW;
00433         exc.name = type < 100 ? "pow" : "powf";
00434         if (_LIB_VERSION == _SVID_) {
00435           exc.retval = HUGE;
00436           y *= 0.5;
00437           if(x<zero&&rint(y)!=y) exc.retval = -HUGE;
00438         } else {
00439           exc.retval = HUGE_VAL;
00440           y *= 0.5;
00441           if(x<zero&&rint(y)!=y) exc.retval = -HUGE_VAL;
00442         }
00443         if (_LIB_VERSION == _POSIX_)
00444           libm_errno = ERANGE;
00445         else if (!matherr(&exc)) {
00446             libm_errno = ERANGE;
00447         }
00448         break;
00449         case 22:
00450         case 122:
00451         /* pow(x,y) underflow */
00452         exc.type = UNDERFLOW;
00453         exc.name = type < 100 ? "pow" : "powf";
00454         exc.retval =  zero;
00455         if (_LIB_VERSION == _POSIX_)
00456           libm_errno = ERANGE;
00457         else if (!matherr(&exc)) {
00458             libm_errno = ERANGE;
00459         }
00460         break;
00461         case 23:
00462         case 123:
00463         /* 0**neg */
00464         exc.type = DOMAIN;
00465         exc.name = type < 100 ? "pow" : "powf";
00466         if (_LIB_VERSION == _SVID_) 
00467           exc.retval = zero;
00468         else
00469           exc.retval = -HUGE_VAL;
00470         if (_LIB_VERSION == _POSIX_)
00471           libm_errno = EDOM;
00472         else if (!matherr(&exc)) {
00473           if (_LIB_VERSION == _SVID_) {
00474             (void) WRITE2("pow(0,neg): DOMAIN error\n", 25);
00475               }
00476           libm_errno = EDOM;
00477         }
00478         break;
00479         case 24:
00480         case 124:
00481         /* neg**non-integral */
00482         exc.type = DOMAIN;
00483         exc.name = type < 100 ? "pow" : "powf";
00484         if (_LIB_VERSION == _SVID_) 
00485             exc.retval = zero;
00486         else 
00487             exc.retval = zero/zero; /* X/Open allow NaN */
00488         if (_LIB_VERSION == _POSIX_) 
00489            libm_errno = EDOM;
00490         else if (!matherr(&exc)) {
00491           if (_LIB_VERSION == _SVID_) {
00492             (void) WRITE2("neg**non-integral: DOMAIN error\n", 32);
00493               }
00494           libm_errno = EDOM;
00495         }
00496         break;
00497         case 25:
00498         case 125:
00499         /* sinh(finite) overflow */
00500         exc.type = OVERFLOW;
00501         exc.name = type < 100 ? "sinh" : "sinhf";
00502         if (_LIB_VERSION == _SVID_)
00503           exc.retval = ( (x>zero) ? HUGE : -HUGE);
00504         else
00505           exc.retval = ( (x>zero) ? HUGE_VAL : -HUGE_VAL);
00506         if (_LIB_VERSION == _POSIX_)
00507           libm_errno = ERANGE;
00508         else if (!matherr(&exc)) {
00509             libm_errno = ERANGE;
00510         }
00511         break;
00512         case 26:
00513         case 126:
00514         /* sqrt(x<0) */
00515         exc.type = DOMAIN;
00516         exc.name = type < 100 ? "sqrt" : "sqrtf";
00517         if (_LIB_VERSION == _SVID_)
00518           exc.retval = zero;
00519         else
00520           exc.retval = zero/zero;
00521         if (_LIB_VERSION == _POSIX_)
00522           libm_errno = EDOM;
00523         else if (!matherr(&exc)) {
00524           if (_LIB_VERSION == _SVID_) {
00525             (void) WRITE2("sqrt: DOMAIN error\n", 19);
00526               }
00527           libm_errno = EDOM;
00528         }
00529         break;
00530             case 27:
00531         case 127:
00532                 /* fmod(x,0) */
00533                 exc.type = DOMAIN;
00534                 exc.name = type < 100 ? "fmod" : "fmodf";
00535                 if (_LIB_VERSION == _SVID_)
00536                     exc.retval = x;
00537         else
00538             exc.retval = zero/zero;
00539                 if (_LIB_VERSION == _POSIX_)
00540                   libm_errno = EDOM;
00541                 else if (!matherr(&exc)) {
00542                   if (_LIB_VERSION == _SVID_) {
00543                     (void) WRITE2("fmod:  DOMAIN error\n", 20);
00544                   }
00545                   libm_errno = EDOM;
00546                 }
00547                 break;
00548             case 28:
00549         case 128:
00550                 /* remainder(x,0) */
00551                 exc.type = DOMAIN;
00552                 exc.name = type < 100 ? "remainder" : "remainderf";
00553                 exc.retval = zero/zero;
00554                 if (_LIB_VERSION == _POSIX_)
00555                   libm_errno = EDOM;
00556                 else if (!matherr(&exc)) {
00557                   if (_LIB_VERSION == _SVID_) {
00558                     (void) WRITE2("remainder: DOMAIN error\n", 24);
00559                   }
00560                   libm_errno = EDOM;
00561                 }
00562                 break;
00563             case 29:
00564         case 129:
00565                 /* acosh(x<1) */
00566                 exc.type = DOMAIN;
00567                 exc.name = type < 100 ? "acosh" : "acoshf";
00568                 exc.retval = zero/zero;
00569                 if (_LIB_VERSION == _POSIX_)
00570                   libm_errno = EDOM;
00571                 else if (!matherr(&exc)) {
00572                   if (_LIB_VERSION == _SVID_) {
00573                     (void) WRITE2("acosh: DOMAIN error\n", 20);
00574                   }
00575                   libm_errno = EDOM;
00576                 }
00577                 break;
00578             case 30:
00579         case 130:
00580                 /* atanh(|x|>1) */
00581                 exc.type = DOMAIN;
00582                 exc.name = type < 100 ? "atanh" : "atanhf";
00583                 exc.retval = zero/zero;
00584                 if (_LIB_VERSION == _POSIX_)
00585                   libm_errno = EDOM;
00586                 else if (!matherr(&exc)) {
00587                   if (_LIB_VERSION == _SVID_) {
00588                     (void) WRITE2("atanh: DOMAIN error\n", 20);
00589                   }
00590                   libm_errno = EDOM;
00591                 }
00592                 break;
00593             case 31:
00594         case 131:
00595                 /* atanh(|x|=1) */
00596                 exc.type = SING;
00597                 exc.name = type < 100 ? "atanh" : "atanhf";
00598         exc.retval = x/zero;    /* sign(x)*inf */
00599                 if (_LIB_VERSION == _POSIX_)
00600                   libm_errno = EDOM;
00601                 else if (!matherr(&exc)) {
00602                   if (_LIB_VERSION == _SVID_) {
00603                     (void) WRITE2("atanh: SING error\n", 18);
00604                   }
00605                   libm_errno = EDOM;
00606                 }
00607                 break;
00608         case 32:
00609         case 132:
00610         /* scalb overflow; SVID also returns +-HUGE_VAL */
00611         exc.type = OVERFLOW;
00612         exc.name = type < 100 ? "scalb" : "scalbf";
00613         exc.retval = x > zero ? HUGE_VAL : -HUGE_VAL;
00614         if (_LIB_VERSION == _POSIX_)
00615           libm_errno = ERANGE;
00616         else if (!matherr(&exc)) {
00617             libm_errno = ERANGE;
00618         }
00619         break;
00620         case 33:
00621         case 133:
00622         /* scalb underflow */
00623         exc.type = UNDERFLOW;
00624         exc.name = type < 100 ? "scalb" : "scalbf";
00625         exc.retval = copysign(zero,x);
00626         if (_LIB_VERSION == _POSIX_)
00627           libm_errno = ERANGE;
00628         else if (!matherr(&exc)) {
00629             libm_errno = ERANGE;
00630         }
00631         break;
00632         case 34:
00633         case 134:
00634         /* j0(|x|>X_TLOSS) */
00635                 exc.type = TLOSS;
00636                 exc.name = type < 100 ? "j0" : "j0f";
00637                 exc.retval = zero;
00638                 if (_LIB_VERSION == _POSIX_)
00639                         libm_errno = ERANGE;
00640                 else if (!matherr(&exc)) {
00641                         if (_LIB_VERSION == _SVID_) {
00642                                 (void) WRITE2(exc.name, 2);
00643                                 (void) WRITE2(": TLOSS error\n", 14);
00644                         }
00645                         libm_errno = ERANGE;
00646                 }        
00647         break;
00648         case 35:
00649         case 135:
00650         /* y0(x>X_TLOSS) */
00651                 exc.type = TLOSS;
00652                 exc.name = type < 100 ? "y0" : "y0f";
00653                 exc.retval = zero;
00654                 if (_LIB_VERSION == _POSIX_)
00655                         libm_errno = ERANGE;
00656                 else if (!matherr(&exc)) {
00657                         if (_LIB_VERSION == _SVID_) {
00658                                 (void) WRITE2(exc.name, 2);
00659                                 (void) WRITE2(": TLOSS error\n", 14);
00660                         }
00661                         libm_errno = ERANGE;
00662                 }        
00663         break;
00664         case 36:
00665         case 136:
00666         /* j1(|x|>X_TLOSS) */
00667                 exc.type = TLOSS;
00668                 exc.name = type < 100 ? "j1" : "j1f";
00669                 exc.retval = zero;
00670                 if (_LIB_VERSION == _POSIX_)
00671                         libm_errno = ERANGE;
00672                 else if (!matherr(&exc)) {
00673                         if (_LIB_VERSION == _SVID_) {
00674                                 (void) WRITE2(exc.name, 2);
00675                                 (void) WRITE2(": TLOSS error\n", 14);
00676                         }
00677                         libm_errno = ERANGE;
00678                 }        
00679         break;
00680         case 37:
00681         case 137:
00682         /* y1(x>X_TLOSS) */
00683                 exc.type = TLOSS;
00684                 exc.name = type < 100 ? "y1" : "y1f";
00685                 exc.retval = zero;
00686                 if (_LIB_VERSION == _POSIX_)
00687                         libm_errno = ERANGE;
00688                 else if (!matherr(&exc)) {
00689                         if (_LIB_VERSION == _SVID_) {
00690                                 (void) WRITE2(exc.name, 2);
00691                                 (void) WRITE2(": TLOSS error\n", 14);
00692                         }
00693                         libm_errno = ERANGE;
00694                 }        
00695         break;
00696         case 38:
00697         case 138:
00698         /* jn(|x|>X_TLOSS) */
00699                 exc.type = TLOSS;
00700                 exc.name = type < 100 ? "jn" : "jnf";
00701                 exc.retval = zero;
00702                 if (_LIB_VERSION == _POSIX_)
00703                         libm_errno = ERANGE;
00704                 else if (!matherr(&exc)) {
00705                         if (_LIB_VERSION == _SVID_) {
00706                                 (void) WRITE2(exc.name, 2);
00707                                 (void) WRITE2(": TLOSS error\n", 14);
00708                         }
00709                         libm_errno = ERANGE;
00710                 }        
00711         break;
00712         case 39:
00713         case 139:
00714         /* yn(x>X_TLOSS) */
00715                 exc.type = TLOSS;
00716                 exc.name = type < 100 ? "yn" : "ynf";
00717                 exc.retval = zero;
00718                 if (_LIB_VERSION == _POSIX_)
00719                         libm_errno = ERANGE;
00720                 else if (!matherr(&exc)) {
00721                         if (_LIB_VERSION == _SVID_) {
00722                                 (void) WRITE2(exc.name, 2);
00723                                 (void) WRITE2(": TLOSS error\n", 14);
00724                         }
00725                         libm_errno = ERANGE;
00726                 }        
00727         break;
00728         case 40:
00729         case 140:
00730         /* gamma(finite) overflow */
00731         exc.type = OVERFLOW;
00732         exc.name = type < 100 ? "gamma" : "gammaf";
00733                 if (_LIB_VERSION == _SVID_)
00734                   exc.retval = HUGE;
00735                 else
00736                   exc.retval = HUGE_VAL;
00737                 if (_LIB_VERSION == _POSIX_)
00738           libm_errno = ERANGE;
00739                 else if (!matherr(&exc)) {
00740                   libm_errno = ERANGE;
00741                 }
00742         break;
00743         case 41:
00744         case 141:
00745         /* gamma(-integer) or gamma(0) */
00746         exc.type = SING;
00747         exc.name = type < 100 ? "gamma" : "gammaf";
00748                 if (_LIB_VERSION == _SVID_)
00749                   exc.retval = HUGE;
00750                 else
00751                   exc.retval = HUGE_VAL;
00752         if (_LIB_VERSION == _POSIX_)
00753           libm_errno = EDOM;
00754         else if (!matherr(&exc)) {
00755           if (_LIB_VERSION == _SVID_) {
00756             (void) WRITE2("gamma: SING error\n", 18);
00757               }
00758           libm_errno = EDOM;
00759         }
00760         break;
00761         case 42:
00762         case 142:
00763         /* pow(NaN,0.0) */
00764         /* error only if _LIB_VERSION == _SVID_ & _XOPEN_ */
00765         exc.type = DOMAIN;
00766         exc.name = type < 100 ? "pow" : "powf";
00767         exc.retval = x;
00768         if (_LIB_VERSION == _IEEE_ ||
00769             _LIB_VERSION == _POSIX_) exc.retval = 1.0;
00770         else if (!matherr(&exc)) {
00771             libm_errno = EDOM;
00772         }
00773         break;
00774     }
00775     return exc.retval; 
00776 }
Generated on Tue Feb 2 17:46:05 2010 for RTAI API by  doxygen 1.4.7