18#ifndef EIGEN_ARCH_GENERIC_PACKET_MATH_FUNCTIONS_H
19#define EIGEN_ARCH_GENERIC_PACKET_MATH_FUNCTIONS_H
22#include "../../InternalHeaderCheck.h"
23#include "GenericPacketMathPolynomials.h"
24#include "GenericPacketMathFrexpLdexp.h"
25#include "GenericPacketMathDoubleWord.h"
51template <
typename Packet>
52EIGEN_STRONG_INLINE
bool plog_core_float(
const Packet v, Packet& log_mantissa, Packet& e) {
53 using PacketI =
typename unpacket_traits<Packet>::integer_packet;
55 const PacketI cst_min_normal = pset1<PacketI>(0x00800000);
56 const PacketI cst_mant_mask = pset1<PacketI>(0x007fffff);
61 const PacketI cst_sqrt_half_offset = pset1<PacketI>(0x004afb0d);
62 const PacketI cst_exp_bias = pset1<PacketI>(0x7f);
63 const PacketI cst_half_mant = pset1<PacketI>(0x3f3504f3);
66 PacketI vi = preinterpret<PacketI>(v);
67 const PacketI is_denormal = pcmp_lt(vi, cst_min_normal);
68 const bool any_special = predux_any(preinterpret<Packet>(por(is_denormal, pcmp_lt(pset1<PacketI>(0x7f7fffff), vi))));
71 Packet v_normalized = pmul(v, pset1<Packet>(8388608.0f));
72 vi = pselect(is_denormal, preinterpret<PacketI>(v_normalized), vi);
77 PacketI vi_biased = padd(vi, cst_sqrt_half_offset);
79 PacketI e_int = psub(plogical_shift_right<23>(vi_biased), cst_exp_bias);
80 if (any_special) e_int = psub(e_int, pand(is_denormal, pset1<PacketI>(23)));
81 e = pcast<PacketI, Packet>(e_int);
86 Packet f = psub(preinterpret<Packet>(padd(pand(vi_biased, cst_mant_mask), cst_half_mant)), pset1<Packet>(1.0f));
93 constexpr float coeffs[] = {
94 8.8758550584316254e-02f,
95 -1.4199858903884888e-01f,
96 1.4824025332927704e-01f,
97 -1.6583317518234253e-01f,
98 1.9972395896911621e-01f,
99 -2.5001299381256104e-01f,
100 3.3333668112754822e-01f,
101 -4.9999997019767761e-01f,
105 Packet f2 = pmul(f, f);
106 Packet p = ppolevl<Packet, 7>::run(f, coeffs);
107 log_mantissa = pmadd(p, f2, f);
115template <
typename Packet,
bool base2>
116EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet plog_impl_float(
const Packet _x) {
117 Packet log_mantissa, e;
118 const bool any_special = plog_core_float(_x, log_mantissa, e);
123 const Packet cst_log2e = pset1<Packet>(
static_cast<float>(EIGEN_LOG2E));
124 x = pmadd(log_mantissa, cst_log2e, e);
126 const Packet cst_ln2 = pset1<Packet>(
static_cast<float>(EIGEN_LN2));
127 x = pmadd(e, cst_ln2, log_mantissa);
129 if (!any_special)
return x;
135 const Packet cst_minus_inf = por(psignmask<Packet>(), pinf<Packet>());
136 const Packet cst_pos_inf = pinf<Packet>();
137 Packet invalid_mask = pcmp_lt_or_nan(_x, pzero(_x));
138 Packet iszero_mask = pcmp_eq(_x, pzero(_x));
139 Packet pos_inf_mask = pcmp_eq(_x, cst_pos_inf);
140 return pselect(iszero_mask, cst_minus_inf, por(pselect(pos_inf_mask, cst_pos_inf, x), invalid_mask));
143template <
typename Packet>
144EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet plog_float(
const Packet _x) {
145 return plog_impl_float<Packet,
false>(_x);
148template <
typename Packet>
149EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet plog2_float(
const Packet _x) {
150 return plog_impl_float<Packet,
true>(_x);
161template <
typename Packet>
162EIGEN_STRONG_INLINE Packet plog_mantissa_double(
const Packet x) {
163 const Packet cst_cephes_log_p0 = pset1<Packet>(1.01875663804580931796E-4);
164 const Packet cst_cephes_log_p1 = pset1<Packet>(4.97494994976747001425E-1);
165 const Packet cst_cephes_log_p2 = pset1<Packet>(4.70579119878881725854E0);
166 const Packet cst_cephes_log_p3 = pset1<Packet>(1.44989225341610930846E1);
167 const Packet cst_cephes_log_p4 = pset1<Packet>(1.79368678507819816313E1);
168 const Packet cst_cephes_log_p5 = pset1<Packet>(7.70838733755885391666E0);
170 const Packet cst_cephes_log_q1 = pset1<Packet>(1.12873587189167450590E1);
171 const Packet cst_cephes_log_q2 = pset1<Packet>(4.52279145837532221105E1);
172 const Packet cst_cephes_log_q3 = pset1<Packet>(8.29875266912776603211E1);
173 const Packet cst_cephes_log_q4 = pset1<Packet>(7.11544750618563894466E1);
174 const Packet cst_cephes_log_q5 = pset1<Packet>(2.31251620126765340583E1);
176 Packet x2 = pmul(x, x);
177 Packet x3 = pmul(x2, x);
181 y = pmadd(cst_cephes_log_p0, x, cst_cephes_log_p1);
182 y1 = pmadd(cst_cephes_log_p3, x, cst_cephes_log_p4);
183 y = pmadd(y, x, cst_cephes_log_p2);
184 y1 = pmadd(y1, x, cst_cephes_log_p5);
185 y_ = pmadd(y, x3, y1);
187 y = padd(x, cst_cephes_log_q1);
188 y1 = pmadd(cst_cephes_log_q3, x, cst_cephes_log_q4);
189 y = pmadd(y, x, cst_cephes_log_q2);
190 y1 = pmadd(y1, x, cst_cephes_log_q5);
191 y = pmadd(y, x3, y1);
195 y = pnmadd(pset1<Packet>(0.5), x2, y);
200template <
typename Packet,
typename =
void>
201struct packet_has_integer_packet : std::false_type {};
202template <
typename Packet>
203struct packet_has_integer_packet<Packet, void_t<typename unpacket_traits<Packet>::integer_packet>> : std::true_type {};
208template <
typename Packet,
bool UseIntegerPacket>
209struct plog_range_reduce_double {
210 EIGEN_STRONG_INLINE
static bool run(
const Packet v, Packet& f, Packet& e) {
211 const Packet one = pset1<Packet>(1.0);
212 const Packet cst_cephes_SQRTHF = pset1<Packet>(0.70710678118654752440E0);
218 Packet mask = pcmp_lt(f, cst_cephes_SQRTHF);
219 Packet tmp = pand(f, mask);
221 e = psub(e, pand(one, mask));
229template <
typename Packet>
230struct plog_range_reduce_double<Packet, true> {
231 EIGEN_STRONG_INLINE
static bool run(
const Packet v, Packet& f, Packet& e) {
232 using PacketI =
typename unpacket_traits<Packet>::integer_packet;
234 const PacketI cst_min_normal = pset1<PacketI>(
static_cast<int64_t
>(0x0010000000000000LL));
236 const PacketI cst_mant_mask = pset1<PacketI>(
static_cast<int64_t
>(0x000FFFFFFFFFFFFFLL));
242 const PacketI cst_sqrt_half_offset =
243 pset1<PacketI>(
static_cast<int64_t
>(0x3FF0000000000000LL - 0x3FE6A09E667F3BCDLL));
245 const PacketI cst_exp_bias = pset1<PacketI>(
static_cast<int64_t
>(1023));
247 const PacketI cst_half_mant = pset1<PacketI>(
static_cast<int64_t
>(0x3FE6A09E667F3BCDLL));
250 PacketI vi = preinterpret<PacketI>(v);
253 const PacketI is_denormal = pcmp_lt(vi, cst_min_normal);
254 const bool any_special = predux_any(preinterpret<Packet>(
255 por(is_denormal, pcmp_lt(pset1<PacketI>(
static_cast<int64_t
>(0x7FEFFFFFFFFFFFFFLL)), vi))));
259 Packet v_norm = pmul(v, pset1frombits<Packet>(
static_cast<uint64_t
>(int64_t(52 + 0x3ff) << 52)));
260 vi = pselect(is_denormal, preinterpret<PacketI>(v_norm), vi);
265 PacketI vi_biased = padd(vi, cst_sqrt_half_offset);
268 PacketI e_int = psub(plogical_shift_right<52>(vi_biased), cst_exp_bias);
269 if (any_special) e_int = psub(e_int, pand(is_denormal, pset1<PacketI>(
static_cast<int64_t
>(52))));
271 e = pcast<PacketI, Packet>(e_int);
277 f = psub(preinterpret<Packet>(padd(pand(vi_biased, cst_mant_mask), cst_half_mant)), pset1<Packet>(1.0));
289template <
typename Packet>
290EIGEN_STRONG_INLINE
bool plog_core_double(
const Packet v, Packet& log_mantissa, Packet& e) {
292 const bool any_special = plog_range_reduce_double<Packet, packet_has_integer_packet<Packet>::value>::run(v, f, e);
293 log_mantissa = plog_mantissa_double(f);
306template <
typename Packet,
bool base2>
307EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet plog_impl_double(
const Packet _x) {
308 const Packet cst_minus_inf = por(psignmask<Packet>(), pinf<Packet>());
309 const Packet cst_pos_inf = pinf<Packet>();
311 Packet log_mantissa, e;
312 const bool any_special = plog_core_double(_x, log_mantissa, e);
317 const Packet cst_log2e = pset1<Packet>(
static_cast<double>(EIGEN_LOG2E));
318 x = pmadd(log_mantissa, cst_log2e, e);
320 const Packet cst_ln2 = pset1<Packet>(
static_cast<double>(EIGEN_LN2));
321 x = pmadd(e, cst_ln2, log_mantissa);
323 if (!any_special)
return x;
325 Packet invalid_mask = pcmp_lt_or_nan(_x, pzero(_x));
326 Packet iszero_mask = pcmp_eq(_x, pzero(_x));
327 Packet pos_inf_mask = pcmp_eq(_x, cst_pos_inf);
332 return pselect(iszero_mask, cst_minus_inf, por(pselect(pos_inf_mask, cst_pos_inf, x), invalid_mask));
335template <
typename Packet>
336EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet plog_double(
const Packet _x) {
337 return plog_impl_double<Packet,
false>(_x);
340template <
typename Packet>
341EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet plog2_double(
const Packet _x) {
342 return plog_impl_double<Packet,
true>(_x);
351template <
typename Packet>
352EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet generic_log1p_float(
const Packet& x) {
353 const Packet one = pset1<Packet>(1.0f);
354 const Packet cst_minus_inf = por(psignmask<Packet>(), pinf<Packet>());
355 const Packet cst_pos_inf = pinf<Packet>();
358 Packet u = padd(one, x);
359 Packet dx = psub(x, psub(u, one));
362 Packet small_mask = pcmp_eq(u, one);
366 const bool any_special = plog_core_float(u, log_u, e);
370 const Packet cst_ln2 = pset1<Packet>(
static_cast<float>(EIGEN_LN2));
371 Packet result = pmadd(e, cst_ln2, padd(log_u, pdiv(dx, u)));
372 result = pselect(small_mask, x, result);
374 if (!any_special)
return result;
378 Packet inf_mask = pcmp_eq(u, cst_pos_inf);
379 Packet neg_mask = pcmp_lt(u, pzero(u));
380 Packet zero_mask = pcmp_eq(x, pset1<Packet>(-1.0f));
381 result = pselect(inf_mask, cst_pos_inf, result);
382 result = pselect(zero_mask, cst_minus_inf, result);
383 result = por(neg_mask, result);
393template <
typename Packet>
394EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet generic_log1p_double(
const Packet& x) {
395 const Packet one = pset1<Packet>(1.0);
396 const Packet cst_minus_inf = por(psignmask<Packet>(), pinf<Packet>());
397 const Packet cst_pos_inf = pinf<Packet>();
400 Packet u = padd(one, x);
401 Packet dx = psub(x, psub(u, one));
404 Packet small_mask = pcmp_eq(u, one);
408 const bool any_special = plog_core_double(u, log_u, e);
412 const Packet cst_ln2 = pset1<Packet>(
static_cast<double>(EIGEN_LN2));
413 Packet result = pmadd(e, cst_ln2, padd(log_u, pdiv(dx, u)));
414 result = pselect(small_mask, x, result);
416 if (!any_special)
return result;
420 Packet inf_mask = pcmp_eq(u, cst_pos_inf);
421 Packet neg_mask = pcmp_lt(u, pzero(u));
422 Packet zero_mask = pcmp_eq(x, pset1<Packet>(-1.0));
423 result = pselect(inf_mask, cst_pos_inf, result);
424 result = pselect(zero_mask, cst_minus_inf, result);
425 result = por(neg_mask, result);
433template <
typename Packet>
434EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet generic_log1p(
const Packet& x) {
435 using ScalarType =
typename unpacket_traits<Packet>::type;
436 const Packet one = pset1<Packet>(ScalarType(1));
437 Packet xp1 = padd(x, one);
438 Packet small_mask = pcmp_eq(xp1, one);
439 Packet log1 = plog(xp1);
440 Packet inf_mask = pcmp_eq(xp1, log1);
441 Packet log_large = pmul(x, pdiv(log1, psub(xp1, one)));
442 return pselect(por(small_mask, inf_mask), x, log_large);
446template <
typename Packet>
447EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet pexp_float_reduced(
const Packet& r) {
448 const Packet cst_one = pset1<Packet>(1.0f);
449 const Packet cst_p2 = pset1<Packet>(0.49999988079071044921875f);
450 const Packet cst_p3 = pset1<Packet>(0.16666518151760101318359375f);
451 const Packet cst_p4 = pset1<Packet>(4.166965186595916748046875e-2f);
452 const Packet cst_p5 = pset1<Packet>(8.36894474923610687255859375e-3f);
453 const Packet cst_p6 = pset1<Packet>(1.37449637986719608306884765625e-3f);
455 const Packet r2 = pmul(r, r);
456 Packet p_even = pmadd(r2, cst_p6, cst_p4);
457 const Packet p_odd = pmadd(r2, cst_p5, cst_p3);
458 p_even = pmadd(r2, p_even, cst_p2);
459 const Packet p_low = padd(r, cst_one);
460 const Packet y = pmadd(r, p_odd, p_even);
461 return pmadd(r2, y, p_low);
466template <
typename Packet>
467EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet pexpm1_float_reduced(
const Packet& r) {
468 const Packet cst_p2 = pset1<Packet>(0.5f);
469 const Packet cst_p3 = pset1<Packet>(0.1666666567325592041015625f);
470 const Packet cst_p4 = pset1<Packet>(4.16664779186248779296875e-2f);
471 const Packet cst_p5 = pset1<Packet>(8.333566598594188690185546875e-3f);
472 const Packet cst_p6 = pset1<Packet>(1.393371261656284332275390625e-3f);
473 const Packet cst_p7 = pset1<Packet>(1.97434448637068271636962890625e-4f);
475 const Packet r2 = pmul(r, r);
476 Packet p_even = pmadd(r2, cst_p6, cst_p4);
477 Packet p_odd = pmadd(r2, cst_p7, cst_p5);
478 p_even = pmadd(r2, p_even, cst_p2);
479 p_odd = pmadd(r2, p_odd, cst_p3);
480 const Packet y = pmadd(r, p_odd, p_even);
481 return pmadd(r2, y, r);
488template <
typename Packet,
bool IsFinite>
489EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pexp_float(
const Packet _x) {
490 using PacketI =
typename unpacket_traits<Packet>::integer_packet;
492 const Packet cst_exp_hi = pset1<Packet>(88.723f);
493 const Packet cst_exp_lo = pset1<Packet>(-104.f);
495 const Packet cst_cephes_LOG2EF = pset1<Packet>(1.44269504088896341f);
498 Packet x = pmin(pmax(_x, cst_exp_lo), cst_exp_hi);
502 Packet m = print(pmul(x, cst_cephes_LOG2EF));
506 const Packet cst_cephes_exp_C1 = pset1<Packet>(-0.693359375f);
507 const Packet cst_cephes_exp_C2 = pset1<Packet>(2.12194440e-4f);
508 Packet r = pmadd(m, cst_cephes_exp_C1, x);
509 r = pmadd(m, cst_cephes_exp_C2, r);
511 Packet y = pexp_float_reduced(r);
526 const PacketI cst_double_bias = pset1<PacketI>(254);
527 const PacketI mi = pcast<Packet, PacketI>(m);
528 const PacketI biased_sum = padd(mi, cst_double_bias);
529 const PacketI biased_hi = plogical_shift_right<1>(biased_sum);
530 const PacketI biased_lo = psub(biased_sum, biased_hi);
531 const Packet pow2_hi = preinterpret<Packet>(plogical_shift_left<23>(biased_hi));
532 const Packet pow2_lo = preinterpret<Packet>(plogical_shift_left<23>(biased_lo));
533 y = pmul(pmul(y, pow2_hi), pow2_lo);
535 EIGEN_IF_CONSTEXPR (!IsFinite) {
543template <
typename Packet>
544EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet pexp_double_reduced(
const Packet& g) {
545 const Packet cst_1 = pset1<Packet>(1.0);
546 const Packet cst_2 = pset1<Packet>(2.0);
547 const Packet cst_cephes_exp_p0 = pset1<Packet>(1.26177193074810590878e-4);
548 const Packet cst_cephes_exp_p1 = pset1<Packet>(3.02994407707441961300e-2);
549 const Packet cst_cephes_exp_p2 = pset1<Packet>(9.99999999999999999910e-1);
550 const Packet cst_cephes_exp_q0 = pset1<Packet>(3.00198505138664455042e-6);
551 const Packet cst_cephes_exp_q1 = pset1<Packet>(2.52448340349684104192e-3);
552 const Packet cst_cephes_exp_q2 = pset1<Packet>(2.27265548208155028766e-1);
553 const Packet cst_cephes_exp_q3 = pset1<Packet>(2.00000000000000000009e0);
555 const Packet x2 = pmul(g, g);
558 Packet px = cst_cephes_exp_p0;
559 px = pmadd(px, x2, cst_cephes_exp_p1);
560 px = pmadd(px, x2, cst_cephes_exp_p2);
564 Packet qx = cst_cephes_exp_q0;
565 qx = pmadd(qx, x2, cst_cephes_exp_q1);
566 qx = pmadd(qx, x2, cst_cephes_exp_q2);
567 qx = pmadd(qx, x2, cst_cephes_exp_q3);
570 return pmadd(cst_2, pdiv(px, psub(qx, px)), cst_1);
576template <
typename Packet>
577EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet pexpm1_double_reduced(
const Packet& r) {
578 const Packet cst_p2 = pset1<Packet>(0.5);
579 const Packet cst_p3 = pset1<Packet>(0.16666666666666677);
580 const Packet cst_p4 = pset1<Packet>(0.04166666666666661);
581 const Packet cst_p5 = pset1<Packet>(0.008333333333321436);
582 const Packet cst_p6 = pset1<Packet>(0.0013888888888923816);
583 const Packet cst_p7 = pset1<Packet>(0.00019841269886601229);
584 const Packet cst_p8 = pset1<Packet>(2.480158723753082e-05);
585 const Packet cst_p9 = pset1<Packet>(2.7557243734579987e-06);
586 const Packet cst_p10 = pset1<Packet>(2.7557352849435147e-07);
587 const Packet cst_p11 = pset1<Packet>(2.510920369520403e-08);
588 const Packet cst_p12 = pset1<Packet>(2.0889530999828774e-09);
591 const Packet r2 = pmul(r, r);
592 Packet p_even = pmadd(r2, cst_p12, cst_p10);
593 Packet p_odd = pmadd(r2, cst_p11, cst_p9);
594 p_even = pmadd(r2, p_even, cst_p8);
595 p_odd = pmadd(r2, p_odd, cst_p7);
596 p_even = pmadd(r2, p_even, cst_p6);
597 p_odd = pmadd(r2, p_odd, cst_p5);
598 p_even = pmadd(r2, p_even, cst_p4);
599 p_odd = pmadd(r2, p_odd, cst_p3);
600 p_even = pmadd(r2, p_even, cst_p2);
601 const Packet y = pmadd(r, p_odd, p_even);
602 return pmadd(r2, y, r);
605template <
typename Packet>
606EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet pexp_double(
const Packet _x) {
607 const Packet cst_exp_hi = pset1<Packet>(709.784);
608 const Packet cst_exp_lo = pset1<Packet>(-745.519);
609 const Packet cst_pldexp_threshold = pset1<Packet>(708.0);
610 const Packet cst_cephes_LOG2EF = pset1<Packet>(1.4426950408889634073599);
611 const Packet cst_cephes_exp_C1 = pset1<Packet>(0.693145751953125);
612 const Packet cst_cephes_exp_C2 = pset1<Packet>(1.42860682030941723212e-6);
615 Packet zero_mask = pcmp_lt(_x, cst_exp_lo);
616 Packet x = pmin(_x, cst_exp_hi);
620 Packet fx = print(pmul(x, cst_cephes_LOG2EF));
625 x = pnmadd(fx, cst_cephes_exp_C1, x);
626 x = pnmadd(fx, cst_cephes_exp_C2, x);
628 x = pexp_double_reduced(x);
632 const Packet fast_pldexp_unsafe = pcmp_lt(cst_pldexp_threshold, pabs(_x));
633 if (!predux_any(fast_pldexp_unsafe)) {
636 return pmax(pldexp_fast(x, fx), _x);
638 return pandnot(pmax(pldexp(x, fx), _x), zero_mask);
641template <typename Packet, typename Scalar = typename unpacket_traits<Packet>::type>
642struct pexp_reduced_impl;
643template <
typename Packet>
644struct pexp_reduced_impl<Packet, float> {
645 static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet run(
const Packet& r) {
return pexp_float_reduced(r); }
647template <
typename Packet>
648struct pexp_reduced_impl<Packet, double> {
649 static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet run(
const Packet& r) {
return pexp_double_reduced(r); }
654template <typename Packet, typename Scalar = typename unpacket_traits<Packet>::type>
655struct pexpm1_reduced_impl;
656template <
typename Packet>
657struct pexpm1_reduced_impl<Packet, float> {
658 static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet run(
const Packet& r) {
return pexpm1_float_reduced(r); }
659 static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
float ln2_hi() {
return 0.693359375f; }
660 static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
float ln2_lo() {
return -2.12194440e-4f; }
662template <
typename Packet>
663struct pexpm1_reduced_impl<Packet, double> {
664 static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet run(
const Packet& r) {
return pexpm1_double_reduced(r); }
665 static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
double ln2_hi() {
return 0.693145751953125; }
666 static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE
double ln2_lo() {
return 1.42860682030941723212e-6; }
674template <
typename Packet>
675EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet generic_expm1(
const Packet& _x) {
676 using Scalar =
typename unpacket_traits<Packet>::type;
677 using Impl = pexpm1_reduced_impl<Packet>;
678 constexpr int max_exponent = std::numeric_limits<Scalar>::max_exponent;
679 constexpr int digits = std::numeric_limits<Scalar>::digits;
680 const Packet one = pset1<Packet>(Scalar(1));
682 const Scalar max_cap = Scalar(max_exponent + 1) * Scalar(EIGEN_LN2);
683 const Scalar min_cap = -Scalar(digits + 2) * Scalar(EIGEN_LN2);
684 const Packet x = pmax(pmin(_x, pset1<Packet>(max_cap)), pset1<Packet>(min_cap));
686 const Packet n = print(pmul(x, pset1<Packet>(Scalar(EIGEN_LOG2E))));
687 Packet r = pnmadd(n, pset1<Packet>(Impl::ln2_hi()), x);
688 r = pnmadd(n, pset1<Packet>(Impl::ln2_lo()), r);
689 const Packet em1 = Impl::run(r);
693 const Packet c = psub(one, pldexp_fast(one, pnegate(pmin(n, pset1<Packet>(Scalar(digits + 2))))));
696 Packet y = pldexp_fast(padd(em1, c), psub(n, one));
698 y = pmul(y, pset1<Packet>(Scalar(2)));
701 y = pselect(pcmp_lt(pabs(_x), pset1<Packet>(Scalar(0.25) * NumTraits<Scalar>::epsilon())), _x, y);
712template <
typename Packet>
713EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet generic_half_exp(
const Packet& _x) {
714 using Scalar =
typename unpacket_traits<Packet>::type;
715 using Impl = pexpm1_reduced_impl<Packet>;
716 constexpr int max_exponent = std::numeric_limits<Scalar>::max_exponent;
718 const Scalar max_cap = Scalar(max_exponent + 2) * Scalar(EIGEN_LN2);
719 const Packet x = pmin(_x, pset1<Packet>(max_cap));
721 const Packet n = print(pmul(x, pset1<Packet>(Scalar(EIGEN_LOG2E))));
722 Packet r = pnmadd(n, pset1<Packet>(Impl::ln2_hi()), x);
723 r = pnmadd(n, pset1<Packet>(Impl::ln2_lo()), r);
726 Packet y = pldexp_fast(pexp_reduced_impl<Packet>::run(r), psub(n, pset1<Packet>(Scalar(2))));
728 y = pmul(y, pset1<Packet>(Scalar(2)));
736template <
typename Packet>
737EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet generic_exp2_reduced(
const Packet& f) {
738 using Scalar =
typename unpacket_traits<Packet>::type;
740 const Scalar ln2_hi = Scalar(EIGEN_LN2);
741 const Scalar ln2_lo = Scalar((
static_cast<double>(EIGEN_LN2) -
double(ln2_hi)) + 2.3190468138462996e-17);
743 twoprod(pset1<Packet>(ln2_hi), f, r_hi, r_lo);
744 r_lo = pmadd(pset1<Packet>(ln2_lo), f, r_lo);
745 const Packet e = pexp_reduced_impl<Packet>::run(r_hi);
746 return pmadd(e, r_lo, e);
751template <
typename Packet>
752EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet generic_exp2(
const Packet& _x) {
753 using Scalar =
typename unpacket_traits<Packet>::type;
754 constexpr int max_exponent = std::numeric_limits<Scalar>::max_exponent;
755 constexpr int digits = std::numeric_limits<Scalar>::digits;
757 constexpr Scalar max_cap = Scalar(max_exponent + 1);
758 constexpr Scalar min_cap = -Scalar(max_exponent + digits - 1);
759 const Packet x = pmax(pmin(_x, pset1<Packet>(max_cap)), pset1<Packet>(min_cap));
760 const Packet n = print(x);
761 const Packet y = generic_exp2_reduced(psub(x, n));
765 if (!predux_any(pcmp_lt(pset1<Packet>(Scalar(max_exponent - 2)), pabs(n))))
return pldexp_fast(y, n);
766 const Packet h = print(pmul(n, pset1<Packet>(Scalar(0.5))));
767 Packet out = pldexp_fast(y, h);
769 return pldexp_fast(out, psub(n, h));
777template <
typename Packet>
778EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet plog10_float(
const Packet& x) {
781 const Packet cst_log10e_hi = pset1<Packet>(0.4342944920063018f);
782 const Packet cst_log10e_lo = pset1<Packet>(-1.0103049952192578e-08f);
783 const Packet cst_inf = pinf<Packet>();
784 const Packet cst_zero = pzero(x);
786 const Packet log_x = plog(x);
787 const Packet finite_mask = pcmp_lt(pabs(log_x), cst_inf);
788 const Packet finite_log_x = pselect(finite_mask, log_x, cst_zero);
789 const Packet split_log10_x = pmadd(finite_log_x, cst_log10e_hi, pmul(finite_log_x, cst_log10e_lo));
790 return pselect(finite_mask, split_log10_x, log_x);
796template <
typename Packet>
797EIGEN_DEFINE_FUNCTION_ALLOWING_MULTIPLE_DEFINITIONS Packet plog10_double(
const Packet& x) {
798 const Packet cst_log10e = pset1<Packet>(0.43429448190325182);
799 return pmul(plog(x), cst_log10e);
807#include "GenericPacketMathPow.h"
808#include "GenericPacketMathTrig.h"
809#include "GenericPacketMathComplex.h"
818template <typename Packet, typename Scalar = typename unpacket_traits<Packet>::type>
819struct psign_uses_binary_encoding
820 : bool_constant<!is_scalar<Packet>::value && packet_has_integer_packet<Packet>::value &&
821 (std::is_same<Scalar, float>::value || std::is_same<Scalar, double>::value)> {};
823template <
typename Packet>
824struct psign_impl<Packet, std::enable_if_t<psign_uses_binary_encoding<Packet>::value>> {
825 static EIGEN_DEVICE_FUNC
inline Packet run(
const Packet& a) {
826 using Scalar =
typename unpacket_traits<Packet>::type;
827 using PacketI =
typename unpacket_traits<Packet>::integer_packet;
828 using IntScalar =
typename unpacket_traits<PacketI>::type;
829 using Binary = binary_floating_point_traits<Scalar>;
833 const PacketI magnitude = pand(preinterpret<PacketI>(a), pset1<PacketI>(IntScalar(~Binary::kSignBit)));
834 const Packet is_zero = preinterpret<Packet>(pcmp_lt(magnitude, pset1<PacketI>(IntScalar(1))));
835 const Packet is_nan = preinterpret<Packet>(pcmp_lt(pset1<PacketI>(IntScalar(Binary::kExponentMask)), magnitude));
836 const Packet signed_one = por(pandnot(a, pabs(a)), pset1<Packet>(Scalar(1)));
837 return pselect(is_nan, a, pandnot(signed_one, is_zero));
841template <
typename Packet>
842struct psign_impl<Packet, std::enable_if_t<!psign_uses_binary_encoding<Packet>::value && !is_scalar<Packet>::value &&
843 !NumTraits<typename unpacket_traits<Packet>::type>::IsComplex &&
844 !NumTraits<typename unpacket_traits<Packet>::type>::IsInteger>> {
845 static EIGEN_DEVICE_FUNC
inline Packet run(
const Packet& a) {
846 using Scalar =
typename unpacket_traits<Packet>::type;
847 const Packet cst_one = pset1<Packet>(Scalar(1));
849 const Packet abs_a = pabs(a);
850 const Packet sign_mask = pandnot(a, abs_a);
851 const Packet zero_mask = pcmp_eq(abs_a, pzero(abs_a));
853 return pselect(pisnan(a), a, pselect(zero_mask, abs_a, por(sign_mask, cst_one)));
857template <
typename Packet>
858struct psign_impl<Packet, std::enable_if_t<!is_scalar<Packet>::value &&
859 !NumTraits<typename unpacket_traits<Packet>::type>::IsComplex &&
860 NumTraits<typename unpacket_traits<Packet>::type>::IsSigned &&
861 NumTraits<typename unpacket_traits<Packet>::type>::IsInteger>> {
862 static EIGEN_DEVICE_FUNC
inline Packet run(
const Packet& a) {
863 using Scalar =
typename unpacket_traits<Packet>::type;
864 const Packet cst_one = pset1<Packet>(Scalar(1));
865 const Packet cst_minus_one = pset1<Packet>(Scalar(-1));
866 const Packet cst_zero = pzero(a);
868 const Packet positive_mask = pcmp_lt(cst_zero, a);
869 const Packet positive = pand(positive_mask, cst_one);
870 const Packet negative_mask = pcmp_lt(a, cst_zero);
871 const Packet negative = pand(negative_mask, cst_minus_one);
873 return por(positive, negative);
877template <
typename Packet>
878struct psign_impl<Packet, std::enable_if_t<!is_scalar<Packet>::value &&
879 !NumTraits<typename unpacket_traits<Packet>::type>::IsComplex &&
880 !NumTraits<typename unpacket_traits<Packet>::type>::IsSigned &&
881 NumTraits<typename unpacket_traits<Packet>::type>::IsInteger>> {
882 static EIGEN_DEVICE_FUNC
inline Packet run(
const Packet& a) {
883 using Scalar =
typename unpacket_traits<Packet>::type;
884 const Packet cst_one = pset1<Packet>(Scalar(1));
885 const Packet cst_zero = pzero(a);
887 const Packet zero_mask = pcmp_eq(cst_zero, a);
888 return pandnot(cst_one, zero_mask);
893template <
typename Packet>
894struct psign_impl<Packet, std::enable_if_t<!is_scalar<Packet>::value &&
895 NumTraits<typename unpacket_traits<Packet>::type>::IsComplex &&
896 unpacket_traits<Packet>::vectorizable>> {
897 static EIGEN_DEVICE_FUNC
inline Packet run(
const Packet& a) {
898 using Scalar =
typename unpacket_traits<Packet>::type;
899 using RealScalar =
typename Scalar::value_type;
900 using RealPacket =
typename unpacket_traits<Packet>::as_real;
907 RealPacket a_abs = pabs(a.v);
908 RealPacket a_abs_flip = pcplxflip(Packet(a_abs)).v;
909 RealPacket a_max = pmax(a_abs, a_abs_flip);
910 RealPacket a_min = pmin(a_abs, a_abs_flip);
911 RealPacket a_min_zero_mask = pcmp_eq(a_min, pzero(a_min));
912 RealPacket a_max_zero_mask = pcmp_eq(a_max, pzero(a_max));
913 RealPacket r = pdiv(a_min, a_max);
914 const RealPacket cst_one = pset1<RealPacket>(RealScalar(1));
915 RealPacket l = pmul(a_max, psqrt(pmadd(r, r, cst_one)));
918 l = pselect(a_min_zero_mask, a_max, l);
920 RealPacket sign_as_real = pandnot(pdiv(a.v, l), a_max_zero_mask);
922 sign.v = sign_as_real;
931template <
typename Packet>
932EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet generic_rint(
const Packet& a) {
933 using Scalar =
typename unpacket_traits<Packet>::type;
934 using IntType =
typename numext::get_integer_by_size<
sizeof(Scalar)>::signed_type;
936 const IntType kLimit = IntType(1) << (NumTraits<Scalar>::digits() - 1);
937 const Packet cst_limit = pset1<Packet>(
static_cast<Scalar
>(kLimit));
938 Packet abs_a = pabs(a);
939 Packet sign_a = pandnot(a, abs_a);
940 Packet rint_a = padd(abs_a, cst_limit);
943 rint_a = psub(rint_a, cst_limit);
944 rint_a = por(rint_a, sign_a);
946 Packet mask = pcmp_lt(abs_a, cst_limit);
947 Packet result = pselect(mask, rint_a, a);
951template <
typename Packet>
952EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet generic_floor(
const Packet& a) {
953 using Scalar =
typename unpacket_traits<Packet>::type;
954 const Packet cst_1 = pset1<Packet>(Scalar(1));
955 Packet rint_a = generic_rint(a);
957 Packet mask = pcmp_lt(a, rint_a);
958 Packet offset = pand(cst_1, mask);
959 Packet result = psub(rint_a, offset);
963template <
typename Packet>
964EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet generic_ceil(
const Packet& a) {
965 using Scalar =
typename unpacket_traits<Packet>::type;
966 const Packet cst_1 = pset1<Packet>(Scalar(1));
967 const Packet sign_mask = psignmask<Packet>();
968 Packet rint_a = generic_rint(a);
970 Packet mask = pcmp_lt(rint_a, a);
971 Packet offset = pand(cst_1, mask);
972 Packet result = padd(rint_a, offset);
974 result = por(result, pand(sign_mask, a));
978template <
typename Packet>
979EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet generic_trunc(
const Packet& a) {
980 Packet abs_a = pabs(a);
981 Packet sign_a = pandnot(a, abs_a);
982 Packet floor_abs_a = generic_floor(abs_a);
983 Packet result = por(floor_abs_a, sign_a);
987template <
typename Packet>
988EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet generic_round(
const Packet& a) {
989 using Scalar =
typename unpacket_traits<Packet>::type;
990 const Packet cst_half = pset1<Packet>(Scalar(0.5));
991 const Packet cst_1 = pset1<Packet>(Scalar(1));
992 Packet abs_a = pabs(a);
993 Packet sign_a = pandnot(a, abs_a);
994 Packet floor_abs_a = generic_floor(abs_a);
995 Packet diff = psub(abs_a, floor_abs_a);
996 Packet mask = pcmp_le(cst_half, diff);
997 Packet offset = pand(cst_1, mask);
998 Packet result = padd(floor_abs_a, offset);
999 result = por(result, sign_a);
1003template <
typename Packet>
1004struct nearest_integer_packetop_impl<Packet, false, false> {
1005 using Scalar =
typename unpacket_traits<Packet>::type;
1006 static_assert(packet_traits<Scalar>::HasRound,
"Generic nearest integer functions are disabled for this type.");
1007 static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet run_floor(
const Packet& x) {
return generic_floor(x); }
1008 static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet run_ceil(
const Packet& x) {
return generic_ceil(x); }
1009 static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet run_rint(
const Packet& x) {
return generic_rint(x); }
1010 static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet run_round(
const Packet& x) {
return generic_round(x); }
1011 static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet run_trunc(
const Packet& x) {
return generic_trunc(x); }
1014template <
typename Packet>
1015struct nearest_integer_packetop_impl<Packet, false, true> {
1016 static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet run_floor(
const Packet& x) {
return x; }
1017 static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet run_ceil(
const Packet& x) {
return x; }
1018 static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet run_rint(
const Packet& x) {
return x; }
1019 static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet run_round(
const Packet& x) {
return x; }
1020 static EIGEN_DEVICE_FUNC EIGEN_STRONG_INLINE Packet run_trunc(
const Packet& x) {
return x; }