[unix-history] / lib / msun / src / k_standard.c

/* @(#)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.
 * ====================================================
 */

#ifndef lint
static char rcsid[] = "$Id: k_standard.c,v 1.3 1994/02/18 02:26:04 jtc Exp $";
#endif

#include "math.h"
#include <errno.h>

#ifndef _USE_WRITE
#include <stdio.h>			/* fputs(), stderr */
#define	WRITE2(u,v)	fputs(u, stderr)
#else	/* !defined(_USE_WRITE) */
#include <unistd.h>			/* write */
#define	WRITE2(u,v)	write(2, u, v)
#undef fflush
#endif	/* !defined(_USE_WRITE) */

static double zero = 0.0;	/* used as const */

/* 
 * 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 one = 1.0, inf = 0.0;
	int i0;

	i0 = ((*(int*)&one)>>29)^1;
	*(i0+(int*)&inf) = 0x7ff00000;	/* set inf to infinite */
#endif

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