Return to exp.c CVS log

Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / usr.lib / libm

Annotation of cci/usr/src/usr.lib/libm/exp.c, revision 1.1

1.1     ! root        1: /*     @(#)exp.c       4.1/4.2         09/24/85        CCI-CPG */
        !             2: 
        !             3: 
        !             4: /*
        !             5:  * The double-precision 'exp' returns the exponential
        !             6:  * function of its floating-point argument.
        !             7:  *
        !             8:  * New version by Les Powers (3/23/85).
        !             9:  * Small operand fixed on (9/24/85).
        !            10:  */
        !            11: 
        !            12: 
        !            13: #include <errno.h>
        !            14: 
        !            15: 
        !            16: 
        !            17: /*
        !            18:  * The following number 'forces' the hex value of 0x7fffffff 0xffffffff
        !            19:  * to be used for HUGE.
        !            20:  */
        !            21: #define        HUGE            1.701411834604692350e+40
        !            22: 
        !            23: #define EXPONENT28     0x0e000000
        !            24: #define EXP_SIZE0      12
        !            25: #define EXP_SIZE1      128
        !            26: #define EXP_SIZE2      256
        !            27: #define EXP_SIZE3      256
        !            28: #define EXP_SIZE4      256
        !            29: 
        !            30: int    errno;
        !            31: 
        !            32: /*
        !            33:  * This is the natural log of the smallest number that can
        !            34:  * be represented with double precision format (2^-128).
        !            35:  */
        !            36: double _minf = -88.7228391116729996054057115466466007136640;
        !            37: 
        !            38: /*
        !            39:  * This is the natural log of the biggest number that can
        !            40:  * be represented with double precision format (2^127 (1-2^-56)).
        !            41:  */
        !            42: double _maxf = 88.0296919311130542821106916173739672939966;
        !            43: 
        !            44: double _ep0[EXP_SIZE0];
        !            45: double _ep1[EXP_SIZE1];
        !            46: double _ep2[EXP_SIZE2];
        !            47: double _ep3[EXP_SIZE3];
        !            48: double _ep4[EXP_SIZE4];
        !            49: double _en0[EXP_SIZE0];
        !            50: double _en1[EXP_SIZE1];
        !            51: double _en2[EXP_SIZE2];
        !            52: double _en3[EXP_SIZE3];
        !            53: double _en4[EXP_SIZE4];
        !            54: 
        !            55: 
        !            56: double
        !            57: exp(arg)
        !            58: double arg;
        !            59: {
        !            60:        int a0;
        !            61:        union {
        !            62:                int i;
        !            63:                struct {
        !            64:                        unsigned char b0;
        !            65:                        unsigned char b1;
        !            66:                        unsigned char b2;
        !            67:                        unsigned char b3;
        !            68:                } b;
        !            69:        } u;
        !            70:        register union {
        !            71:                double d;
        !            72:                int i;
        !            73:        } abs_arg;
        !            74: 
        !            75:        if (arg >= 0.0) {
        !            76:                abs_arg.d = arg;
        !            77:                if (abs_arg.i >= 0x42000000 ) { /* if (abs_arg.i >= 8.0) */
        !            78:                        if (abs_arg.d > _maxf) {
        !            79:                                errno = ERANGE;
        !            80:                                return(HUGE);
        !            81:                        }
        !            82:                        a0 = abs_arg.d;
        !            83:                        return(exp(arg - (a0&0x78)) * _ep0[a0>>3]);
        !            84:                }
        !            85: 
        !            86:                abs_arg.i += EXPONENT28;    /* multiply by 2 to 28th power */
        !            87:                u.i = abs_arg.d;
        !            88:                abs_arg.d = u.i;
        !            89:                if ( abs_arg.i != 0 )
        !            90:                  abs_arg.i -= EXPONENT28;    /* divide by 2 to 28th power */
        !            91:                return(((arg-abs_arg.d)+1.)*
        !            92:                        _ep1[u.b.b0]*_ep2[u.b.b1]*_ep3[u.b.b2]*_ep4[u.b.b3]);
        !            93:        } else {
        !            94:                abs_arg.d = -arg;
        !            95:                if (abs_arg.i >= 0x42000000) {
        !            96:                        if (arg < _minf)
        !            97:                                return(0.);
        !            98:                        a0 = -arg;
        !            99:                        return(exp(arg + (a0&0x78)) * _en0[a0>>3]);
        !           100:                }
        !           101: 
        !           102:                abs_arg.i += EXPONENT28;    /* multiply by 2 to 28th power */
        !           103:                u.i = abs_arg.d;
        !           104:                abs_arg.d = u.i;
        !           105:                if ( abs_arg.i != 0 )
        !           106:                  abs_arg.i -= EXPONENT28;    /* divide by 2 to 28th power */
        !           107:                return(((arg+abs_arg.d)+1.)*
        !           108:                      _en1[u.b.b0]*_en2[u.b.b1]*_en3[u.b.b2]*_en4[u.b.b3]);
        !           109:        }
        !           110: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.