usr/src/lib/libm/common/C/__tan.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   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)
  51  *         By
  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 }