ReactOS 0.4.15-dev-7931-gfd331f1
tan.c File Reference
#include "libm.h"
#include "libm_util.h"
#include "libm_inlines.h"
#include "libm_errno.h"
Include dependency graph for tan.c:

Go to the source code of this file.

Macros

#define USE_NAN_WITH_FLAGS
 
#define USE_VAL_WITH_FLAGS
 
#define USE_HANDLE_ERROR
 

Functions

static double tan_piby4 (double x, double xx, int recip)
 
double tan (double x)
 

Macro Definition Documentation

◆ USE_HANDLE_ERROR

#define USE_HANDLE_ERROR

Definition at line 32 of file tan.c.

◆ USE_NAN_WITH_FLAGS

#define USE_NAN_WITH_FLAGS

Definition at line 30 of file tan.c.

◆ USE_VAL_WITH_FLAGS

#define USE_VAL_WITH_FLAGS

Definition at line 31 of file tan.c.

Function Documentation

◆ tan()

double tan ( double  x)

Definition at line 122 of file tan.c.

123{
124 double r, rr;
125 int region, xneg;
126
127 unsigned long long ux, ax;
128 GET_BITS_DP64(x, ux);
129 ax = (ux & ~SIGNBIT_DP64);
130 if (ax <= 0x3fe921fb54442d18) /* abs(x) <= pi/4 */
131 {
132 if (ax < 0x3f20000000000000) /* abs(x) < 2.0^(-13) */
133 {
134 if (ax < 0x3e40000000000000) /* abs(x) < 2.0^(-27) */
135 {
136 if (ax == 0x0000000000000000) return x;
137 else return val_with_flags(x, AMD_F_INEXACT);
138 }
139 else
140 {
141 /* Using a temporary variable prevents 64-bit VC++ from
142 rearranging
143 x + x*x*x*0.333333333333333333;
144 into
145 x * (1 + x*x*0.333333333333333333);
146 The latter results in an incorrectly rounded answer. */
147 double tmp;
148 tmp = x*x*x*0.333333333333333333;
149 return x + tmp;
150 }
151 }
152 else
153 return tan_piby4(x, 0.0, 0);
154 }
155 else if ((ux & EXPBITS_DP64) == EXPBITS_DP64)
156 {
157 /* x is either NaN or infinity */
158 if (ux & MANTBITS_DP64)
159 /* x is NaN */
160 return _handle_error("tan", OP_TAN, ux|0x0008000000000000, _DOMAIN, 0,
161 EDOM, x, 0.0, 1);
162 else
163 /* x is infinity. Return a NaN */
165 EDOM, x, 0.0, 1);
166 }
167 xneg = (ax != ux);
168
169
170 if (xneg)
171 x = -x;
172
173 if (x < 5.0e5)
174 {
175 /* For these size arguments we can just carefully subtract the
176 appropriate multiple of pi/2, using extra precision where
177 x is close to an exact multiple of pi/2 */
178 static const double
179 twobypi = 6.36619772367581382433e-01, /* 0x3fe45f306dc9c883 */
180 piby2_1 = 1.57079632673412561417e+00, /* 0x3ff921fb54400000 */
181 piby2_1tail = 6.07710050650619224932e-11, /* 0x3dd0b4611a626331 */
182 piby2_2 = 6.07710050630396597660e-11, /* 0x3dd0b4611a600000 */
183 piby2_2tail = 2.02226624879595063154e-21, /* 0x3ba3198a2e037073 */
184 piby2_3 = 2.02226624871116645580e-21, /* 0x3ba3198a2e000000 */
185 piby2_3tail = 8.47842766036889956997e-32; /* 0x397b839a252049c1 */
186 double t, rhead, rtail;
187 int npi2;
188 unsigned long long uy, xexp, expdiff;
189 xexp = ax >> EXPSHIFTBITS_DP64;
190 /* How many pi/2 is x a multiple of? */
191 if (ax <= 0x400f6a7a2955385e) /* 5pi/4 */
192 {
193 if (ax <= 0x4002d97c7f3321d2) /* 3pi/4 */
194 npi2 = 1;
195 else
196 npi2 = 2;
197 }
198 else if (ax <= 0x401c463abeccb2bb) /* 9pi/4 */
199 {
200 if (ax <= 0x4015fdbbe9bba775) /* 7pi/4 */
201 npi2 = 3;
202 else
203 npi2 = 4;
204 }
205 else
206 npi2 = (int)(x * twobypi + 0.5);
207 /* Subtract the multiple from x to get an extra-precision remainder */
208 rhead = x - npi2 * piby2_1;
209 rtail = npi2 * piby2_1tail;
210 GET_BITS_DP64(rhead, uy);
211 expdiff = xexp - ((uy & EXPBITS_DP64) >> EXPSHIFTBITS_DP64);
212 if (expdiff > 15)
213 {
214 /* The remainder is pretty small compared with x, which
215 implies that x is a near multiple of pi/2
216 (x matches the multiple to at least 15 bits) */
217 t = rhead;
218 rtail = npi2 * piby2_2;
219 rhead = t - rtail;
220 rtail = npi2 * piby2_2tail - ((t - rhead) - rtail);
221 if (expdiff > 48)
222 {
223 /* x matches a pi/2 multiple to at least 48 bits */
224 t = rhead;
225 rtail = npi2 * piby2_3;
226 rhead = t - rtail;
227 rtail = npi2 * piby2_3tail - ((t - rhead) - rtail);
228 }
229 }
230 r = rhead - rtail;
231 rr = (rhead - r) - rtail;
232 region = npi2 & 3;
233 }
234 else
235 {
236 /* Reduce x into range [-pi/4,pi/4] */
237 __remainder_piby2(x, &r, &rr, &region);
238 }
239
240 if (xneg)
241 return -tan_piby4(r, rr, region & 1);
242 else
243 return tan_piby4(r, rr, region & 1);
244}
double __cdecl _handle_error(char *fname, int opcode, unsigned long long value, int type, int flags, int error, double arg1, double arg2, int nargs)
Handles an error condition.
Definition: _handle_error.c:34
unsigned int(__cdecl typeof(jpeg_read_scanlines))(struct jpeg_decompress_struct *
Definition: typeof.h:31
#define EDOM
Definition: errno.h:39
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
GLdouble GLdouble t
Definition: gl.h:2047
#define _DOMAIN
Definition: math.h:39
void __remainder_piby2(double x, double *r, double *rr, int *region)
#define AMD_F_INEXACT
Definition: libm_new.h:82
#define AMD_F_INVALID
Definition: libm_new.h:86
#define INDEFBITPATT_DP64
Definition: libm_util.h:52
#define EXPSHIFTBITS_DP64
Definition: libm_util.h:56
#define GET_BITS_DP64(x, ux)
Definition: libm_util.h:118
#define EXPBITS_DP64
Definition: libm_util.h:45
#define MANTBITS_DP64
Definition: libm_util.h:46
ecx edi movl ebx edx edi decl ecx esi eax jecxz decl eax andl eax esi movl edx movl TEMP incl eax andl eax ecx incl ebx testl eax jnz xchgl ecx incl TEMP esp ecx subl ebx pushl ecx ecx edx ecx shrl ecx mm0 mm4 mm0 mm4 mm1 mm5 mm1 mm5 mm2 mm6 mm2 mm6 mm3 mm7 mm3 mm7 paddd mm0 paddd mm4 paddd mm0 paddd mm4 paddd mm0 paddd mm4 movq mm1 movq mm5 psrlq mm1 psrlq mm5 paddd mm0 paddd mm4 psrad mm0 psrad mm4 packssdw mm0 packssdw mm4 mm1 punpckldq mm0 pand mm1 pand mm0 por mm1 movq edi esi edx edi decl ecx jnz popl ecx andl ecx jecxz mm0 mm0 mm1 mm1 mm2 mm2 mm3 mm3 paddd mm0 paddd mm0 paddd mm0 movq mm1 psrlq mm1 paddd mm0 psrad mm0 packssdw mm0 movd eax movw ax
Definition: synth_sse3d.h:180
static double tan_piby4(double x, double xx, int recip)
Definition: tan.c:42

◆ tan_piby4()

static double tan_piby4 ( double  x,
double  xx,
int  recip 
)
inlinestatic

Definition at line 42 of file tan.c.

43{
44 double r, t1, t2, xl;
45 int transform = 0;
46 static const double
47 piby4_lead = 7.85398163397448278999e-01, /* 0x3fe921fb54442d18 */
48 piby4_tail = 3.06161699786838240164e-17; /* 0x3c81a62633145c06 */
49
50 /* In order to maintain relative precision transform using the identity:
51 tan(pi/4-x) = (1-tan(x))/(1+tan(x)) for arguments close to pi/4.
52 Similarly use tan(x-pi/4) = (tan(x)-1)/(tan(x)+1) close to -pi/4. */
53
54 if (x > 0.68)
55 {
56 transform = 1;
57 x = piby4_lead - x;
58 xl = piby4_tail - xx;
59 x += xl;
60 xx = 0.0;
61 }
62 else if (x < -0.68)
63 {
64 transform = -1;
65 x = piby4_lead + x;
66 xl = piby4_tail + xx;
67 x += xl;
68 xx = 0.0;
69 }
70
71 /* Core Remez [2,3] approximation to tan(x+xx) on the
72 interval [0,0.68]. */
73
74 r = x*x + 2.0 * x * xx;
75 t1 = x;
76 t2 = xx + x*r*
77 (0.372379159759792203640806338901e0 +
78 (-0.229345080057565662883358588111e-1 +
79 0.224044448537022097264602535574e-3*r)*r)/
80 (0.111713747927937668539901657944e1 +
81 (-0.515658515729031149329237816945e0 +
82 (0.260656620398645407524064091208e-1 -
83 0.232371494088563558304549252913e-3*r)*r)*r);
84
85 /* Reconstruct tan(x) in the transformed case. */
86
87 if (transform)
88 {
89 double t;
90 t = t1 + t2;
91 if (recip)
92 return transform*(2*t/(t-1) - 1.0);
93 else
94 return transform*(1.0 - 2*t/(1+t));
95 }
96
97 if (recip)
98 {
99 /* Compute -1.0/(t1 + t2) accurately */
100 double trec, trec_top, z1, z2, t;
101 unsigned long long u;
102 t = t1 + t2;
103 GET_BITS_DP64(t, u);
104 u &= 0xffffffff00000000;
105 PUT_BITS_DP64(u, z1);
106 z2 = t2 - (z1 - t1);
107 trec = -1.0 / t;
108 GET_BITS_DP64(trec, u);
109 u &= 0xffffffff00000000;
110 PUT_BITS_DP64(u, trec_top);
111 return trec_top + trec * ((1.0 + trec_top * z1) + trec_top * z2);
112
113 }
114 else
115 return t1 + t2;
116}
GLuint GLenum GLenum transform
Definition: glext.h:9407
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble * u
Definition: glfuncs.h:240
#define PUT_BITS_DP64(ux, x)
Definition: libm_util.h:124
int xx
Definition: npserver.c:29

Referenced by tan().