Subversion Repositories Kolibri OS

Rev

Go to most recent revision | Blame | Last modification | View Log | Download | RSS feed

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