Print this page
11210 libm should be cstyle(1ONBLD) clean


   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 
  22 /*
  23  * Copyright 2011 Nexenta Systems, Inc.  All rights reserved.
  24  */

  25 /*
  26  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
  27  * Use is subject to license terms.
  28  */
  29 
  30 /* INDENT OFF */
  31 /*
  32  * __k_tan( double x;  double y; int k )
  33  * kernel tan/cotan function on [-pi/4, pi/4], pi/4 ~ 0.785398164
  34  * Input x is assumed to be bounded by ~pi/4 in magnitude.
  35  * Input y is the tail of x.
  36  * Input k indicate -- tan if k=0; else -1/tan
  37  *
  38  * Table look up algorithm
  39  *      1. by tan(-x) = -tan(x), need only to consider positive x
  40  *      2. if x < 5/32 = [0x3fc40000, 0] = 0.15625 , then
  41  *           if x < 2^-27 (hx < 0x3e400000 0), set w=x with inexact if x !=  0
  42  *           else
  43  *              z = x*x;
  44  *              w = x + (y+(x*z)*(t1+z*(t2+z*(t3+z*(t4+z*(t5+z*t6))))))
  45  *         return (k == 0)? w: 1/w;
  46  *      3. else
  47  *              ht = (hx + 0x4000)&0x7fff8000       (round x to a break point t)
  48  *              lt = 0
  49  *              i  = (hy-0x3fc40000)>>15; (i<=64)
  50  *              x' = (x - t)+y                  (|x'| ~<= 2^-7)


  52  *              tan(t+x')
  53  *                = (tan(t)+tan(x'))/(1-tan(x')tan(t))
  54  *         We have
  55  *                           sin(x')+tan(t)*(tan(t)*sin(x'))
  56  *                = tan(t) + -------------------------------    for k=0
  57  *                              cos(x') - tan(t)*sin(x')
  58  *
  59  *                           cos(x') - tan(t)*sin(x')
  60  *                = - --------------------------------------    for k=1
  61  *                     tan(t) + tan(t)*(cos(x')-1) + sin(x')
  62  *
  63  *
  64  *         where        tan(t) is from the table,
  65  *                      sin(x') = x + pp1*x^3 + pp2*x^5
  66  *                      cos(x') = 1 + qq1*x^2 + qq2*x^4
  67  */
  68 
  69 #include "libm.h"
  70 
  71 extern const double _TBL_tan_hi[], _TBL_tan_lo[];

  72 static const double q[] = {
  73 /* one  = */  1.0,


  74 /*
  75  *                       2       2       -59.56
  76  * |sin(x) - pp1*x*(pp2+x *(pp3+x )| <= 2        for |x|<1/64
  77  */
  78 /* pp1  = */  8.33326120969096230395312119298978359438478946686e-0003,
  79 /* pp2  = */  1.20001038589438965215025680596868692381425944526e+0002,
  80 /* pp3  = */ -2.00001730975089451192161504877731204032897949219e+0001,
  81 
  82 /*
  83  *                   2      2        -56.19
  84  * |cos(x) - (1+qq1*x (qq2+x ))| <= 2        for |x|<=1/128
  85  */
  86 /* qq1  = */  4.16665486385721928197511942926212213933467864990e-0002,
  87 /* qq2  = */ -1.20000339921340035687080671777948737144470214844e+0001,
  88 
  89 /*
  90  * |tan(x) - PF(x)|
  91  * |--------------| <= 2^-58.57 for |x|<0.15625
  92  * |      x       |
  93  *
  94  * where (let z = x*x)
  95  *      PF(x) = x + (t1*x*z)(t2 + z(t3 + z))(t4 + z)(t5 + z(t6 + z))
  96  */
  97 /* t1 = */  3.71923358986516816929168705030406272271648049355e-0003,
  98 /* t2 = */  6.02645120354857866118436504621058702468872070312e+0000,
  99 /* t3 = */  2.42627327587398156083509093150496482849121093750e+0000,
 100 /* t4 = */  2.44968983934252770851003333518747240304946899414e+0000,
 101 /* t5 = */  6.07089252571767978849948121933266520500183105469e+0000,
 102 /* t6 = */ -2.49403756995593761658369658107403665781021118164e+0000,
 103 };
 104 
 105 
 106 #define one q[0]
 107 #define pp1 q[1]
 108 #define pp2 q[2]
 109 #define pp3 q[3]
 110 #define qq1 q[4]
 111 #define qq2 q[5]
 112 #define t1  q[6]
 113 #define t2  q[7]
 114 #define t3  q[8]
 115 #define t4  q[9]
 116 #define t5  q[10]
 117 #define t6  q[11]
 118 
 119 /* INDENT ON */
 120 
 121 
 122 double
 123 __k_tan(double x, double y, int k) {

 124         double a, t, z, w = 0.0L, s, c, r, rh, xh, xl;
 125         int i, j, hx, ix;
 126 
 127         t = one;
 128         hx = ((int *) &x)[HIWORD];
 129         ix = hx & 0x7fffffff;

 130         if (ix < 0x3fc40000) {               /* 0.15625 */
 131                 if (ix < 0x3e400000) {       /* 2^-27 */
 132                         if ((i = (int) x) == 0)         /* generate inexact */
 133                                 w = x;

 134                         t = y;
 135                 } else {
 136                         z = x * x;
 137                         t = y + (((t1 * x) * z) * (t2 + z * (t3 + z))) *
 138                                 ((t4 + z) * (t5 + z * (t6 + z)));
 139                         w = x + t;
 140                 }

 141                 if (k == 0)
 142                         return (w);

 143                 /*
 144                  * Compute -1/(x+T) with great care
 145                  * Let r = -1/(x+T), rh = r chopped to 20 bits.
 146                  * Also let xh  = x+T chopped to 20 bits, xl = (x-xh)+T. Then
 147                  *   -1/(x+T)   = rh + (-1/(x+T)-rh) = rh + r*(1+rh*(x+T))
 148                  *              = rh + r*((1+rh*xh)+rh*xl).
 149                  */
 150                 rh = r = -one / w;
 151                 ((int *) &rh)[LOWORD] = 0;
 152                 xh = w;
 153                 ((int *) &xh)[LOWORD] = 0;
 154                 xl = (x - xh) + t;
 155                 return (rh + r * ((one + rh * xh) + rh * xl));
 156         }

 157         j = (ix + 0x4000) & 0x7fff8000;
 158         i = (j - 0x3fc40000) >> 15;
 159         ((int *) &t)[HIWORD] = j;

 160         if (hx > 0)
 161                 x = y - (t - x);
 162         else
 163                 x = -y - (t + x);

 164         a = _TBL_tan_hi[i];
 165         z = x * x;
 166         s = (pp1 * x) * (pp2 + z * (pp3 + z));  /* sin(x) */
 167         t = (qq1 * z) * (qq2 + z);              /* cos(x) - 1 */

 168         if (k == 0) {
 169                 w = a * s;
 170                 t = _TBL_tan_lo[i] + (s + a * w) / (one - (w - t));
 171                 return (hx < 0 ? -a - t : a + t);
 172         } else {
 173                 w = s + a * t;
 174                 c = w + _TBL_tan_lo[i];
 175                 t = a * s - t;

 176                 /*
 177                  * Now try to compute [(1-T)/(a+c)] accurately
 178                  *
 179                  * Let r = 1/(a+c), rh = (1-T)*r chopped to 20 bits.
 180                  * Also let xh = a+c chopped to 20 bits, xl = (a-xh)+c. Then
 181                  *      (1-T)/(a+c) = rh + ((1-T)/(a+c)-rh)
 182                  *              = rh + r*(1-T-rh*(a+c))
 183                  *              = rh + r*((1-T-rh*xh)-rh*xl)
 184                  *              = rh + r*(((1-rh*xh)-T)-rh*xl)
 185                  */
 186                 r = one / (a + c);
 187                 rh = (one - t) * r;
 188                 ((int *) &rh)[LOWORD] = 0;
 189                 xh = a + c;
 190                 ((int *) &xh)[LOWORD] = 0;
 191                 xl = (a - xh) + c;
 192                 z = rh + r * (((one - rh * xh) - t) - rh * xl);
 193                 return (hx >= 0 ? -z : z);
 194         }
 195 }


   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 
  22 /*
  23  * Copyright 2011 Nexenta Systems, Inc.  All rights reserved.
  24  */
  25 
  26 /*
  27  * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
  28  * Use is subject to license terms.
  29  */
  30 
  31 
  32 /*
  33  * __k_tan( double x;  double y; int k )
  34  * kernel tan/cotan function on [-pi/4, pi/4], pi/4 ~ 0.785398164
  35  * Input x is assumed to be bounded by ~pi/4 in magnitude.
  36  * Input y is the tail of x.
  37  * Input k indicate -- tan if k=0; else -1/tan
  38  *
  39  * Table look up algorithm
  40  *      1. by tan(-x) = -tan(x), need only to consider positive x
  41  *      2. if x < 5/32 = [0x3fc40000, 0] = 0.15625 , then
  42  *           if x < 2^-27 (hx < 0x3e400000 0), set w=x with inexact if x !=  0
  43  *           else
  44  *              z = x*x;
  45  *              w = x + (y+(x*z)*(t1+z*(t2+z*(t3+z*(t4+z*(t5+z*t6))))))
  46  *         return (k == 0)? w: 1/w;
  47  *      3. else
  48  *              ht = (hx + 0x4000)&0x7fff8000       (round x to a break point t)
  49  *              lt = 0
  50  *              i  = (hy-0x3fc40000)>>15; (i<=64)
  51  *              x' = (x - t)+y                  (|x'| ~<= 2^-7)


  53  *              tan(t+x')
  54  *                = (tan(t)+tan(x'))/(1-tan(x')tan(t))
  55  *         We have
  56  *                           sin(x')+tan(t)*(tan(t)*sin(x'))
  57  *                = tan(t) + -------------------------------    for k=0
  58  *                              cos(x') - tan(t)*sin(x')
  59  *
  60  *                           cos(x') - tan(t)*sin(x')
  61  *                = - --------------------------------------    for k=1
  62  *                     tan(t) + tan(t)*(cos(x')-1) + sin(x')
  63  *
  64  *
  65  *         where        tan(t) is from the table,
  66  *                      sin(x') = x + pp1*x^3 + pp2*x^5
  67  *                      cos(x') = 1 + qq1*x^2 + qq2*x^4
  68  */
  69 
  70 #include "libm.h"
  71 
  72 extern const double _TBL_tan_hi[], _TBL_tan_lo[];
  73 
  74 static const double q[] = {
  75 /* one  = */
  76         1.0,
  77 
  78 /*
  79  *                       2       2       -59.56
  80  * |sin(x) - pp1*x*(pp2+x *(pp3+x )| <= 2        for |x|<1/64
  81  */
  82 /* pp1  = */ 8.33326120969096230395312119298978359438478946686e-0003,
  83 /* pp2  = */ 1.20001038589438965215025680596868692381425944526e+0002,
  84 /* pp3  = */ -2.00001730975089451192161504877731204032897949219e+0001,
  85 
  86 /*
  87  *                   2      2        -56.19
  88  * |cos(x) - (1+qq1*x (qq2+x ))| <= 2        for |x|<=1/128
  89  */
  90 /* qq1  = */ 4.16665486385721928197511942926212213933467864990e-0002,
  91 /* qq2  = */ -1.20000339921340035687080671777948737144470214844e+0001,
  92 
  93 /*
  94  * |tan(x) - PF(x)|
  95  * |--------------| <= 2^-58.57 for |x|<0.15625
  96  * |      x       |
  97  *
  98  * where (let z = x*x)
  99  *      PF(x) = x + (t1*x*z)(t2 + z(t3 + z))(t4 + z)(t5 + z(t6 + z))
 100  */
 101 /* t1 = */ 3.71923358986516816929168705030406272271648049355e-0003,
 102 /* t2 = */ 6.02645120354857866118436504621058702468872070312e+0000,
 103 /* t3 = */ 2.42627327587398156083509093150496482849121093750e+0000,
 104 /* t4 = */ 2.44968983934252770851003333518747240304946899414e+0000,
 105 /* t5 = */ 6.07089252571767978849948121933266520500183105469e+0000,
 106 /* t6 = */ -2.49403756995593761658369658107403665781021118164e+0000,
 107 };
 108 

 109 #define one             q[0]
 110 #define pp1             q[1]
 111 #define pp2             q[2]
 112 #define pp3             q[3]
 113 #define qq1             q[4]
 114 #define qq2             q[5]
 115 #define t1              q[6]
 116 #define t2              q[7]
 117 #define t3              q[8]
 118 #define t4              q[9]
 119 #define t5              q[10]
 120 #define t6              q[11]
 121 


 122 
 123 double
 124 __k_tan(double x, double y, int k)
 125 {
 126         double a, t, z, w = 0.0L, s, c, r, rh, xh, xl;
 127         int i, j, hx, ix;
 128 
 129         t = one;
 130         hx = ((int *)&x)[HIWORD];
 131         ix = hx & 0x7fffffff;
 132 
 133         if (ix < 0x3fc40000) {                       /* 0.15625 */
 134                 if (ix < 0x3e400000) {               /* 2^-27 */
 135                         if ((i = (int)x) == 0)  /* generate inexact */
 136                                 w = x;
 137 
 138                         t = y;
 139                 } else {
 140                         z = x * x;
 141                         t = y + (((t1 * x) * z) * (t2 + z * (t3 + z))) * ((t4 +
 142                             z) * (t5 + z * (t6 + z)));
 143                         w = x + t;
 144                 }
 145 
 146                 if (k == 0)
 147                         return (w);
 148 
 149                 /*
 150                  * Compute -1/(x+T) with great care
 151                  * Let r = -1/(x+T), rh = r chopped to 20 bits.
 152                  * Also let xh  = x+T chopped to 20 bits, xl = (x-xh)+T. Then
 153                  *   -1/(x+T)   = rh + (-1/(x+T)-rh) = rh + r*(1+rh*(x+T))
 154                  *              = rh + r*((1+rh*xh)+rh*xl).
 155                  */
 156                 rh = r = -one / w;
 157                 ((int *)&rh)[LOWORD] = 0;
 158                 xh = w;
 159                 ((int *)&xh)[LOWORD] = 0;
 160                 xl = (x - xh) + t;
 161                 return (rh + r * ((one + rh * xh) + rh * xl));
 162         }
 163 
 164         j = (ix + 0x4000) & 0x7fff8000;
 165         i = (j - 0x3fc40000) >> 15;
 166         ((int *)&t)[HIWORD] = j;
 167 
 168         if (hx > 0)
 169                 x = y - (t - x);
 170         else
 171                 x = -y - (t + x);
 172 
 173         a = _TBL_tan_hi[i];
 174         z = x * x;
 175         s = (pp1 * x) * (pp2 + z * (pp3 + z));  /* sin(x) */
 176         t = (qq1 * z) * (qq2 + z);              /* cos(x) - 1 */
 177 
 178         if (k == 0) {
 179                 w = a * s;
 180                 t = _TBL_tan_lo[i] + (s + a * w) / (one - (w - t));
 181                 return (hx < 0 ? -a - t : a + t);
 182         } else {
 183                 w = s + a * t;
 184                 c = w + _TBL_tan_lo[i];
 185                 t = a * s - t;
 186 
 187                 /*
 188                  * Now try to compute [(1-T)/(a+c)] accurately
 189                  *
 190                  * Let r = 1/(a+c), rh = (1-T)*r chopped to 20 bits.
 191                  * Also let xh = a+c chopped to 20 bits, xl = (a-xh)+c. Then
 192                  *      (1-T)/(a+c) = rh + ((1-T)/(a+c)-rh)
 193                  *              = rh + r*(1-T-rh*(a+c))
 194                  *              = rh + r*((1-T-rh*xh)-rh*xl)
 195                  *              = rh + r*(((1-rh*xh)-T)-rh*xl)
 196                  */
 197                 r = one / (a + c);
 198                 rh = (one - t) * r;
 199                 ((int *)&rh)[LOWORD] = 0;
 200                 xh = a + c;
 201                 ((int *)&xh)[LOWORD] = 0;
 202                 xl = (a - xh) + c;
 203                 z = rh + r * (((one - rh * xh) - t) - rh * xl);
 204                 return (hx >= 0 ? -z : z);
 205         }
 206 }