src/fdlibm/k_standard.c

/* -*- Mode: C; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
 *
 * ***** BEGIN LICENSE BLOCK *****
 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
 *
 * The contents of this file are subject to the Mozilla Public License Version
 * 1.1 (the "License"); you may not use this file except in compliance with
 * the License. You may obtain a copy of the License at
 * http://www.mozilla.org/MPL/
 *
 * Software distributed under the License is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
 * for the specific language governing rights and limitations under the
 * License.
 *
 * The Original Code is Mozilla Communicator client code, released
 * March 31, 1998.
 *
 * The Initial Developer of the Original Code is
 * Sun Microsystems, Inc.
 * Portions created by the Initial Developer are Copyright (C) 1998
 * the Initial Developer. All Rights Reserved.
 *
 * Contributor(s):
 *
 * Alternatively, the contents of this file may be used under the terms of
 * either of the GNU General Public License Version 2 or later (the "GPL"),
 * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
 * in which case the provisions of the GPL or the LGPL are applicable instead
 * of those above. If you wish to allow use of your version of this file only
 * under the terms of either the GPL or the LGPL, and not to allow others to
 * use your version of this file under the terms of the MPL, indicate your
 * decision by deleting the provisions above and replace them with the notice
 * and other provisions required by the GPL or the LGPL. If you do not delete
 * the provisions above, a recipient may use your version of this file under
 * the terms of any one of the MPL, the GPL or the LGPL.
 *
 * ***** END LICENSE BLOCK ***** */

/* @(#)k_standard.c 1.3 95/01/18 */
/*
 * ====================================================
 * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
 *
 * Developed at SunSoft, a Sun Microsystems, Inc. business.
 * Permission to use, copy, modify, and distribute this
 * software is freely granted, provided that this notice 
 * is preserved.
 * ====================================================
 *
 */

#include "fdlibm.h"

/* XXX ugly hack to get msvc to link without error. */
#if _LIB_VERSION == _IEEE_ && !(defined(DARWIN) || defined(XP_MACOSX))
   int errno;
#  define EDOM 0
#  define ERANGE 0
#else
#  include <errno.h>
#endif


#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, int *err)
#else
        double __kernel_standard(x,y,type, err)
     double x,y; int type;int *err;
#endif
{
        struct exception exc;
#ifndef HUGE_VAL        /* this is the only routine that uses HUGE_VAL */ 
#define HUGE_VAL inf
        double inf = 0.0;
        fd_twoints u;

        u.d = inf;
        __HI(u) = 0x7ff00000;   /* set inf to infinite */
        inf = u.d;
#endif

    *err = 0;

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