Return to atand.c CVS log

Up to [CSRG BSD Unix] / 43BSDTahoe / cci / libM

Annotation of 43BSDTahoe/cci/libM/atand.c, revision 1.1

1.1     ! root        1: /*     @(#)atan.c      4.1/4.2         10/31/84  CCI-CPG       */
        !             2: 
        !             3: 
        !             4: /*
        !             5:  * Double-precision arctangent function recoded with
        !             6:  * new algorithm polynomial at CCI-CPG.
        !             7:  * 
        !             8:  * atan returns the value of the arctangent of its
        !             9:  * argument in the range [-pi/2,pi/2].
        !            10:  * 
        !            11:  * atan2 returns the arctangent of arg1/arg2
        !            12:  * in the range [-pi,pi].
        !            13:  * 
        !            14:  * There are no error returns.
        !            15:  * 
        !            16:  * New version by Les Powers (3/31/85)
        !            17:  */
        !            18: 
        !            19: #include "atand.h"
        !            20: 
        !            21: 
        !            22: static double pio2 =  1.570796326794896619231e0;
        !            23: static double pio4 =  0.785398163397448309615e0;
        !            24: static double ap0  =  1.0;
        !            25: static double ap1  = -1.0/3.0;
        !            26: static double ap2  =  1.0/5.0;
        !            27: static double ap3  = -1.0/7.0;
        !            28: 
        !            29: 
        !            30: /*
        !            31:  * atan reduces its argument
        !            32:  * and returns the arctan.
        !            33:  */
        !            34: double
        !            35: atan(x)
        !            36: double x;
        !            37: {
        !            38:        double t,s;
        !            39:        unsigned ta;
        !            40:        union {
        !            41:          double d;
        !            42:          struct { unsigned i0,i1; } i;
        !            43:          struct { unsigned char b0,b1,b2,b3; } b;
        !            44:        } u;
        !            45:        if ( x < 0 )
        !            46:          return( -atan(-x) );
        !            47:        u.d = x;
        !            48:        if (u.i.i0 >= 0x41000000 ) {            /* if (x >= 2.0) */
        !            49:          return( pio2 - atan( 1.0/x ) );
        !            50:        }
        !            51:        if (u.i.i0 >= 0x40000000 ) {            /* if (x >= 0.5) */
        !            52:          u.i.i0 = (u.i.i0 & 0x40ff8000) | 0x00008000;
        !            53:          u.i.i1 = 0;
        !            54:          t = (x-u.d)/(x*u.d+1.0);
        !            55:          s = t*t;
        !            56:          return( t*(ap0+s*(ap1+s*ap2)) + at1[u.b.b1] );
        !            57:        }
        !            58:        if (u.i.i0 >= 0x3d000000) {             /* if (x >= 1/128) */
        !            59:          u.i.i0 += 0x03800000;
        !            60:          ta = u.d;
        !            61:          u.d = ta;
        !            62:          u.i.i0 -= 0x03800000;
        !            63:          t = (x-u.d)/(x*u.d+1.0);
        !            64:        }
        !            65:        else {
        !            66:          ta = 0;
        !            67:          t = x;
        !            68:        }
        !            69:        s = t*t;
        !            70:        return( t*(ap0+s*(ap1+s*(ap2+s*ap3))) + at0[ta] );
        !            71: }
        !            72: 
        !            73: 
        !            74: /*
        !            75:  * atan2 discovers what quadrant the angle
        !            76:  * is in and calls atan.
        !            77:  */
        !            78: double
        !            79: atan2(y,x)
        !            80: double y,x;
        !            81: {
        !            82:        double atan();
        !            83: 
        !            84:        if (y > 0)
        !            85:          if ( x >= y )
        !            86:                return(        atan(y/x));
        !            87:          else if ( x >= 0 )
        !            88:                return( pio2 - atan(x/y));
        !            89:          else if (-x <= y )
        !            90:                return( pio2 + atan(-x/y));
        !            91:          else
        !            92:                return( pio2 + pio2 - atan(-y/x));
        !            93:        else if (y < 0)
        !            94:          if ( x >= -y )
        !            95:                return(       -atan(-y/x));
        !            96:          else if ( x >= 0 )
        !            97:                return(-pio2 + atan(x/(-y)));
        !            98:          else if (-x <= -y )
        !            99:                return(-pio2 - atan(x/y));
        !           100:          else
        !           101:                return(-pio2 - pio2 + atan(y/x));
        !           102:        else
        !           103:          if ( x > 0 )
        !           104:                return( 0 );
        !           105:          else if ( x < 0 )
        !           106:                return( pio2 + pio2 );
        !           107:          else
        !           108:                return( pio2 );
        !           109: }

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