Branch data     Line data    Source code

       1                 :             : /* s_atanf.c -- float version of s_atan.c.
       2                 :             :  * Conversion to float by Ian Lance Taylor, Cygnus Support, ian@cygnus.com.
       3                 :             :  */
       4                 :             : 
       5                 :             : /*
       6                 :             :  * ====================================================
       7                 :             :  * Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
       8                 :             :  *
       9                 :             :  * Developed at SunPro, a Sun Microsystems, Inc. business.
      10                 :             :  * Permission to use, copy, modify, and distribute this
      11                 :             :  * software is freely granted, provided that this notice
      12                 :             :  * is preserved.
      13                 :             :  * ====================================================
      14                 :             :  */
      15                 :             : 
      16                 :             : #include "cdefs-compat.h"
      17                 :             : //__FBSDID("$FreeBSD: src/lib/msun/src/s_atanf.c,v 1.10 2008/08/01 01:24:25 das Exp $");
      18                 :             : 
      19                 :             : #include <openlibm_math.h>
      20                 :             : 
      21                 :             : #include "math_private.h"
      22                 :             : 
      23                 :             : static const float atanhi[] = {
      24                 :             :   4.6364760399e-01, /* atan(0.5)hi 0x3eed6338 */
      25                 :             :   7.8539812565e-01, /* atan(1.0)hi 0x3f490fda */
      26                 :             :   9.8279368877e-01, /* atan(1.5)hi 0x3f7b985e */
      27                 :             :   1.5707962513e+00, /* atan(inf)hi 0x3fc90fda */
      28                 :             : };
      29                 :             : 
      30                 :             : static const float atanlo[] = {
      31                 :             :   5.0121582440e-09, /* atan(0.5)lo 0x31ac3769 */
      32                 :             :   3.7748947079e-08, /* atan(1.0)lo 0x33222168 */
      33                 :             :   3.4473217170e-08, /* atan(1.5)lo 0x33140fb4 */
      34                 :             :   7.5497894159e-08, /* atan(inf)lo 0x33a22168 */
      35                 :             : };
      36                 :             : 
      37                 :             : static const float aT[] = {
      38                 :             :   3.3333328366e-01,
      39                 :             :  -1.9999158382e-01,
      40                 :             :   1.4253635705e-01,
      41                 :             :  -1.0648017377e-01,
      42                 :             :   6.1687607318e-02,
      43                 :             : };
      44                 :             : 
      45                 :             : static const float
      46                 :             : one   = 1.0,
      47                 :             : huge   = 1.0e30;
      48                 :             : 
      49                 :             : OLM_DLLEXPORT float
      50                 :          19 : atanf(float x)
      51                 :             : {
      52                 :             :         float w,s1,s2,z;
      53                 :             :         int32_t ix,hx,id;
      54                 :             : 
      55                 :          19 :         GET_FLOAT_WORD(hx,x);
      56                 :          19 :         ix = hx&0x7fffffff;
      57         [ +  + ]:          19 :         if(ix>=0x4c800000) { /* if |x| >= 2**26 */
      58         [ +  + ]:           4 :             if(ix>0x7f800000)
      59                 :           1 :                 return x+x;             /* NaN */
      60         [ +  + ]:           3 :             if(hx>0) return  atanhi[3]+*(volatile float *)&atanlo[3];
      61                 :           2 :             else     return -atanhi[3]-*(volatile float *)&atanlo[3];
      62         [ +  + ]:          15 :         } if (ix < 0x3ee00000) {     /* |x| < 0.4375 */
      63         [ +  - ]:           6 :             if (ix < 0x39800000) {   /* |x| < 2**-12 */
      64         [ +  - ]:           6 :                 if(huge+x>one) return x;     /* raise inexact */
      65                 :             :             }
      66                 :           0 :             id = -1;
      67                 :             :         } else {
      68                 :           9 :         x = fabsf(x);
      69         [ +  + ]:           9 :         if (ix < 0x3f980000) {               /* |x| < 1.1875 */
      70         [ -  + ]:           7 :             if (ix < 0x3f300000) {   /* 7/16 <=|x|<11/16 */
      71                 :           0 :                 id = 0; x = ((float)2.0*x-one)/((float)2.0+x);
      72                 :             :             } else {                    /* 11/16<=|x|< 19/16 */
      73                 :           7 :                 id = 1; x  = (x-one)/(x+one);
      74                 :             :             }
      75                 :             :         } else {
      76         [ +  + ]:           2 :             if (ix < 0x401c0000) {   /* |x| < 2.4375 */
      77                 :           1 :                 id = 2; x  = (x-(float)1.5)/(one+(float)1.5*x);
      78                 :             :             } else {                    /* 2.4375 <= |x| < 2**26 */
      79                 :           1 :                 id = 3; x  = -(float)1.0/x;
      80                 :             :             }
      81                 :             :         }}
      82                 :             :     /* end of argument reduction */
      83                 :           9 :         z = x*x;
      84                 :           9 :         w = z*z;
      85                 :             :     /* break sum from i=0 to 10 aT[i]z**(i+1) into odd and even poly */
      86                 :           9 :         s1 = z*(aT[0]+w*(aT[2]+w*aT[4]));
      87                 :           9 :         s2 = w*(aT[1]+w*aT[3]);
      88         [ -  + ]:           9 :         if (id<0) return x - x*(s1+s2);
      89                 :             :         else {
      90                 :           9 :             z = atanhi[id] - ((x*(s1+s2) - atanlo[id]) - x);
      91         [ +  + ]:           9 :             return (hx<0)? -z:z;
      92                 :             :         }
      93                 :             : }