arch/SSE/MathFunctions.h
1 // This file is part of Eigen, a lightweight C++ template library
2 // for linear algebra.
3 //
4 // Copyright (C) 2007 Julien Pommier
5 // Copyright (C) 2009 Gael Guennebaud <gael.guennebaud@inria.fr>
6 //
7 // This Source Code Form is subject to the terms of the Mozilla
8 // Public License v. 2.0. If a copy of the MPL was not distributed
9 // with this file, You can obtain one at http://mozilla.org/MPL/2.0/.
10 
11 /* The sin, cos, exp, and log functions of this file come from
12  * Julien Pommier's sse math library: http://gruntthepeon.free.fr/ssemath/
13  */
14 
15 #ifndef EIGEN_MATH_FUNCTIONS_SSE_H
16 #define EIGEN_MATH_FUNCTIONS_SSE_H
17 
18 namespace Eigen {
19 
20 namespace internal {
21 
22 template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
23 Packet4f plog<Packet4f>(const Packet4f& _x)
24 {
25  Packet4f x = _x;
26  _EIGEN_DECLARE_CONST_Packet4f(1 , 1.0f);
27  _EIGEN_DECLARE_CONST_Packet4f(half, 0.5f);
28  _EIGEN_DECLARE_CONST_Packet4i(0x7f, 0x7f);
29 
30  _EIGEN_DECLARE_CONST_Packet4f_FROM_INT(inv_mant_mask, ~0x7f800000);
31 
32  /* the smallest non denormalized float number */
33  _EIGEN_DECLARE_CONST_Packet4f_FROM_INT(min_norm_pos, 0x00800000);
34 
35  /* natural logarithm computed for 4 simultaneous float
36  return NaN for x <= 0
37  */
38  _EIGEN_DECLARE_CONST_Packet4f(cephes_SQRTHF, 0.707106781186547524f);
39  _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p0, 7.0376836292E-2f);
40  _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p1, - 1.1514610310E-1f);
41  _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p2, 1.1676998740E-1f);
42  _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p3, - 1.2420140846E-1f);
43  _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p4, + 1.4249322787E-1f);
44  _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p5, - 1.6668057665E-1f);
45  _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p6, + 2.0000714765E-1f);
46  _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p7, - 2.4999993993E-1f);
47  _EIGEN_DECLARE_CONST_Packet4f(cephes_log_p8, + 3.3333331174E-1f);
48  _EIGEN_DECLARE_CONST_Packet4f(cephes_log_q1, -2.12194440e-4f);
49  _EIGEN_DECLARE_CONST_Packet4f(cephes_log_q2, 0.693359375f);
50 
51 
52  Packet4i emm0;
53 
54  Packet4f invalid_mask = _mm_cmple_ps(x, _mm_setzero_ps());
55 
56  x = pmax(x, p4f_min_norm_pos); /* cut off denormalized stuff */
57  emm0 = _mm_srli_epi32(_mm_castps_si128(x), 23);
58 
59  /* keep only the fractional part */
60  x = _mm_and_ps(x, p4f_inv_mant_mask);
61  x = _mm_or_ps(x, p4f_half);
62 
63  emm0 = _mm_sub_epi32(emm0, p4i_0x7f);
64  Packet4f e = padd(_mm_cvtepi32_ps(emm0), p4f_1);
65 
66  /* part2:
67  if( x < SQRTHF ) {
68  e -= 1;
69  x = x + x - 1.0;
70  } else { x = x - 1.0; }
71  */
72  Packet4f mask = _mm_cmplt_ps(x, p4f_cephes_SQRTHF);
73  Packet4f tmp = _mm_and_ps(x, mask);
74  x = psub(x, p4f_1);
75  e = psub(e, _mm_and_ps(p4f_1, mask));
76  x = padd(x, tmp);
77 
78  Packet4f x2 = pmul(x,x);
79  Packet4f x3 = pmul(x2,x);
80 
81  Packet4f y, y1, y2;
82  y = pmadd(p4f_cephes_log_p0, x, p4f_cephes_log_p1);
83  y1 = pmadd(p4f_cephes_log_p3, x, p4f_cephes_log_p4);
84  y2 = pmadd(p4f_cephes_log_p6, x, p4f_cephes_log_p7);
85  y = pmadd(y , x, p4f_cephes_log_p2);
86  y1 = pmadd(y1, x, p4f_cephes_log_p5);
87  y2 = pmadd(y2, x, p4f_cephes_log_p8);
88  y = pmadd(y, x3, y1);
89  y = pmadd(y, x3, y2);
90  y = pmul(y, x3);
91 
92  y1 = pmul(e, p4f_cephes_log_q1);
93  tmp = pmul(x2, p4f_half);
94  y = padd(y, y1);
95  x = psub(x, tmp);
96  y2 = pmul(e, p4f_cephes_log_q2);
97  x = padd(x, y);
98  x = padd(x, y2);
99  return _mm_or_ps(x, invalid_mask); // negative arg will be NAN
100 }
101 
102 template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
103 Packet4f pexp<Packet4f>(const Packet4f& _x)
104 {
105  Packet4f x = _x;
106  _EIGEN_DECLARE_CONST_Packet4f(1 , 1.0f);
107  _EIGEN_DECLARE_CONST_Packet4f(half, 0.5f);
108  _EIGEN_DECLARE_CONST_Packet4i(0x7f, 0x7f);
109 
110 
111  _EIGEN_DECLARE_CONST_Packet4f(exp_hi, 88.3762626647950f);
112  _EIGEN_DECLARE_CONST_Packet4f(exp_lo, -88.3762626647949f);
113 
114  _EIGEN_DECLARE_CONST_Packet4f(cephes_LOG2EF, 1.44269504088896341f);
115  _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_C1, 0.693359375f);
116  _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_C2, -2.12194440e-4f);
117 
118  _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p0, 1.9875691500E-4f);
119  _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p1, 1.3981999507E-3f);
120  _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p2, 8.3334519073E-3f);
121  _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p3, 4.1665795894E-2f);
122  _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p4, 1.6666665459E-1f);
123  _EIGEN_DECLARE_CONST_Packet4f(cephes_exp_p5, 5.0000001201E-1f);
124 
125  Packet4f tmp = _mm_setzero_ps(), fx;
126  Packet4i emm0;
127 
128  // clamp x
129  x = pmax(pmin(x, p4f_exp_hi), p4f_exp_lo);
130 
131  /* express exp(x) as exp(g + n*log(2)) */
132  fx = pmadd(x, p4f_cephes_LOG2EF, p4f_half);
133 
134  /* how to perform a floorf with SSE: just below */
135  emm0 = _mm_cvttps_epi32(fx);
136  tmp = _mm_cvtepi32_ps(emm0);
137  /* if greater, substract 1 */
138  Packet4f mask = _mm_cmpgt_ps(tmp, fx);
139  mask = _mm_and_ps(mask, p4f_1);
140  fx = psub(tmp, mask);
141 
142  tmp = pmul(fx, p4f_cephes_exp_C1);
143  Packet4f z = pmul(fx, p4f_cephes_exp_C2);
144  x = psub(x, tmp);
145  x = psub(x, z);
146 
147  z = pmul(x,x);
148 
149  Packet4f y = p4f_cephes_exp_p0;
150  y = pmadd(y, x, p4f_cephes_exp_p1);
151  y = pmadd(y, x, p4f_cephes_exp_p2);
152  y = pmadd(y, x, p4f_cephes_exp_p3);
153  y = pmadd(y, x, p4f_cephes_exp_p4);
154  y = pmadd(y, x, p4f_cephes_exp_p5);
155  y = pmadd(y, z, x);
156  y = padd(y, p4f_1);
157 
158  // build 2^n
159  emm0 = _mm_cvttps_epi32(fx);
160  emm0 = _mm_add_epi32(emm0, p4i_0x7f);
161  emm0 = _mm_slli_epi32(emm0, 23);
162  return pmul(y, _mm_castsi128_ps(emm0));
163 }
164 
165 /* evaluation of 4 sines at onces, using SSE2 intrinsics.
166 
167  The code is the exact rewriting of the cephes sinf function.
168  Precision is excellent as long as x < 8192 (I did not bother to
169  take into account the special handling they have for greater values
170  -- it does not return garbage for arguments over 8192, though, but
171  the extra precision is missing).
172 
173  Note that it is such that sinf((float)M_PI) = 8.74e-8, which is the
174  surprising but correct result.
175 */
176 
177 template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
178 Packet4f psin<Packet4f>(const Packet4f& _x)
179 {
180  Packet4f x = _x;
181  _EIGEN_DECLARE_CONST_Packet4f(1 , 1.0f);
182  _EIGEN_DECLARE_CONST_Packet4f(half, 0.5f);
183 
184  _EIGEN_DECLARE_CONST_Packet4i(1, 1);
185  _EIGEN_DECLARE_CONST_Packet4i(not1, ~1);
186  _EIGEN_DECLARE_CONST_Packet4i(2, 2);
187  _EIGEN_DECLARE_CONST_Packet4i(4, 4);
188 
189  _EIGEN_DECLARE_CONST_Packet4f_FROM_INT(sign_mask, 0x80000000);
190 
191  _EIGEN_DECLARE_CONST_Packet4f(minus_cephes_DP1,-0.78515625f);
192  _EIGEN_DECLARE_CONST_Packet4f(minus_cephes_DP2, -2.4187564849853515625e-4f);
193  _EIGEN_DECLARE_CONST_Packet4f(minus_cephes_DP3, -3.77489497744594108e-8f);
194  _EIGEN_DECLARE_CONST_Packet4f(sincof_p0, -1.9515295891E-4f);
195  _EIGEN_DECLARE_CONST_Packet4f(sincof_p1, 8.3321608736E-3f);
196  _EIGEN_DECLARE_CONST_Packet4f(sincof_p2, -1.6666654611E-1f);
197  _EIGEN_DECLARE_CONST_Packet4f(coscof_p0, 2.443315711809948E-005f);
198  _EIGEN_DECLARE_CONST_Packet4f(coscof_p1, -1.388731625493765E-003f);
199  _EIGEN_DECLARE_CONST_Packet4f(coscof_p2, 4.166664568298827E-002f);
200  _EIGEN_DECLARE_CONST_Packet4f(cephes_FOPI, 1.27323954473516f); // 4 / M_PI
201 
202  Packet4f xmm1, xmm2 = _mm_setzero_ps(), xmm3, sign_bit, y;
203 
204  Packet4i emm0, emm2;
205  sign_bit = x;
206  /* take the absolute value */
207  x = pabs(x);
208 
209  /* take the modulo */
210 
211  /* extract the sign bit (upper one) */
212  sign_bit = _mm_and_ps(sign_bit, p4f_sign_mask);
213 
214  /* scale by 4/Pi */
215  y = pmul(x, p4f_cephes_FOPI);
216 
217  /* store the integer part of y in mm0 */
218  emm2 = _mm_cvttps_epi32(y);
219  /* j=(j+1) & (~1) (see the cephes sources) */
220  emm2 = _mm_add_epi32(emm2, p4i_1);
221  emm2 = _mm_and_si128(emm2, p4i_not1);
222  y = _mm_cvtepi32_ps(emm2);
223  /* get the swap sign flag */
224  emm0 = _mm_and_si128(emm2, p4i_4);
225  emm0 = _mm_slli_epi32(emm0, 29);
226  /* get the polynom selection mask
227  there is one polynom for 0 <= x <= Pi/4
228  and another one for Pi/4<x<=Pi/2
229 
230  Both branches will be computed.
231  */
232  emm2 = _mm_and_si128(emm2, p4i_2);
233  emm2 = _mm_cmpeq_epi32(emm2, _mm_setzero_si128());
234 
235  Packet4f swap_sign_bit = _mm_castsi128_ps(emm0);
236  Packet4f poly_mask = _mm_castsi128_ps(emm2);
237  sign_bit = _mm_xor_ps(sign_bit, swap_sign_bit);
238 
239  /* The magic pass: "Extended precision modular arithmetic"
240  x = ((x - y * DP1) - y * DP2) - y * DP3; */
241  xmm1 = pmul(y, p4f_minus_cephes_DP1);
242  xmm2 = pmul(y, p4f_minus_cephes_DP2);
243  xmm3 = pmul(y, p4f_minus_cephes_DP3);
244  x = padd(x, xmm1);
245  x = padd(x, xmm2);
246  x = padd(x, xmm3);
247 
248  /* Evaluate the first polynom (0 <= x <= Pi/4) */
249  y = p4f_coscof_p0;
250  Packet4f z = _mm_mul_ps(x,x);
251 
252  y = pmadd(y, z, p4f_coscof_p1);
253  y = pmadd(y, z, p4f_coscof_p2);
254  y = pmul(y, z);
255  y = pmul(y, z);
256  Packet4f tmp = pmul(z, p4f_half);
257  y = psub(y, tmp);
258  y = padd(y, p4f_1);
259 
260  /* Evaluate the second polynom (Pi/4 <= x <= 0) */
261 
262  Packet4f y2 = p4f_sincof_p0;
263  y2 = pmadd(y2, z, p4f_sincof_p1);
264  y2 = pmadd(y2, z, p4f_sincof_p2);
265  y2 = pmul(y2, z);
266  y2 = pmul(y2, x);
267  y2 = padd(y2, x);
268 
269  /* select the correct result from the two polynoms */
270  y2 = _mm_and_ps(poly_mask, y2);
271  y = _mm_andnot_ps(poly_mask, y);
272  y = _mm_or_ps(y,y2);
273  /* update the sign */
274  return _mm_xor_ps(y, sign_bit);
275 }
276 
277 /* almost the same as psin */
278 template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
279 Packet4f pcos<Packet4f>(const Packet4f& _x)
280 {
281  Packet4f x = _x;
282  _EIGEN_DECLARE_CONST_Packet4f(1 , 1.0f);
283  _EIGEN_DECLARE_CONST_Packet4f(half, 0.5f);
284 
285  _EIGEN_DECLARE_CONST_Packet4i(1, 1);
286  _EIGEN_DECLARE_CONST_Packet4i(not1, ~1);
287  _EIGEN_DECLARE_CONST_Packet4i(2, 2);
288  _EIGEN_DECLARE_CONST_Packet4i(4, 4);
289 
290  _EIGEN_DECLARE_CONST_Packet4f(minus_cephes_DP1,-0.78515625f);
291  _EIGEN_DECLARE_CONST_Packet4f(minus_cephes_DP2, -2.4187564849853515625e-4f);
292  _EIGEN_DECLARE_CONST_Packet4f(minus_cephes_DP3, -3.77489497744594108e-8f);
293  _EIGEN_DECLARE_CONST_Packet4f(sincof_p0, -1.9515295891E-4f);
294  _EIGEN_DECLARE_CONST_Packet4f(sincof_p1, 8.3321608736E-3f);
295  _EIGEN_DECLARE_CONST_Packet4f(sincof_p2, -1.6666654611E-1f);
296  _EIGEN_DECLARE_CONST_Packet4f(coscof_p0, 2.443315711809948E-005f);
297  _EIGEN_DECLARE_CONST_Packet4f(coscof_p1, -1.388731625493765E-003f);
298  _EIGEN_DECLARE_CONST_Packet4f(coscof_p2, 4.166664568298827E-002f);
299  _EIGEN_DECLARE_CONST_Packet4f(cephes_FOPI, 1.27323954473516f); // 4 / M_PI
300 
301  Packet4f xmm1, xmm2 = _mm_setzero_ps(), xmm3, y;
302  Packet4i emm0, emm2;
303 
304  x = pabs(x);
305 
306  /* scale by 4/Pi */
307  y = pmul(x, p4f_cephes_FOPI);
308 
309  /* get the integer part of y */
310  emm2 = _mm_cvttps_epi32(y);
311  /* j=(j+1) & (~1) (see the cephes sources) */
312  emm2 = _mm_add_epi32(emm2, p4i_1);
313  emm2 = _mm_and_si128(emm2, p4i_not1);
314  y = _mm_cvtepi32_ps(emm2);
315 
316  emm2 = _mm_sub_epi32(emm2, p4i_2);
317 
318  /* get the swap sign flag */
319  emm0 = _mm_andnot_si128(emm2, p4i_4);
320  emm0 = _mm_slli_epi32(emm0, 29);
321  /* get the polynom selection mask */
322  emm2 = _mm_and_si128(emm2, p4i_2);
323  emm2 = _mm_cmpeq_epi32(emm2, _mm_setzero_si128());
324 
325  Packet4f sign_bit = _mm_castsi128_ps(emm0);
326  Packet4f poly_mask = _mm_castsi128_ps(emm2);
327 
328  /* The magic pass: "Extended precision modular arithmetic"
329  x = ((x - y * DP1) - y * DP2) - y * DP3; */
330  xmm1 = pmul(y, p4f_minus_cephes_DP1);
331  xmm2 = pmul(y, p4f_minus_cephes_DP2);
332  xmm3 = pmul(y, p4f_minus_cephes_DP3);
333  x = padd(x, xmm1);
334  x = padd(x, xmm2);
335  x = padd(x, xmm3);
336 
337  /* Evaluate the first polynom (0 <= x <= Pi/4) */
338  y = p4f_coscof_p0;
339  Packet4f z = pmul(x,x);
340 
341  y = pmadd(y,z,p4f_coscof_p1);
342  y = pmadd(y,z,p4f_coscof_p2);
343  y = pmul(y, z);
344  y = pmul(y, z);
345  Packet4f tmp = _mm_mul_ps(z, p4f_half);
346  y = psub(y, tmp);
347  y = padd(y, p4f_1);
348 
349  /* Evaluate the second polynom (Pi/4 <= x <= 0) */
350  Packet4f y2 = p4f_sincof_p0;
351  y2 = pmadd(y2, z, p4f_sincof_p1);
352  y2 = pmadd(y2, z, p4f_sincof_p2);
353  y2 = pmul(y2, z);
354  y2 = pmadd(y2, x, x);
355 
356  /* select the correct result from the two polynoms */
357  y2 = _mm_and_ps(poly_mask, y2);
358  y = _mm_andnot_ps(poly_mask, y);
359  y = _mm_or_ps(y,y2);
360 
361  /* update the sign */
362  return _mm_xor_ps(y, sign_bit);
363 }
364 
365 // This is based on Quake3's fast inverse square root.
366 // For detail see here: http://www.beyond3d.com/content/articles/8/
367 template<> EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS EIGEN_UNUSED
368 Packet4f psqrt<Packet4f>(const Packet4f& _x)
369 {
370  Packet4f half = pmul(_x, pset1<Packet4f>(.5f));
371 
372  /* select only the inverse sqrt of non-zero inputs */
373  Packet4f non_zero_mask = _mm_cmpgt_ps(_x, pset1<Packet4f>(std::numeric_limits<float>::epsilon()));
374  Packet4f x = _mm_and_ps(non_zero_mask, _mm_rsqrt_ps(_x));
375 
376  x = pmul(x, psub(pset1<Packet4f>(1.5f), pmul(half, pmul(x,x))));
377  return pmul(_x,x);
378 }
379 
380 } // end namespace internal
381 
382 } // end namespace Eigen
383 
384 #endif // EIGEN_MATH_FUNCTIONS_SSE_H