WebSVN – Kolibri OS – Diff – /programs/develop/libraries/menuetlibc/src/libm/k_standa.c


/* Copyright (C) 1994 DJ Delorie, see COPYING.DJ for details */
/* @(#)k_standard.c 5.1 93/09/24 */
/*
 * ====================================================
 * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
 *
 * Developed at SunPro, a Sun Microsystems, Inc. business.
 * Permission to use, copy, modify, and distribute this
 * software is freely granted, provided that this notice 
 * is preserved.
 * ====================================================
 */
 
#if defined(LIBM_SCCS) && !defined(lint)
static char rcsid[] = "$Id: k_standard.c,v 1.4 1994/08/10 20:31:44 jtc Exp $";
#endif
 
#include "math.h"
#include "math_private.h"
#include 
 
#ifndef _USE_WRITE
#include 			/* fputs(), stderr */
#define	WRITE2(u,v)	fputs(u, stderr)
#else	/* !defined(_USE_WRITE) */
#include 			/* write */
#define	WRITE2(u,v)	write(2, u, v)
#undef fflush
#endif	/* !defined(_USE_WRITE) */
 
inline int fputs(const char* str, FILE* f) { return -1; }
 
#ifdef __STDC__
static const double zero = 0.0;	/* used as const */
#else
static double zero = 0.0;	/* used as const */
#endif
 
/* 
 * Standard conformance (non-IEEE) on exception cases.
 * Mapping:
 *	1 -- acos(|x|>1)
 *	2 -- asin(|x|>1)
 *	3 -- atan2(+-0,+-0)
 *	4 -- hypot overflow
 *	5 -- cosh overflow
 *	6 -- exp overflow
 *	7 -- exp underflow
 *	8 -- y0(0)
 *	9 -- y0(-ve)
 *	10-- y1(0)
 *	11-- y1(-ve)
 *	12-- yn(0)
 *	13-- yn(-ve)
 *	14-- lgamma(finite) overflow
 *	15-- lgamma(-integer)
 *	16-- log(0)
 *	17-- log(x<0)
 *	18-- log10(0)
 *	19-- log10(x<0)
 *	20-- pow(0.0,0.0)
 *	21-- pow(x,y) overflow
 *	22-- pow(x,y) underflow
 *	23-- pow(0,negative) 
 *	24-- pow(neg,non-integral)
 *	25-- sinh(finite) overflow
 *	26-- sqrt(negative)
 *      27-- fmod(x,0)
 *      28-- remainder(x,0)
 *	29-- acosh(x<1)
 *	30-- atanh(|x|>1)
 *	31-- atanh(|x|=1)
 *	32-- scalb overflow
 *	33-- scalb underflow
 *	34-- j0(|x|>X_TLOSS)
 *	35-- y0(x>X_TLOSS)
 *	36-- j1(|x|>X_TLOSS)
 *	37-- y1(x>X_TLOSS)
 *	38-- jn(|x|>X_TLOSS, n)
 *	39-- yn(x>X_TLOSS, n)
 *	40-- gamma(finite) overflow
 *	41-- gamma(-integer)
 *	42-- pow(NaN,0.0)
 */
 
 
#ifdef __STDC__
	double __kernel_standard(double x, double y, int type) 
#else
	double __kernel_standard(x,y,type) 
	double x,y; int type;
#endif
{
	struct exception exc;
#ifndef HUGE_VAL	/* this is the only routine that uses HUGE_VAL */ 
#define HUGE_VAL inf
	double inf = 0.0;
 
	SET_HIGH_WORD(inf,0x7ff00000);	/* set inf to infinite */
#endif
 
#ifdef _USE_WRITE
	(void) fflush(stdout);
#endif
	exc.arg1 = x;
	exc.arg2 = y;
	switch(type) {
	    case 1:
	    case 101:
		/* acos(|x|>1) */
		exc.type = DOMAIN;
		exc.name = type < 100 ? "acos" : "acosf";
		exc.retval = zero;
		if (_LIB_VERSION == _POSIX_)
		  errno = EDOM;
		else if (!matherr(&exc)) {
		  if(_LIB_VERSION == _SVID_) {
		    (void) WRITE2("acos: DOMAIN error\n", 19);
		  }
		  errno = EDOM;
		}
		break;
	    case 2:
	    case 102:
		/* asin(|x|>1) */
		exc.type = DOMAIN;
		exc.name = type < 100 ? "asin" : "asinf";
		exc.retval = zero;
		if(_LIB_VERSION == _POSIX_)
		  errno = EDOM;
		else if (!matherr(&exc)) {
		  if(_LIB_VERSION == _SVID_) {
		    	(void) WRITE2("asin: DOMAIN error\n", 19);
		  }
		  errno = EDOM;
		}
		break;
	    case 3:
	    case 103:
		/* atan2(+-0,+-0) */
		exc.arg1 = y;
		exc.arg2 = x;
		exc.type = DOMAIN;
		exc.name = type < 100 ? "atan2" : "atan2f";
		exc.retval = zero;
		if(_LIB_VERSION == _POSIX_)
		  errno = EDOM;
		else if (!matherr(&exc)) {
		  if(_LIB_VERSION == _SVID_) {
			(void) WRITE2("atan2: DOMAIN error\n", 20);
		      }
		  errno = EDOM;
		}
		break;
	    case 4:
	    case 104:
		/* hypot(finite,finite) overflow */
		exc.type = OVERFLOW;
		exc.name = type < 100 ? "hypot" : "hypotf";
		if (_LIB_VERSION == _SVID_)
		  exc.retval = HUGE_VAL;
		else
		  exc.retval = HUGE_VAL;
		if (_LIB_VERSION == _POSIX_)
		  errno = ERANGE;
		else if (!matherr(&exc)) {
			errno = ERANGE;
		}
		break;
	    case 5:
	    case 105:
		/* cosh(finite) overflow */
		exc.type = OVERFLOW;
		exc.name = type < 100 ? "cosh" : "coshf";
		if (_LIB_VERSION == _SVID_)
		  exc.retval = HUGE_VAL;
		else
		  exc.retval = HUGE_VAL;
		if (_LIB_VERSION == _POSIX_)
		  errno = ERANGE;
		else if (!matherr(&exc)) {
			errno = ERANGE;
		}
		break;
	    case 6:
	    case 106:
		/* exp(finite) overflow */
		exc.type = OVERFLOW;
		exc.name = type < 100 ? "exp" : "expf";
		if (_LIB_VERSION == _SVID_)
		  exc.retval = HUGE_VAL;
		else
		  exc.retval = HUGE_VAL;
		if (_LIB_VERSION == _POSIX_)
		  errno = ERANGE;
		else if (!matherr(&exc)) {
			errno = ERANGE;
		}
		break;
	    case 7:
	    case 107:
		/* exp(finite) underflow */
		exc.type = UNDERFLOW;
		exc.name = type < 100 ? "exp" : "expf";
		exc.retval = zero;
		if (_LIB_VERSION == _POSIX_)
		  errno = ERANGE;
		else if (!matherr(&exc)) {
			errno = ERANGE;
		}
		break;
	    case 8:
	    case 108:
		/* y0(0) = -inf */
		exc.type = DOMAIN;	/* should be SING for IEEE */
		exc.name = type < 100 ? "y0" : "y0f";
		if (_LIB_VERSION == _SVID_)
		  exc.retval = -HUGE_VAL;
		else
		  exc.retval = -HUGE_VAL;
		if (_LIB_VERSION == _POSIX_)
		  errno = EDOM;
		else if (!matherr(&exc)) {
		  if (_LIB_VERSION == _SVID_) {
			(void) WRITE2("y0: DOMAIN error\n", 17);
		      }
		  errno = EDOM;
		}
		break;
	    case 9:
	    case 109:
		/* y0(x<0) = NaN */
		exc.type = DOMAIN;
		exc.name = type < 100 ? "y0" : "y0f";
		if (_LIB_VERSION == _SVID_)
		  exc.retval = -HUGE_VAL;
		else
		  exc.retval = -HUGE_VAL;
		if (_LIB_VERSION == _POSIX_)
		  errno = EDOM;
		else if (!matherr(&exc)) {
		  if (_LIB_VERSION == _SVID_) {
			(void) WRITE2("y0: DOMAIN error\n", 17);
		      }
		  errno = EDOM;
		}
		break;
	    case 10:
	    case 110:
		/* y1(0) = -inf */
		exc.type = DOMAIN;	/* should be SING for IEEE */
		exc.name = type < 100 ? "y1" : "y1f";
		if (_LIB_VERSION == _SVID_)
		  exc.retval = -HUGE_VAL;
		else
		  exc.retval = -HUGE_VAL;
		if (_LIB_VERSION == _POSIX_)
		  errno = EDOM;
		else if (!matherr(&exc)) {
		  if (_LIB_VERSION == _SVID_) {
			(void) WRITE2("y1: DOMAIN error\n", 17);
		      }
		  errno = EDOM;
		}
		break;
	    case 11:
	    case 111:
		/* y1(x<0) = NaN */
		exc.type = DOMAIN;
		exc.name = type < 100 ? "y1" : "y1f";
		if (_LIB_VERSION == _SVID_)
		  exc.retval = -HUGE_VAL;
		else
		  exc.retval = -HUGE_VAL;
		if (_LIB_VERSION == _POSIX_)
		  errno = EDOM;
		else if (!matherr(&exc)) {
		  if (_LIB_VERSION == _SVID_) {
			(void) WRITE2("y1: DOMAIN error\n", 17);
		      }
		  errno = EDOM;
		}
		break;
	    case 12:
	    case 112:
		/* yn(n,0) = -inf */
		exc.type = DOMAIN;	/* should be SING for IEEE */
		exc.name = type < 100 ? "yn" : "ynf";
		if (_LIB_VERSION == _SVID_)
		  exc.retval = -HUGE_VAL;
		else
		  exc.retval = -HUGE_VAL;
		if (_LIB_VERSION == _POSIX_)
		  errno = EDOM;
		else if (!matherr(&exc)) {
		  if (_LIB_VERSION == _SVID_) {
			(void) WRITE2("yn: DOMAIN error\n", 17);
		      }
		  errno = EDOM;
		}
		break;
	    case 13:
	    case 113:
		/* yn(x<0) = NaN */
		exc.type = DOMAIN;
		exc.name = type < 100 ? "yn" : "ynf";
		if (_LIB_VERSION == _SVID_)
		  exc.retval = -HUGE_VAL;
		else
		  exc.retval = -HUGE_VAL;
		if (_LIB_VERSION == _POSIX_)
		  errno = EDOM;
		else if (!matherr(&exc)) {
		  if (_LIB_VERSION == _SVID_) {
			(void) WRITE2("yn: DOMAIN error\n", 17);
		      }
		  errno = EDOM;
		}
		break;
	    case 14:
	    case 114:
		/* lgamma(finite) overflow */
		exc.type = OVERFLOW;
		exc.name = type < 100 ? "lgamma" : "lgammaf";
                if (_LIB_VERSION == _SVID_)
                  exc.retval = HUGE_VAL;
                else
                  exc.retval = HUGE_VAL;
                if (_LIB_VERSION == _POSIX_)
			errno = ERANGE;
                else if (!matherr(&exc)) {
                        errno = ERANGE;
		}
		break;
	    case 15:
	    case 115:
		/* lgamma(-integer) or lgamma(0) */
		exc.type = SING;
		exc.name = type < 100 ? "lgamma" : "lgammaf";
                if (_LIB_VERSION == _SVID_)
                  exc.retval = HUGE_VAL;
                else
                  exc.retval = HUGE_VAL;
		if (_LIB_VERSION == _POSIX_)
		  errno = EDOM;
		else if (!matherr(&exc)) {
		  if (_LIB_VERSION == _SVID_) {
			(void) WRITE2("lgamma: SING error\n", 19);
		      }
		  errno = EDOM;
		}
		break;
	    case 16:
	    case 116:
		/* log(0) */
		exc.type = SING;
		exc.name = type < 100 ? "log" : "logf";
		if (_LIB_VERSION == _SVID_)
		  exc.retval = -HUGE_VAL;
		else
		  exc.retval = -HUGE_VAL;
		if (_LIB_VERSION == _POSIX_)
		  errno = ERANGE;
		else if (!matherr(&exc)) {
		  if (_LIB_VERSION == _SVID_) {
			(void) WRITE2("log: SING error\n", 16);
		      }
		  errno = EDOM;
		}
		break;
	    case 17:
	    case 117:
		/* log(x<0) */
		exc.type = DOMAIN;
		exc.name = type < 100 ? "log" : "logf";
		if (_LIB_VERSION == _SVID_)
		  exc.retval = -HUGE_VAL;
		else
		  exc.retval = -HUGE_VAL;
		if (_LIB_VERSION == _POSIX_)
		  errno = EDOM;
		else if (!matherr(&exc)) {
		  if (_LIB_VERSION == _SVID_) {
			(void) WRITE2("log: DOMAIN error\n", 18);
		      }
		  errno = EDOM;
		}
		break;
	    case 18:
	    case 118:
		/* log10(0) */
		exc.type = SING;
		exc.name = type < 100 ? "log10" : "log10f";
		if (_LIB_VERSION == _SVID_)
		  exc.retval = -HUGE_VAL;
		else
		  exc.retval = -HUGE_VAL;
		if (_LIB_VERSION == _POSIX_)
		  errno = ERANGE;
		else if (!matherr(&exc)) {
		  if (_LIB_VERSION == _SVID_) {
			(void) WRITE2("log10: SING error\n", 18);
		      }
		  errno = EDOM;
		}
		break;
	    case 19:
	    case 119:
		/* log10(x<0) */
		exc.type = DOMAIN;
		exc.name = type < 100 ? "log10" : "log10f";
		if (_LIB_VERSION == _SVID_)
		  exc.retval = -HUGE_VAL;
		else
		  exc.retval = -HUGE_VAL;
		if (_LIB_VERSION == _POSIX_)
		  errno = EDOM;
		else if (!matherr(&exc)) {
		  if (_LIB_VERSION == _SVID_) {
			(void) WRITE2("log10: DOMAIN error\n", 20);
		      }
		  errno = EDOM;
		}
		break;
	    case 20:
	    case 120:
		/* pow(0.0,0.0) */
		/* error only if _LIB_VERSION == _SVID_ */
		exc.type = DOMAIN;
		exc.name = type < 100 ? "pow" : "powf";
		exc.retval = zero;
		if (_LIB_VERSION != _SVID_) exc.retval = 1.0;
		else if (!matherr(&exc)) {
			(void) WRITE2("pow(0,0): DOMAIN error\n", 23);
			errno = EDOM;
		}
		break;
	    case 21:
	    case 121:
		/* pow(x,y) overflow */
		exc.type = OVERFLOW;
		exc.name = type < 100 ? "pow" : "powf";
		if (_LIB_VERSION == _SVID_) {
		  exc.retval = HUGE_VAL;
		  y *= 0.5;
		  if(x
		} else {
		  exc.retval = HUGE_VAL;
		  y *= 0.5;
		  if(x
		}
		if (_LIB_VERSION == _POSIX_)
		  errno = ERANGE;
		else if (!matherr(&exc)) {
			errno = ERANGE;
		}
		break;
	    case 22:
	    case 122:
		/* pow(x,y) underflow */
		exc.type = UNDERFLOW;
		exc.name = type < 100 ? "pow" : "powf";
		exc.retval =  zero;
		if (_LIB_VERSION == _POSIX_)
		  errno = ERANGE;
		else if (!matherr(&exc)) {
			errno = ERANGE;
		}
		break;
	    case 23:
	    case 123:
		/* 0**neg */
		exc.type = DOMAIN;
		exc.name = type < 100 ? "pow" : "powf";
		if (_LIB_VERSION == _SVID_) 
		  exc.retval = zero;
		else
		  exc.retval = -HUGE_VAL;
		if (_LIB_VERSION == _POSIX_)
		  errno = EDOM;
		else if (!matherr(&exc)) {
		  if (_LIB_VERSION == _SVID_) {
			(void) WRITE2("pow(0,neg): DOMAIN error\n", 25);
		      }
		  errno = EDOM;
		}
		break;
	    case 24:
	    case 124:
		/* neg**non-integral */
		exc.type = DOMAIN;
		exc.name = type < 100 ? "pow" : "powf";
		if (_LIB_VERSION == _SVID_) 
		    exc.retval = zero;
		else 
		    exc.retval = zero/zero;	/* X/Open allow NaN */
		if (_LIB_VERSION == _POSIX_) 
		   errno = EDOM;
		else if (!matherr(&exc)) {
		  if (_LIB_VERSION == _SVID_) {
			(void) WRITE2("neg**non-integral: DOMAIN error\n", 32);
		      }
		  errno = EDOM;
		}
		break;
	    case 25:
	    case 125:
		/* sinh(finite) overflow */
		exc.type = OVERFLOW;
		exc.name = type < 100 ? "sinh" : "sinhf";
		if (_LIB_VERSION == _SVID_)
		  exc.retval = ( (x>zero) ? HUGE_VAL: -HUGE_VAL);
		else
		  exc.retval = ( (x>zero) ? HUGE_VAL : -HUGE_VAL);
		if (_LIB_VERSION == _POSIX_)
		  errno = ERANGE;
		else if (!matherr(&exc)) {
			errno = ERANGE;
		}
		break;
	    case 26:
	    case 126:
		/* sqrt(x<0) */
		exc.type = DOMAIN;
		exc.name = type < 100 ? "sqrt" : "sqrtf";
		if (_LIB_VERSION == _SVID_)
		  exc.retval = zero;
		else
		  exc.retval = zero/zero;
		if (_LIB_VERSION == _POSIX_)
		  errno = EDOM;
		else if (!matherr(&exc)) {
		  if (_LIB_VERSION == _SVID_) {
			(void) WRITE2("sqrt: DOMAIN error\n", 19);
		      }
		  errno = EDOM;
		}
		break;
            case 27:
	    case 127:
                /* fmod(x,0) */
                exc.type = DOMAIN;
                exc.name = type < 100 ? "fmod" : "fmodf";
                if (_LIB_VERSION == _SVID_)
                    exc.retval = x;
		else
		    exc.retval = zero/zero;
                if (_LIB_VERSION == _POSIX_)
                  errno = EDOM;
                else if (!matherr(&exc)) {
                  if (_LIB_VERSION == _SVID_) {
                    (void) WRITE2("fmod:  DOMAIN error\n", 20);
                  }
                  errno = EDOM;
                }
                break;
            case 28:
	    case 128:
                /* remainder(x,0) */
                exc.type = DOMAIN;
                exc.name = type < 100 ? "remainder" : "remainderf";
                exc.retval = zero/zero;
                if (_LIB_VERSION == _POSIX_)
                  errno = EDOM;
                else if (!matherr(&exc)) {
                  if (_LIB_VERSION == _SVID_) {
                    (void) WRITE2("remainder: DOMAIN error\n", 24);
                  }
                  errno = EDOM;
                }
                break;
            case 29:
	    case 129:
                /* acosh(x<1) */
                exc.type = DOMAIN;
                exc.name = type < 100 ? "acosh" : "acoshf";
                exc.retval = zero/zero;
                if (_LIB_VERSION == _POSIX_)
                  errno = EDOM;
                else if (!matherr(&exc)) {
                  if (_LIB_VERSION == _SVID_) {
                    (void) WRITE2("acosh: DOMAIN error\n", 20);
                  }
                  errno = EDOM;
                }
                break;
            case 30:
	    case 130:
                /* atanh(|x|>1) */
                exc.type = DOMAIN;
                exc.name = type < 100 ? "atanh" : "atanhf";
                exc.retval = zero/zero;
                if (_LIB_VERSION == _POSIX_)
                  errno = EDOM;
                else if (!matherr(&exc)) {
                  if (_LIB_VERSION == _SVID_) {
                    (void) WRITE2("atanh: DOMAIN error\n", 20);
                  }
                  errno = EDOM;
                }
                break;
            case 31:
	    case 131:
                /* atanh(|x|=1) */
                exc.type = SING;
                exc.name = type < 100 ? "atanh" : "atanhf";
		exc.retval = x/zero;	/* sign(x)*inf */
                if (_LIB_VERSION == _POSIX_)
                  errno = EDOM;
                else if (!matherr(&exc)) {
                  if (_LIB_VERSION == _SVID_) {
                    (void) WRITE2("atanh: SING error\n", 18);
                  }
                  errno = EDOM;
                }
                break;
	    case 32:
	    case 132:
		/* scalb overflow; SVID also returns +-HUGE_VAL */
		exc.type = OVERFLOW;
		exc.name = type < 100 ? "scalb" : "scalbf";
		exc.retval = x > zero ? HUGE_VAL : -HUGE_VAL;
		if (_LIB_VERSION == _POSIX_)
		  errno = ERANGE;
		else if (!matherr(&exc)) {
			errno = ERANGE;
		}
		break;
	    case 33:
	    case 133:
		/* scalb underflow */
		exc.type = UNDERFLOW;
		exc.name = type < 100 ? "scalb" : "scalbf";
		exc.retval = copysign(zero,x);
		if (_LIB_VERSION == _POSIX_)
		  errno = ERANGE;
		else if (!matherr(&exc)) {
			errno = ERANGE;
		}
		break;
	    case 34:
	    case 134:
		/* j0(|x|>X_TLOSS) */
                exc.type = TLOSS;
                exc.name = type < 100 ? "j0" : "j0f";
                exc.retval = zero;
                if (_LIB_VERSION == _POSIX_)
                        errno = ERANGE;
                else if (!matherr(&exc)) {
                        if (_LIB_VERSION == _SVID_) {
                                (void) WRITE2(exc.name, 2);
                                (void) WRITE2(": TLOSS error\n", 14);
                        }
                        errno = ERANGE;
                }        
		break;
	    case 35:
	    case 135:
		/* y0(x>X_TLOSS) */
                exc.type = TLOSS;
                exc.name = type < 100 ? "y0" : "y0f";
                exc.retval = zero;
                if (_LIB_VERSION == _POSIX_)
                        errno = ERANGE;
                else if (!matherr(&exc)) {
                        if (_LIB_VERSION == _SVID_) {
                                (void) WRITE2(exc.name, 2);
                                (void) WRITE2(": TLOSS error\n", 14);
                        }
                        errno = ERANGE;
                }        
		break;
	    case 36:
	    case 136:
		/* j1(|x|>X_TLOSS) */
                exc.type = TLOSS;
                exc.name = type < 100 ? "j1" : "j1f";
                exc.retval = zero;
                if (_LIB_VERSION == _POSIX_)
                        errno = ERANGE;
                else if (!matherr(&exc)) {
                        if (_LIB_VERSION == _SVID_) {
                                (void) WRITE2(exc.name, 2);
                                (void) WRITE2(": TLOSS error\n", 14);
                        }
                        errno = ERANGE;
                }        
		break;
	    case 37:
	    case 137:
		/* y1(x>X_TLOSS) */
                exc.type = TLOSS;
                exc.name = type < 100 ? "y1" : "y1f";
                exc.retval = zero;
                if (_LIB_VERSION == _POSIX_)
                        errno = ERANGE;
                else if (!matherr(&exc)) {
                        if (_LIB_VERSION == _SVID_) {
                                (void) WRITE2(exc.name, 2);
                                (void) WRITE2(": TLOSS error\n", 14);
                        }
                        errno = ERANGE;
                }        
		break;
	    case 38:
	    case 138:
		/* jn(|x|>X_TLOSS) */
                exc.type = TLOSS;
                exc.name = type < 100 ? "jn" : "jnf";
                exc.retval = zero;
                if (_LIB_VERSION == _POSIX_)
                        errno = ERANGE;
                else if (!matherr(&exc)) {
                        if (_LIB_VERSION == _SVID_) {
                                (void) WRITE2(exc.name, 2);
                                (void) WRITE2(": TLOSS error\n", 14);
                        }
                        errno = ERANGE;
                }        
		break;
	    case 39:
	    case 139:
		/* yn(x>X_TLOSS) */
                exc.type = TLOSS;
                exc.name = type < 100 ? "yn" : "ynf";
                exc.retval = zero;
                if (_LIB_VERSION == _POSIX_)
                        errno = ERANGE;
                else if (!matherr(&exc)) {
                        if (_LIB_VERSION == _SVID_) {
                                (void) WRITE2(exc.name, 2);
                                (void) WRITE2(": TLOSS error\n", 14);
                        }
                        errno = ERANGE;
                }        
		break;
	    case 40:
	    case 140:
		/* gamma(finite) overflow */
		exc.type = OVERFLOW;
		exc.name = type < 100 ? "gamma" : "gammaf";
                if (_LIB_VERSION == _SVID_)
                  exc.retval = HUGE_VAL;
                else
                  exc.retval = HUGE_VAL;
                if (_LIB_VERSION == _POSIX_)
		  errno = ERANGE;
                else if (!matherr(&exc)) {
                  errno = ERANGE;
                }
		break;
	    case 41:
	    case 141:
		/* gamma(-integer) or gamma(0) */
		exc.type = SING;
		exc.name = type < 100 ? "gamma" : "gammaf";
                if (_LIB_VERSION == _SVID_)
                  exc.retval = HUGE_VAL;
                else
                  exc.retval = HUGE_VAL;
		if (_LIB_VERSION == _POSIX_)
		  errno = EDOM;
		else if (!matherr(&exc)) {
		  if (_LIB_VERSION == _SVID_) {
			(void) WRITE2("gamma: SING error\n", 18);
		      }
		  errno = EDOM;
		}
		break;
	    case 42:
	    case 142:
		/* pow(NaN,0.0) */
		/* error only if _LIB_VERSION == _SVID_ & _XOPEN_ */
		exc.type = DOMAIN;
		exc.name = type < 100 ? "pow" : "powf";
		exc.retval = x;
		if (_LIB_VERSION == _IEEE_ ||
		    _LIB_VERSION == _POSIX_) exc.retval = 1.0;
		else if (!matherr(&exc)) {
			errno = EDOM;
		}
		break;
	}
	return exc.retval; 
}
>
>
>

Rev 4973	Rev 5098
1	/* Copyright (C) 1994 DJ Delorie, see COPYING.DJ for details */	1	/* Copyright (C) 1994 DJ Delorie, see COPYING.DJ for details */
2	/* @(#)k_standard.c 5.1 93/09/24 */	2	/* @(#)k_standard.c 5.1 93/09/24 */
3	/*	3	/*
4	* ====================================================	4	* ====================================================
5	* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.	5	* Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
6	*	6	*
7	* Developed at SunPro, a Sun Microsystems, Inc. business.	7	* Developed at SunPro, a Sun Microsystems, Inc. business.
8	* Permission to use, copy, modify, and distribute this	8	* Permission to use, copy, modify, and distribute this
9	* software is freely granted, provided that this notice	9	* software is freely granted, provided that this notice
10	* is preserved.	10	* is preserved.
11	* ====================================================	11	* ====================================================
12	*/	12	*/
13		13
14	#if defined(LIBM_SCCS) && !defined(lint)	14	#if defined(LIBM_SCCS) && !defined(lint)
15	static char rcsid[] = "$Id: k_standard.c,v 1.4 1994/08/10 20:31:44 jtc Exp $";	15	static char rcsid[] = "$Id: k_standard.c,v 1.4 1994/08/10 20:31:44 jtc Exp $";
16	#endif	16	#endif
17		17
18	#include "math.h"	18	#include "math.h"
19	#include "math_private.h"	19	#include "math_private.h"
20	#include	20	#include
21		21
22	#ifndef _USE_WRITE	22	#ifndef _USE_WRITE
23	#include /* fputs(), stderr */	23	#include /* fputs(), stderr */
24	#define WRITE2(u,v) fputs(u, stderr)	24	#define WRITE2(u,v) fputs(u, stderr)
25	#else /* !defined(_USE_WRITE) */	25	#else /* !defined(_USE_WRITE) */
26	#include /* write */	26	#include /* write */
27	#define WRITE2(u,v) write(2, u, v)	27	#define WRITE2(u,v) write(2, u, v)
28	#undef fflush	28	#undef fflush
29	#endif /* !defined(_USE_WRITE) */	29	#endif /* !defined(_USE_WRITE) */
-		30
-		31	inline int fputs(const char* str, FILE* f) { return -1; }
30		32
31	#ifdef __STDC__	33	#ifdef __STDC__
32	static const double zero = 0.0; /* used as const */	34	static const double zero = 0.0; /* used as const */
33	#else	35	#else
34	static double zero = 0.0; /* used as const */	36	static double zero = 0.0; /* used as const */
35	#endif	37	#endif
36		38
37	/*	39	/*
38	* Standard conformance (non-IEEE) on exception cases.	40	* Standard conformance (non-IEEE) on exception cases.
39	* Mapping:	41	* Mapping:
40	* 1 -- acos(\|x\|>1)	42	* 1 -- acos(\|x\|>1)
41	* 2 -- asin(\|x\|>1)	43	* 2 -- asin(\|x\|>1)
42	* 3 -- atan2(+-0,+-0)	44	* 3 -- atan2(+-0,+-0)
43	* 4 -- hypot overflow	45	* 4 -- hypot overflow
44	* 5 -- cosh overflow	46	* 5 -- cosh overflow
45	* 6 -- exp overflow	47	* 6 -- exp overflow
46	* 7 -- exp underflow	48	* 7 -- exp underflow
47	* 8 -- y0(0)	49	* 8 -- y0(0)
48	* 9 -- y0(-ve)	50	* 9 -- y0(-ve)
49	* 10-- y1(0)	51	* 10-- y1(0)
50	* 11-- y1(-ve)	52	* 11-- y1(-ve)
51	* 12-- yn(0)	53	* 12-- yn(0)
52	* 13-- yn(-ve)	54	* 13-- yn(-ve)
53	* 14-- lgamma(finite) overflow	55	* 14-- lgamma(finite) overflow
54	* 15-- lgamma(-integer)	56	* 15-- lgamma(-integer)
55	* 16-- log(0)	57	* 16-- log(0)
56	* 17-- log(x<0)	58	* 17-- log(x<0)
57	* 18-- log10(0)	59	* 18-- log10(0)
58	* 19-- log10(x<0)	60	* 19-- log10(x<0)
59	* 20-- pow(0.0,0.0)	61	* 20-- pow(0.0,0.0)
60	* 21-- pow(x,y) overflow	62	* 21-- pow(x,y) overflow
61	* 22-- pow(x,y) underflow	63	* 22-- pow(x,y) underflow
62	* 23-- pow(0,negative)	64	* 23-- pow(0,negative)
63	* 24-- pow(neg,non-integral)	65	* 24-- pow(neg,non-integral)
64	* 25-- sinh(finite) overflow	66	* 25-- sinh(finite) overflow
65	* 26-- sqrt(negative)	67	* 26-- sqrt(negative)
66	* 27-- fmod(x,0)	68	* 27-- fmod(x,0)
67	* 28-- remainder(x,0)	69	* 28-- remainder(x,0)
68	* 29-- acosh(x<1)	70	* 29-- acosh(x<1)
69	* 30-- atanh(\|x\|>1)	71	* 30-- atanh(\|x\|>1)
70	* 31-- atanh(\|x\|=1)	72	* 31-- atanh(\|x\|=1)
71	* 32-- scalb overflow	73	* 32-- scalb overflow
72	* 33-- scalb underflow	74	* 33-- scalb underflow
73	* 34-- j0(\|x\|>X_TLOSS)	75	* 34-- j0(\|x\|>X_TLOSS)
74	* 35-- y0(x>X_TLOSS)	76	* 35-- y0(x>X_TLOSS)
75	* 36-- j1(\|x\|>X_TLOSS)	77	* 36-- j1(\|x\|>X_TLOSS)
76	* 37-- y1(x>X_TLOSS)	78	* 37-- y1(x>X_TLOSS)
77	* 38-- jn(\|x\|>X_TLOSS, n)	79	* 38-- jn(\|x\|>X_TLOSS, n)
78	* 39-- yn(x>X_TLOSS, n)	80	* 39-- yn(x>X_TLOSS, n)
79	* 40-- gamma(finite) overflow	81	* 40-- gamma(finite) overflow
80	* 41-- gamma(-integer)	82	* 41-- gamma(-integer)
81	* 42-- pow(NaN,0.0)	83	* 42-- pow(NaN,0.0)
82	*/	84	*/
83		85
84		86
85	#ifdef __STDC__	87	#ifdef __STDC__
86	double __kernel_standard(double x, double y, int type)	88	double __kernel_standard(double x, double y, int type)
87	#else	89	#else
88	double __kernel_standard(x,y,type)	90	double __kernel_standard(x,y,type)
89	double x,y; int type;	91	double x,y; int type;
90	#endif	92	#endif
91	{	93	{
92	struct exception exc;	94	struct exception exc;
93	#ifndef HUGE_VAL /* this is the only routine that uses HUGE_VAL */	95	#ifndef HUGE_VAL /* this is the only routine that uses HUGE_VAL */
94	#define HUGE_VAL inf	96	#define HUGE_VAL inf
95	double inf = 0.0;	97	double inf = 0.0;
96		98
97	SET_HIGH_WORD(inf,0x7ff00000); /* set inf to infinite */	99	SET_HIGH_WORD(inf,0x7ff00000); /* set inf to infinite */
98	#endif	100	#endif
99		101
100	#ifdef _USE_WRITE	102	#ifdef _USE_WRITE
101	(void) fflush(stdout);	103	(void) fflush(stdout);
102	#endif	104	#endif
103	exc.arg1 = x;	105	exc.arg1 = x;
104	exc.arg2 = y;	106	exc.arg2 = y;
105	switch(type) {	107	switch(type) {
106	case 1:	108	case 1:
107	case 101:	109	case 101:
108	/* acos(\|x\|>1) */	110	/* acos(\|x\|>1) */
109	exc.type = DOMAIN;	111	exc.type = DOMAIN;
110	exc.name = type < 100 ? "acos" : "acosf";	112	exc.name = type < 100 ? "acos" : "acosf";
111	exc.retval = zero;	113	exc.retval = zero;
112	if (_LIB_VERSION == _POSIX_)	114	if (_LIB_VERSION == _POSIX_)
113	errno = EDOM;	115	errno = EDOM;
114	else if (!matherr(&exc)) {	116	else if (!matherr(&exc)) {
115	if(_LIB_VERSION == _SVID_) {	117	if(_LIB_VERSION == _SVID_) {
116	(void) WRITE2("acos: DOMAIN error\n", 19);	118	(void) WRITE2("acos: DOMAIN error\n", 19);
117	}	119	}
118	errno = EDOM;	120	errno = EDOM;
119	}	121	}
120	break;	122	break;
121	case 2:	123	case 2:
122	case 102:	124	case 102:
123	/* asin(\|x\|>1) */	125	/* asin(\|x\|>1) */
124	exc.type = DOMAIN;	126	exc.type = DOMAIN;
125	exc.name = type < 100 ? "asin" : "asinf";	127	exc.name = type < 100 ? "asin" : "asinf";
126	exc.retval = zero;	128	exc.retval = zero;
127	if(_LIB_VERSION == _POSIX_)	129	if(_LIB_VERSION == _POSIX_)
128	errno = EDOM;	130	errno = EDOM;
129	else if (!matherr(&exc)) {	131	else if (!matherr(&exc)) {
130	if(_LIB_VERSION == _SVID_) {	132	if(_LIB_VERSION == _SVID_) {
131	(void) WRITE2("asin: DOMAIN error\n", 19);	133	(void) WRITE2("asin: DOMAIN error\n", 19);
132	}	134	}
133	errno = EDOM;	135	errno = EDOM;
134	}	136	}
135	break;	137	break;
136	case 3:	138	case 3:
137	case 103:	139	case 103:
138	/* atan2(+-0,+-0) */	140	/* atan2(+-0,+-0) */
139	exc.arg1 = y;	141	exc.arg1 = y;
140	exc.arg2 = x;	142	exc.arg2 = x;
141	exc.type = DOMAIN;	143	exc.type = DOMAIN;
142	exc.name = type < 100 ? "atan2" : "atan2f";	144	exc.name = type < 100 ? "atan2" : "atan2f";
143	exc.retval = zero;	145	exc.retval = zero;
144	if(_LIB_VERSION == _POSIX_)	146	if(_LIB_VERSION == _POSIX_)
145	errno = EDOM;	147	errno = EDOM;
146	else if (!matherr(&exc)) {	148	else if (!matherr(&exc)) {
147	if(_LIB_VERSION == _SVID_) {	149	if(_LIB_VERSION == _SVID_) {
148	(void) WRITE2("atan2: DOMAIN error\n", 20);	150	(void) WRITE2("atan2: DOMAIN error\n", 20);
149	}	151	}
150	errno = EDOM;	152	errno = EDOM;
151	}	153	}
152	break;	154	break;
153	case 4:	155	case 4:
154	case 104:	156	case 104:
155	/* hypot(finite,finite) overflow */	157	/* hypot(finite,finite) overflow */
156	exc.type = OVERFLOW;	158	exc.type = OVERFLOW;
157	exc.name = type < 100 ? "hypot" : "hypotf";	159	exc.name = type < 100 ? "hypot" : "hypotf";
158	if (_LIB_VERSION == _SVID_)	160	if (_LIB_VERSION == _SVID_)
159	exc.retval = HUGE_VAL;	161	exc.retval = HUGE_VAL;
160	else	162	else
161	exc.retval = HUGE_VAL;	163	exc.retval = HUGE_VAL;
162	if (_LIB_VERSION == _POSIX_)	164	if (_LIB_VERSION == _POSIX_)
163	errno = ERANGE;	165	errno = ERANGE;
164	else if (!matherr(&exc)) {	166	else if (!matherr(&exc)) {
165	errno = ERANGE;	167	errno = ERANGE;
166	}	168	}
167	break;	169	break;
168	case 5:	170	case 5:
169	case 105:	171	case 105:
170	/* cosh(finite) overflow */	172	/* cosh(finite) overflow */
171	exc.type = OVERFLOW;	173	exc.type = OVERFLOW;
172	exc.name = type < 100 ? "cosh" : "coshf";	174	exc.name = type < 100 ? "cosh" : "coshf";
173	if (_LIB_VERSION == _SVID_)	175	if (_LIB_VERSION == _SVID_)
174	exc.retval = HUGE_VAL;	176	exc.retval = HUGE_VAL;
175	else	177	else
176	exc.retval = HUGE_VAL;	178	exc.retval = HUGE_VAL;
177	if (_LIB_VERSION == _POSIX_)	179	if (_LIB_VERSION == _POSIX_)
178	errno = ERANGE;	180	errno = ERANGE;
179	else if (!matherr(&exc)) {	181	else if (!matherr(&exc)) {
180	errno = ERANGE;	182	errno = ERANGE;
181	}	183	}
182	break;	184	break;
183	case 6:	185	case 6:
184	case 106:	186	case 106:
185	/* exp(finite) overflow */	187	/* exp(finite) overflow */
186	exc.type = OVERFLOW;	188	exc.type = OVERFLOW;
187	exc.name = type < 100 ? "exp" : "expf";	189	exc.name = type < 100 ? "exp" : "expf";
188	if (_LIB_VERSION == _SVID_)	190	if (_LIB_VERSION == _SVID_)
189	exc.retval = HUGE_VAL;	191	exc.retval = HUGE_VAL;
190	else	192	else
191	exc.retval = HUGE_VAL;	193	exc.retval = HUGE_VAL;
192	if (_LIB_VERSION == _POSIX_)	194	if (_LIB_VERSION == _POSIX_)
193	errno = ERANGE;	195	errno = ERANGE;
194	else if (!matherr(&exc)) {	196	else if (!matherr(&exc)) {
195	errno = ERANGE;	197	errno = ERANGE;
196	}	198	}
197	break;	199	break;
198	case 7:	200	case 7:
199	case 107:	201	case 107:
200	/* exp(finite) underflow */	202	/* exp(finite) underflow */
201	exc.type = UNDERFLOW;	203	exc.type = UNDERFLOW;
202	exc.name = type < 100 ? "exp" : "expf";	204	exc.name = type < 100 ? "exp" : "expf";
203	exc.retval = zero;	205	exc.retval = zero;
204	if (_LIB_VERSION == _POSIX_)	206	if (_LIB_VERSION == _POSIX_)
205	errno = ERANGE;	207	errno = ERANGE;
206	else if (!matherr(&exc)) {	208	else if (!matherr(&exc)) {
207	errno = ERANGE;	209	errno = ERANGE;
208	}	210	}
209	break;	211	break;
210	case 8:	212	case 8:
211	case 108:	213	case 108:
212	/* y0(0) = -inf */	214	/* y0(0) = -inf */
213	exc.type = DOMAIN; /* should be SING for IEEE */	215	exc.type = DOMAIN; /* should be SING for IEEE */
214	exc.name = type < 100 ? "y0" : "y0f";	216	exc.name = type < 100 ? "y0" : "y0f";
215	if (_LIB_VERSION == _SVID_)	217	if (_LIB_VERSION == _SVID_)
216	exc.retval = -HUGE_VAL;	218	exc.retval = -HUGE_VAL;
217	else	219	else
218	exc.retval = -HUGE_VAL;	220	exc.retval = -HUGE_VAL;
219	if (_LIB_VERSION == _POSIX_)	221	if (_LIB_VERSION == _POSIX_)
220	errno = EDOM;	222	errno = EDOM;
221	else if (!matherr(&exc)) {	223	else if (!matherr(&exc)) {
222	if (_LIB_VERSION == _SVID_) {	224	if (_LIB_VERSION == _SVID_) {
223	(void) WRITE2("y0: DOMAIN error\n", 17);	225	(void) WRITE2("y0: DOMAIN error\n", 17);
224	}	226	}
225	errno = EDOM;	227	errno = EDOM;
226	}	228	}
227	break;	229	break;
228	case 9:	230	case 9:
229	case 109:	231	case 109:
230	/* y0(x<0) = NaN */	232	/* y0(x<0) = NaN */
231	exc.type = DOMAIN;	233	exc.type = DOMAIN;
232	exc.name = type < 100 ? "y0" : "y0f";	234	exc.name = type < 100 ? "y0" : "y0f";
233	if (_LIB_VERSION == _SVID_)	235	if (_LIB_VERSION == _SVID_)
234	exc.retval = -HUGE_VAL;	236	exc.retval = -HUGE_VAL;
235	else	237	else
236	exc.retval = -HUGE_VAL;	238	exc.retval = -HUGE_VAL;
237	if (_LIB_VERSION == _POSIX_)	239	if (_LIB_VERSION == _POSIX_)
238	errno = EDOM;	240	errno = EDOM;
239	else if (!matherr(&exc)) {	241	else if (!matherr(&exc)) {
240	if (_LIB_VERSION == _SVID_) {	242	if (_LIB_VERSION == _SVID_) {
241	(void) WRITE2("y0: DOMAIN error\n", 17);	243	(void) WRITE2("y0: DOMAIN error\n", 17);
242	}	244	}
243	errno = EDOM;	245	errno = EDOM;
244	}	246	}
245	break;	247	break;
246	case 10:	248	case 10:
247	case 110:	249	case 110:
248	/* y1(0) = -inf */	250	/* y1(0) = -inf */
249	exc.type = DOMAIN; /* should be SING for IEEE */	251	exc.type = DOMAIN; /* should be SING for IEEE */
250	exc.name = type < 100 ? "y1" : "y1f";	252	exc.name = type < 100 ? "y1" : "y1f";
251	if (_LIB_VERSION == _SVID_)	253	if (_LIB_VERSION == _SVID_)
252	exc.retval = -HUGE_VAL;	254	exc.retval = -HUGE_VAL;
253	else	255	else
254	exc.retval = -HUGE_VAL;	256	exc.retval = -HUGE_VAL;
255	if (_LIB_VERSION == _POSIX_)	257	if (_LIB_VERSION == _POSIX_)
256	errno = EDOM;	258	errno = EDOM;
257	else if (!matherr(&exc)) {	259	else if (!matherr(&exc)) {
258	if (_LIB_VERSION == _SVID_) {	260	if (_LIB_VERSION == _SVID_) {
259	(void) WRITE2("y1: DOMAIN error\n", 17);	261	(void) WRITE2("y1: DOMAIN error\n", 17);
260	}	262	}
261	errno = EDOM;	263	errno = EDOM;
262	}	264	}
263	break;	265	break;
264	case 11:	266	case 11:
265	case 111:	267	case 111:
266	/* y1(x<0) = NaN */	268	/* y1(x<0) = NaN */
267	exc.type = DOMAIN;	269	exc.type = DOMAIN;
268	exc.name = type < 100 ? "y1" : "y1f";	270	exc.name = type < 100 ? "y1" : "y1f";
269	if (_LIB_VERSION == _SVID_)	271	if (_LIB_VERSION == _SVID_)
270	exc.retval = -HUGE_VAL;	272	exc.retval = -HUGE_VAL;
271	else	273	else
272	exc.retval = -HUGE_VAL;	274	exc.retval = -HUGE_VAL;
273	if (_LIB_VERSION == _POSIX_)	275	if (_LIB_VERSION == _POSIX_)
274	errno = EDOM;	276	errno = EDOM;
275	else if (!matherr(&exc)) {	277	else if (!matherr(&exc)) {
276	if (_LIB_VERSION == _SVID_) {	278	if (_LIB_VERSION == _SVID_) {
277	(void) WRITE2("y1: DOMAIN error\n", 17);	279	(void) WRITE2("y1: DOMAIN error\n", 17);
278	}	280	}
279	errno = EDOM;	281	errno = EDOM;
280	}	282	}
281	break;	283	break;
282	case 12:	284	case 12:
283	case 112:	285	case 112:
284	/* yn(n,0) = -inf */	286	/* yn(n,0) = -inf */
285	exc.type = DOMAIN; /* should be SING for IEEE */	287	exc.type = DOMAIN; /* should be SING for IEEE */
286	exc.name = type < 100 ? "yn" : "ynf";	288	exc.name = type < 100 ? "yn" : "ynf";
287	if (_LIB_VERSION == _SVID_)	289	if (_LIB_VERSION == _SVID_)
288	exc.retval = -HUGE_VAL;	290	exc.retval = -HUGE_VAL;
289	else	291	else
290	exc.retval = -HUGE_VAL;	292	exc.retval = -HUGE_VAL;
291	if (_LIB_VERSION == _POSIX_)	293	if (_LIB_VERSION == _POSIX_)
292	errno = EDOM;	294	errno = EDOM;
293	else if (!matherr(&exc)) {	295	else if (!matherr(&exc)) {
294	if (_LIB_VERSION == _SVID_) {	296	if (_LIB_VERSION == _SVID_) {
295	(void) WRITE2("yn: DOMAIN error\n", 17);	297	(void) WRITE2("yn: DOMAIN error\n", 17);
296	}	298	}
297	errno = EDOM;	299	errno = EDOM;
298	}	300	}
299	break;	301	break;
300	case 13:	302	case 13:
301	case 113:	303	case 113:
302	/* yn(x<0) = NaN */	304	/* yn(x<0) = NaN */
303	exc.type = DOMAIN;	305	exc.type = DOMAIN;
304	exc.name = type < 100 ? "yn" : "ynf";	306	exc.name = type < 100 ? "yn" : "ynf";
305	if (_LIB_VERSION == _SVID_)	307	if (_LIB_VERSION == _SVID_)
306	exc.retval = -HUGE_VAL;	308	exc.retval = -HUGE_VAL;
307	else	309	else
308	exc.retval = -HUGE_VAL;	310	exc.retval = -HUGE_VAL;
309	if (_LIB_VERSION == _POSIX_)	311	if (_LIB_VERSION == _POSIX_)
310	errno = EDOM;	312	errno = EDOM;
311	else if (!matherr(&exc)) {	313	else if (!matherr(&exc)) {
312	if (_LIB_VERSION == _SVID_) {	314	if (_LIB_VERSION == _SVID_) {
313	(void) WRITE2("yn: DOMAIN error\n", 17);	315	(void) WRITE2("yn: DOMAIN error\n", 17);
314	}	316	}
315	errno = EDOM;	317	errno = EDOM;
316	}	318	}
317	break;	319	break;
318	case 14:	320	case 14:
319	case 114:	321	case 114:
320	/* lgamma(finite) overflow */	322	/* lgamma(finite) overflow */
321	exc.type = OVERFLOW;	323	exc.type = OVERFLOW;
322	exc.name = type < 100 ? "lgamma" : "lgammaf";	324	exc.name = type < 100 ? "lgamma" : "lgammaf";
323	if (_LIB_VERSION == _SVID_)	325	if (_LIB_VERSION == _SVID_)
324	exc.retval = HUGE_VAL;	326	exc.retval = HUGE_VAL;
325	else	327	else
326	exc.retval = HUGE_VAL;	328	exc.retval = HUGE_VAL;
327	if (_LIB_VERSION == _POSIX_)	329	if (_LIB_VERSION == _POSIX_)
328	errno = ERANGE;	330	errno = ERANGE;
329	else if (!matherr(&exc)) {	331	else if (!matherr(&exc)) {
330	errno = ERANGE;	332	errno = ERANGE;
331	}	333	}
332	break;	334	break;
333	case 15:	335	case 15:
334	case 115:	336	case 115:
335	/* lgamma(-integer) or lgamma(0) */	337	/* lgamma(-integer) or lgamma(0) */
336	exc.type = SING;	338	exc.type = SING;
337	exc.name = type < 100 ? "lgamma" : "lgammaf";	339	exc.name = type < 100 ? "lgamma" : "lgammaf";
338	if (_LIB_VERSION == _SVID_)	340	if (_LIB_VERSION == _SVID_)
339	exc.retval = HUGE_VAL;	341	exc.retval = HUGE_VAL;
340	else	342	else
341	exc.retval = HUGE_VAL;	343	exc.retval = HUGE_VAL;
342	if (_LIB_VERSION == _POSIX_)	344	if (_LIB_VERSION == _POSIX_)
343	errno = EDOM;	345	errno = EDOM;
344	else if (!matherr(&exc)) {	346	else if (!matherr(&exc)) {
345	if (_LIB_VERSION == _SVID_) {	347	if (_LIB_VERSION == _SVID_) {
346	(void) WRITE2("lgamma: SING error\n", 19);	348	(void) WRITE2("lgamma: SING error\n", 19);
347	}	349	}
348	errno = EDOM;	350	errno = EDOM;
349	}	351	}
350	break;	352	break;
351	case 16:	353	case 16:
352	case 116:	354	case 116:
353	/* log(0) */	355	/* log(0) */
354	exc.type = SING;	356	exc.type = SING;
355	exc.name = type < 100 ? "log" : "logf";	357	exc.name = type < 100 ? "log" : "logf";
356	if (_LIB_VERSION == _SVID_)	358	if (_LIB_VERSION == _SVID_)
357	exc.retval = -HUGE_VAL;	359	exc.retval = -HUGE_VAL;
358	else	360	else
359	exc.retval = -HUGE_VAL;	361	exc.retval = -HUGE_VAL;
360	if (_LIB_VERSION == _POSIX_)	362	if (_LIB_VERSION == _POSIX_)
361	errno = ERANGE;	363	errno = ERANGE;
362	else if (!matherr(&exc)) {	364	else if (!matherr(&exc)) {
363	if (_LIB_VERSION == _SVID_) {	365	if (_LIB_VERSION == _SVID_) {
364	(void) WRITE2("log: SING error\n", 16);	366	(void) WRITE2("log: SING error\n", 16);
365	}	367	}
366	errno = EDOM;	368	errno = EDOM;
367	}	369	}
368	break;	370	break;
369	case 17:	371	case 17:
370	case 117:	372	case 117:
371	/* log(x<0) */	373	/* log(x<0) */
372	exc.type = DOMAIN;	374	exc.type = DOMAIN;
373	exc.name = type < 100 ? "log" : "logf";	375	exc.name = type < 100 ? "log" : "logf";
374	if (_LIB_VERSION == _SVID_)	376	if (_LIB_VERSION == _SVID_)
375	exc.retval = -HUGE_VAL;	377	exc.retval = -HUGE_VAL;
376	else	378	else
377	exc.retval = -HUGE_VAL;	379	exc.retval = -HUGE_VAL;
378	if (_LIB_VERSION == _POSIX_)	380	if (_LIB_VERSION == _POSIX_)
379	errno = EDOM;	381	errno = EDOM;
380	else if (!matherr(&exc)) {	382	else if (!matherr(&exc)) {
381	if (_LIB_VERSION == _SVID_) {	383	if (_LIB_VERSION == _SVID_) {
382	(void) WRITE2("log: DOMAIN error\n", 18);	384	(void) WRITE2("log: DOMAIN error\n", 18);
383	}	385	}
384	errno = EDOM;	386	errno = EDOM;
385	}	387	}
386	break;	388	break;
387	case 18:	389	case 18:
388	case 118:	390	case 118:
389	/* log10(0) */	391	/* log10(0) */
390	exc.type = SING;	392	exc.type = SING;
391	exc.name = type < 100 ? "log10" : "log10f";	393	exc.name = type < 100 ? "log10" : "log10f";
392	if (_LIB_VERSION == _SVID_)	394	if (_LIB_VERSION == _SVID_)
393	exc.retval = -HUGE_VAL;	395	exc.retval = -HUGE_VAL;
394	else	396	else
395	exc.retval = -HUGE_VAL;	397	exc.retval = -HUGE_VAL;
396	if (_LIB_VERSION == _POSIX_)	398	if (_LIB_VERSION == _POSIX_)
397	errno = ERANGE;	399	errno = ERANGE;
398	else if (!matherr(&exc)) {	400	else if (!matherr(&exc)) {
399	if (_LIB_VERSION == _SVID_) {	401	if (_LIB_VERSION == _SVID_) {
400	(void) WRITE2("log10: SING error\n", 18);	402	(void) WRITE2("log10: SING error\n", 18);
401	}	403	}
402	errno = EDOM;	404	errno = EDOM;
403	}	405	}
404	break;	406	break;
405	case 19:	407	case 19:
406	case 119:	408	case 119:
407	/* log10(x<0) */	409	/* log10(x<0) */
408	exc.type = DOMAIN;	410	exc.type = DOMAIN;
409	exc.name = type < 100 ? "log10" : "log10f";	411	exc.name = type < 100 ? "log10" : "log10f";
410	if (_LIB_VERSION == _SVID_)	412	if (_LIB_VERSION == _SVID_)
411	exc.retval = -HUGE_VAL;	413	exc.retval = -HUGE_VAL;
412	else	414	else
413	exc.retval = -HUGE_VAL;	415	exc.retval = -HUGE_VAL;
414	if (_LIB_VERSION == _POSIX_)	416	if (_LIB_VERSION == _POSIX_)
415	errno = EDOM;	417	errno = EDOM;
416	else if (!matherr(&exc)) {	418	else if (!matherr(&exc)) {
417	if (_LIB_VERSION == _SVID_) {	419	if (_LIB_VERSION == _SVID_) {
418	(void) WRITE2("log10: DOMAIN error\n", 20);	420	(void) WRITE2("log10: DOMAIN error\n", 20);
419	}	421	}
420	errno = EDOM;	422	errno = EDOM;
421	}	423	}
422	break;	424	break;
423	case 20:	425	case 20:
424	case 120:	426	case 120:
425	/* pow(0.0,0.0) */	427	/* pow(0.0,0.0) */
426	/* error only if _LIB_VERSION == _SVID_ */	428	/* error only if _LIB_VERSION == _SVID_ */
427	exc.type = DOMAIN;	429	exc.type = DOMAIN;
428	exc.name = type < 100 ? "pow" : "powf";	430	exc.name = type < 100 ? "pow" : "powf";
429	exc.retval = zero;	431	exc.retval = zero;
430	if (_LIB_VERSION != _SVID_) exc.retval = 1.0;	432	if (_LIB_VERSION != _SVID_) exc.retval = 1.0;
431	else if (!matherr(&exc)) {	433	else if (!matherr(&exc)) {
432	(void) WRITE2("pow(0,0): DOMAIN error\n", 23);	434	(void) WRITE2("pow(0,0): DOMAIN error\n", 23);
433	errno = EDOM;	435	errno = EDOM;
434	}	436	}
435	break;	437	break;
436	case 21:	438	case 21:
437	case 121:	439	case 121:
438	/* pow(x,y) overflow */	440	/* pow(x,y) overflow */
439	exc.type = OVERFLOW;	441	exc.type = OVERFLOW;
440	exc.name = type < 100 ? "pow" : "powf";	442	exc.name = type < 100 ? "pow" : "powf";
441	if (_LIB_VERSION == _SVID_) {	443	if (_LIB_VERSION == _SVID_) {
442	exc.retval = HUGE_VAL;	444	exc.retval = HUGE_VAL;
443	y *= 0.5;	445	y *= 0.5;
444	if(x	446	if(x
445	} else {	447	} else {
446	exc.retval = HUGE_VAL;	448	exc.retval = HUGE_VAL;
447	y *= 0.5;	449	y *= 0.5;
448	if(x	450	if(x
449	}	451	}
450	if (_LIB_VERSION == _POSIX_)	452	if (_LIB_VERSION == _POSIX_)
451	errno = ERANGE;	453	errno = ERANGE;
452	else if (!matherr(&exc)) {	454	else if (!matherr(&exc)) {
453	errno = ERANGE;	455	errno = ERANGE;
454	}	456	}
455	break;	457	break;
456	case 22:	458	case 22:
457	case 122:	459	case 122:
458	/* pow(x,y) underflow */	460	/* pow(x,y) underflow */
459	exc.type = UNDERFLOW;	461	exc.type = UNDERFLOW;
460	exc.name = type < 100 ? "pow" : "powf";	462	exc.name = type < 100 ? "pow" : "powf";
461	exc.retval = zero;	463	exc.retval = zero;
462	if (_LIB_VERSION == _POSIX_)	464	if (_LIB_VERSION == _POSIX_)
463	errno = ERANGE;	465	errno = ERANGE;
464	else if (!matherr(&exc)) {	466	else if (!matherr(&exc)) {
465	errno = ERANGE;	467	errno = ERANGE;
466	}	468	}
467	break;	469	break;
468	case 23:	470	case 23:
469	case 123:	471	case 123:
470	/* 0*neg /	472	/* 0*neg /
471	exc.type = DOMAIN;	473	exc.type = DOMAIN;
472	exc.name = type < 100 ? "pow" : "powf";	474	exc.name = type < 100 ? "pow" : "powf";
473	if (_LIB_VERSION == _SVID_)	475	if (_LIB_VERSION == _SVID_)
474	exc.retval = zero;	476	exc.retval = zero;
475	else	477	else
476	exc.retval = -HUGE_VAL;	478	exc.retval = -HUGE_VAL;
477	if (_LIB_VERSION == _POSIX_)	479	if (_LIB_VERSION == _POSIX_)
478	errno = EDOM;	480	errno = EDOM;
479	else if (!matherr(&exc)) {	481	else if (!matherr(&exc)) {
480	if (_LIB_VERSION == _SVID_) {	482	if (_LIB_VERSION == _SVID_) {
481	(void) WRITE2("pow(0,neg): DOMAIN error\n", 25);	483	(void) WRITE2("pow(0,neg): DOMAIN error\n", 25);
482	}	484	}
483	errno = EDOM;	485	errno = EDOM;
484	}	486	}
485	break;	487	break;
486	case 24:	488	case 24:
487	case 124:	489	case 124:
488	/* neg*non-integral /	490	/* neg*non-integral /
489	exc.type = DOMAIN;	491	exc.type = DOMAIN;
490	exc.name = type < 100 ? "pow" : "powf";	492	exc.name = type < 100 ? "pow" : "powf";
491	if (_LIB_VERSION == _SVID_)	493	if (_LIB_VERSION == _SVID_)
492	exc.retval = zero;	494	exc.retval = zero;
493	else	495	else
494	exc.retval = zero/zero; /* X/Open allow NaN */	496	exc.retval = zero/zero; /* X/Open allow NaN */
495	if (_LIB_VERSION == _POSIX_)	497	if (_LIB_VERSION == _POSIX_)
496	errno = EDOM;	498	errno = EDOM;
497	else if (!matherr(&exc)) {	499	else if (!matherr(&exc)) {
498	if (_LIB_VERSION == _SVID_) {	500	if (_LIB_VERSION == _SVID_) {

Subversion Repositories Kolibri OS

(root)/programs/develop/libraries/menuetlibc/src/libm/k_standa.c – Rev 4973 → 5098