22 namespace ext::intel::experimental::esimd {
37 template <
typename T0,
typename T1,
int SZ,
typename U,
38 class Sat = __ESIMD_NS::saturation_off_tag>
39 __ESIMD_API std::enable_if_t<std::is_integral<T0>::value &&
40 std::is_integral<T1>::value &&
41 std::is_integral<U>::value,
42 __ESIMD_NS::simd<T0, SZ>>
43 shl(__ESIMD_NS::simd<T1, SZ> src0, U src1, Sat sat = {}) {
45 __ESIMD_DNS::computation_type_t<decltype(src0), int32_t>;
46 ComputationTy Src0 = src0;
47 ComputationTy Src1 = src1;
49 if constexpr (std::is_same_v<Sat, __ESIMD_NS::saturation_on_tag>) {
50 if constexpr (std::is_unsigned<T0>::value) {
51 if constexpr (std::is_unsigned<
52 typename ComputationTy::element_type>::value)
53 return __esimd_uushl_sat<T0, typename ComputationTy::element_type, SZ>(
54 Src0.data(), Src1.data());
56 return __esimd_usshl_sat<T0, typename ComputationTy::element_type, SZ>(
57 Src0.data(), Src1.data());
59 if constexpr (std::is_signed<typename ComputationTy::element_type>::value)
60 return __esimd_sushl_sat<T0, typename ComputationTy::element_type, SZ>(
61 Src0.data(), Src1.data());
63 return __esimd_ssshl_sat<T0, typename ComputationTy::element_type, SZ>(
64 Src0.data(), Src1.data());
67 if constexpr (std::is_unsigned<T0>::value) {
68 if constexpr (std::is_unsigned<
69 typename ComputationTy::element_type>::value)
70 return __esimd_uushl<T0, typename ComputationTy::element_type, SZ>(
71 Src0.data(), Src1.data());
73 return __esimd_usshl<T0, typename ComputationTy::element_type, SZ>(
74 Src0.data(), Src1.data());
76 if constexpr (std::is_signed<typename ComputationTy::element_type>::value)
77 return __esimd_sushl<T0, typename ComputationTy::element_type, SZ>(
78 Src0.data(), Src1.data());
80 return __esimd_ssshl<T0, typename ComputationTy::element_type, SZ>(
81 Src0.data(), Src1.data());
95 template <
typename T0,
typename T1,
typename T2,
96 class Sat = __ESIMD_NS::saturation_off_tag>
97 __ESIMD_API std::enable_if_t<__ESIMD_DNS::is_esimd_scalar<T0>::value &&
98 __ESIMD_DNS::is_esimd_scalar<T1>::value &&
99 __ESIMD_DNS::is_esimd_scalar<T2>::value &&
100 std::is_integral<T0>::value &&
101 std::is_integral<T1>::value &&
102 std::is_integral<T2>::value,
103 std::remove_const_t<T0>>
104 shl(T1 src0, T2 src1, Sat sat = {}) {
105 __ESIMD_NS::simd<T1, 1> Src0 = src0;
106 __ESIMD_NS::simd<T0, 1> Result =
107 esimd::shl<T0, T1, 1, T2, Sat>(Src0, src1, sat);
121 template <
typename T0,
typename T1,
int SZ,
typename U,
122 class Sat = __ESIMD_NS::saturation_off_tag>
123 __ESIMD_API std::enable_if_t<std::is_integral<T0>::value &&
124 std::is_integral<T1>::value &&
125 std::is_integral<U>::value,
126 __ESIMD_NS::simd<T0, SZ>>
127 lsr(__ESIMD_NS::simd<T1, SZ> src0, U src1, Sat sat = {}) {
128 using IntermedTy = __ESIMD_DNS::computation_type_t<T1, T1>;
129 typedef typename std::make_unsigned<IntermedTy>::type ComputationTy;
130 __ESIMD_NS::simd<ComputationTy, SZ> Src0 = src0;
131 __ESIMD_NS::simd<ComputationTy, SZ> Src1 = src1;
133 __ESIMD_NS::simd<ComputationTy, SZ> Result = Src0.data() >> Src1.data();
135 if constexpr (std::is_same_v<Sat, __ESIMD_NS::saturation_off_tag>)
138 return __ESIMD_NS::saturate<T0>(Result);
151 template <
typename T0,
typename T1,
typename T2,
152 class Sat = __ESIMD_NS::saturation_off_tag>
153 __ESIMD_API std::enable_if_t<__ESIMD_DNS::is_esimd_scalar<T0>::value &&
154 __ESIMD_DNS::is_esimd_scalar<T1>::value &&
155 __ESIMD_DNS::is_esimd_scalar<T2>::value &&
156 std::is_integral<T0>::value &&
157 std::is_integral<T1>::value &&
158 std::is_integral<T2>::value,
159 std::remove_const_t<T0>>
160 lsr(T1 src0, T2 src1, Sat sat = {}) {
161 __ESIMD_NS::simd<T1, 1> Src0 = src0;
162 __ESIMD_NS::simd<T0, 1> Result =
163 esimd::lsr<T0, T1, 1, T2, Sat>(Src0, src1, sat);
178 template <
typename T0,
typename T1,
int SZ,
typename U,
179 class Sat = __ESIMD_NS::saturation_off_tag>
180 __ESIMD_API std::enable_if_t<std::is_integral<T0>::value &&
181 std::is_integral<T1>::value &&
182 std::is_integral<U>::value,
183 __ESIMD_NS::simd<T0, SZ>>
184 asr(__ESIMD_NS::simd<T1, SZ> src0, U src1, Sat sat = {}) {
185 using IntermedTy = __ESIMD_DNS::computation_type_t<T1, T1>;
186 typedef typename std::make_signed<IntermedTy>::type ComputationTy;
187 __ESIMD_NS::simd<ComputationTy, SZ> Src0 = src0;
189 __ESIMD_NS::simd<ComputationTy, SZ> Result = Src0 >> src1;
191 if constexpr (std::is_same_v<Sat, __ESIMD_NS::saturation_off_tag>)
194 return __ESIMD_NS::saturate<T0>(Result);
207 template <
typename T0,
typename T1,
typename T2,
208 class Sat = __ESIMD_NS::saturation_off_tag>
209 __ESIMD_API std::enable_if_t<__ESIMD_DNS::is_esimd_scalar<T0>::value &&
210 __ESIMD_DNS::is_esimd_scalar<T1>::value &&
211 __ESIMD_DNS::is_esimd_scalar<T2>::value &&
212 std::is_integral<T0>::value &&
213 std::is_integral<T1>::value &&
214 std::is_integral<T2>::value,
215 std::remove_const_t<T0>>
216 asr(T1 src0, T2 src1, Sat sat = {}) {
217 __ESIMD_NS::simd<T1, 1> Src0 = src0;
218 __ESIMD_NS::simd<T0, 1> Result =
219 esimd::asr<T0, T1, 1, T2, Sat>(Src0, src1, sat);
233 template <
typename T0,
typename T1,
int SZ,
typename U,
234 class Sat = __ESIMD_NS::saturation_off_tag>
235 __ESIMD_API std::enable_if_t<std::is_integral<T0>::value &&
236 std::is_integral<T1>::value &&
237 std::is_integral<U>::value,
238 __ESIMD_NS::simd<T0, SZ>>
239 shr(__ESIMD_NS::simd<T1, SZ> src0, U src1, Sat sat = {}) {
240 if constexpr (std::is_unsigned<T1>::value) {
241 return esimd::lsr<T0, T1, SZ, U, Sat>(src0, src1, sat);
243 return esimd::asr<T0, T1, SZ, U, Sat>(src0, src1, sat);
256 template <
typename T0,
typename T1,
typename T2,
257 class Sat = __ESIMD_NS::saturation_off_tag>
258 __ESIMD_API std::enable_if_t<__ESIMD_DNS::is_esimd_scalar<T0>::value &&
259 __ESIMD_DNS::is_esimd_scalar<T1>::value &&
260 __ESIMD_DNS::is_esimd_scalar<T2>::value &&
261 std::is_integral<T0>::value &&
262 std::is_integral<T1>::value &&
263 std::is_integral<T2>::value,
264 std::remove_const_t<T0>>
265 shr(T1 src0, T2 src1, Sat sat = {}) {
266 __ESIMD_NS::simd<T1, 1> Src0 = src0;
267 __ESIMD_NS::simd<T0, 1> Result =
268 esimd::shr<T0, T1, 1, T2, Sat>(Src0, src1, sat);
280 template <
typename T0,
typename T1,
int SZ>
282 __ESIMD_NS::detail::is_type<T0, int16_t, uint16_t, int32_t, uint32_t,
284 __ESIMD_NS::detail::is_type<T1, int16_t, uint16_t, int32_t, uint32_t,
286 __ESIMD_NS::simd<T0, SZ>>
287 rol(__ESIMD_NS::simd<T1, SZ> src0, __ESIMD_NS::simd<T1, SZ> src1) {
288 return __esimd_rol<T0, T1, SZ>(src0.data(), src1.data());
299 template <
typename T0,
typename T1,
int SZ,
typename U>
301 __ESIMD_NS::detail::is_type<T0, int16_t, uint16_t, int32_t, uint32_t,
303 __ESIMD_NS::detail::is_type<T1, int16_t, uint16_t, int32_t, uint32_t,
305 __ESIMD_NS::detail::is_type<U, int16_t, uint16_t, int32_t, uint32_t,
307 __ESIMD_NS::simd<T0, SZ>>
308 rol(__ESIMD_NS::simd<T1, SZ> src0, U src1) {
309 __ESIMD_NS::simd<T1, SZ> Src1 = src1;
310 return esimd::rol<T0>(src0, Src1);
320 template <
typename T0,
typename T1,
typename T2>
322 __ESIMD_DNS::is_esimd_scalar<T0>::value &&
323 __ESIMD_DNS::is_esimd_scalar<T1>::value &&
324 __ESIMD_DNS::is_esimd_scalar<T2>::value &&
325 __ESIMD_NS::detail::is_type<T0, int16_t, uint16_t, int32_t, uint32_t,
327 __ESIMD_NS::detail::is_type<T1, int16_t, uint16_t, int32_t, uint32_t,
329 __ESIMD_NS::detail::is_type<T2, int16_t, uint16_t, int32_t, uint32_t,
331 std::remove_const_t<T0>>
333 __ESIMD_NS::simd<T1, 1> Src0 = src0;
334 __ESIMD_NS::simd<T0, 1> Result = esimd::rol<T0, T1, 1, T2>(Src0, src1);
346 template <
typename T0,
typename T1,
int SZ>
348 __ESIMD_NS::detail::is_type<T0, int16_t, uint16_t, int32_t, uint32_t,
350 __ESIMD_NS::detail::is_type<T1, int16_t, uint16_t, int32_t, uint32_t,
352 __ESIMD_NS::simd<T0, SZ>>
353 ror(__ESIMD_NS::simd<T1, SZ> src0, __ESIMD_NS::simd<T1, SZ> src1) {
354 return __esimd_ror<T0, T1, SZ>(src0.data(), src1.data());
365 template <
typename T0,
typename T1,
int SZ,
typename U>
367 __ESIMD_NS::detail::is_type<T0, int16_t, uint16_t, int32_t, uint32_t,
369 __ESIMD_NS::detail::is_type<T1, int16_t, uint16_t, int32_t, uint32_t,
371 __ESIMD_NS::detail::is_type<U, int16_t, uint16_t, int32_t, uint32_t,
373 __ESIMD_NS::simd<T0, SZ>>
374 ror(__ESIMD_NS::simd<T1, SZ> src0, U src1) {
375 __ESIMD_NS::simd<T1, SZ> Src1 = src1;
376 return esimd::ror<T0>(src0, Src1);
386 template <
typename T0,
typename T1,
typename T2>
388 __ESIMD_DNS::is_esimd_scalar<T0>::value &&
389 __ESIMD_DNS::is_esimd_scalar<T1>::value &&
390 __ESIMD_DNS::is_esimd_scalar<T2>::value &&
391 __ESIMD_NS::detail::is_type<T0, int16_t, uint16_t, int32_t, uint32_t,
393 __ESIMD_NS::detail::is_type<T1, int16_t, uint16_t, int32_t, uint32_t,
395 __ESIMD_NS::detail::is_type<T2, int16_t, uint16_t, int32_t, uint32_t,
397 std::remove_const_t<T0>>
399 __ESIMD_NS::simd<T1, 1> Src0 = src0;
400 __ESIMD_NS::simd<T0, 1> Result = esimd::ror<T0, T1, 1, T2>(Src0, src1);
410 #ifndef ESIMD_HAS_LONG_LONG
412 template <
typename T0,
typename T1,
typename U,
int SZ>
414 ESIMD_INLINE std::enable_if_t<__ESIMD_DNS::is_dword_type<T0>::value &&
415 __ESIMD_DNS::is_dword_type<T1>::value &&
416 __ESIMD_DNS::is_dword_type<U>::value,
417 __ESIMD_NS::simd<T0, SZ>>
418 imul(__ESIMD_NS::simd<T0, SZ> &rmd, __ESIMD_NS::simd<T1, SZ> src0, U src1) {
419 using ComputationTy = __ESIMD_DNS::computation_type_t<decltype(src0), U>;
420 ComputationTy Src0 = src0;
421 ComputationTy Src1 = src1;
423 if constexpr (std::is_unsigned<T0>::value)
424 return __esimd_umulh(Src0.data(), Src1.data());
426 return __esimd_smulh(Src0.data(), Src1.data());
433 template <
typename T0,
typename T1,
typename U,
int SZ>
435 std::enable_if_t<__ESIMD_DNS::is_dword_type<T0>::value &&
436 __ESIMD_DNS::is_dword_type<T1>::value &&
437 __ESIMD_DNS::is_dword_type<U>::value && SZ == 1,
438 __ESIMD_NS::simd<T0, SZ>>
439 imul(__ESIMD_NS::simd<T0, SZ> &rmd, __ESIMD_NS::simd<T1, SZ> src0, U src1) {
440 using ComputationTy =
441 __ESIMD_DNS::computation_type_t<decltype(rmd),
long long>;
442 ComputationTy Product = convert<long long>(src0);
444 rmd = Product.bit_cast_view<T0>().select<1, 1>[0];
445 return Product.bit_cast_view<T0>().select<1, 1>[1];
448 template <
typename T0,
typename T1,
typename U,
int SZ>
450 std::enable_if_t<__ESIMD_DNS::is_dword_type<T0>::value &&
451 __ESIMD_DNS::is_dword_type<T1>::value &&
452 __ESIMD_DNS::is_dword_type<U>::value && SZ != 1,
453 __ESIMD_NS::simd<T0, SZ>>
454 imul(__ESIMD_NS::simd<T0, SZ> &rmd, __ESIMD_NS::simd<T1, SZ> src0, U src1) {
455 using ComputationTy =
456 __ESIMD_DNS::computation_type_t<decltype(rmd),
long long>;
457 ComputationTy Product = convert<long long>(src0);
459 rmd = Product.bit_cast_view<T0>().select<SZ, 2>(0);
460 return Product.bit_cast_view<T0>().select<SZ, 2>(1);
465 template <
typename T0,
typename T1,
typename U,
int SZ>
466 __ESIMD_API std::enable_if_t<__ESIMD_DNS::is_esimd_scalar<U>::value,
467 __ESIMD_NS::simd<T0, SZ>>
468 imul(__ESIMD_NS::simd<T0, SZ> &rmd, U src0, __ESIMD_NS::simd<T1, SZ> src1) {
473 template <
typename T0,
typename T,
typename U>
475 ESIMD_INLINE std::enable_if_t<__ESIMD_DNS::is_esimd_scalar<T>::value &&
476 __ESIMD_DNS::is_esimd_scalar<U>::value &&
477 __ESIMD_DNS::is_esimd_scalar<T0>::value,
479 imul(__ESIMD_NS::simd<T0, 1> &rmd, T src0, U src1) {
480 __ESIMD_NS::simd<T, 1> src_0 = src0;
481 __ESIMD_NS::simd<U, 1> src_1 = src1;
482 __ESIMD_NS::simd<T0, 1> res =
483 esimd::imul(rmd, src_0.select_all(), src_1.select_all());
494 template <
typename T,
int SZ,
typename U>
496 std::enable_if_t<std::is_integral<T>::value && std::is_integral<U>::value,
497 __ESIMD_NS::simd<T, SZ>>
498 quot(__ESIMD_NS::simd<T, SZ> src0, U src1) {
508 template <
typename T0,
typename T1>
509 __ESIMD_API std::enable_if_t<__ESIMD_DNS::is_esimd_scalar<T0>::value &&
510 __ESIMD_DNS::is_esimd_scalar<T1>::value &&
511 std::is_integral<T0>::value &&
512 std::is_integral<T1>::value,
513 std::remove_const_t<T0>>
525 template <
typename T,
int SZ,
typename U>
527 std::enable_if_t<std::is_integral<T>::value && std::is_integral<U>::value,
528 __ESIMD_NS::simd<T, SZ>>
529 mod(__ESIMD_NS::simd<T, SZ> src0, U src1) {
539 template <
typename T0,
typename T1>
540 __ESIMD_API std::enable_if_t<__ESIMD_DNS::is_esimd_scalar<T0>::value &&
541 __ESIMD_DNS::is_esimd_scalar<T1>::value &&
542 std::is_integral<T0>::value &&
543 std::is_integral<T1>::value,
544 std::remove_const_t<T0>>
558 template <
typename T,
int SZ,
typename U>
560 std::enable_if_t<std::is_integral<T>::value && std::is_integral<U>::value,
561 __ESIMD_NS::simd<T, SZ>>
562 div(__ESIMD_NS::simd<T, SZ> &remainder, __ESIMD_NS::simd<T, SZ> src0,
564 remainder = src0 % src1;
577 template <
typename T,
int SZ,
typename U>
579 std::enable_if_t<std::is_integral<T>::value && std::is_integral<U>::value &&
580 __ESIMD_DNS::is_esimd_scalar<U>::value,
581 __ESIMD_NS::simd<T, SZ>>
582 div(__ESIMD_NS::simd<T, SZ> &remainder, U src0,
583 __ESIMD_NS::simd<T, SZ> src1) {
584 remainder = src0 % src1;
597 template <
typename RT,
typename T0,
typename T1>
599 ESIMD_INLINE std::enable_if_t<__ESIMD_DNS::is_esimd_scalar<RT>::value &&
600 __ESIMD_DNS::is_esimd_scalar<T0>::value &&
601 __ESIMD_DNS::is_esimd_scalar<T1>::value,
602 std::remove_const_t<RT>>
605 remainder[0] = src0 % src1;
610 #if defined(ESIMD_GEN7_5) || defined(ESIMD_GEN8) || defined(ESIMD_GEN8_5) || \
611 defined(ESIMD_GEN9) || defined(ESIMD_GEN9_5)
623 template <
typename T0,
typename T1,
int SZ,
typename U,
624 class Sat = __ESIMD_NS::saturation_off_tag>
625 __ESIMD_API __ESIMD_NS::simd<T0, SZ>
dp2(__ESIMD_NS::simd<T1, SZ> src0, U src1,
627 static_assert(SZ % 4 == 0,
"result size is not a multiple of 4");
628 __ESIMD_NS::simd<float, SZ> Src0 = src0;
629 __ESIMD_NS::simd<float, SZ> Src1 = src1;
630 __ESIMD_NS::simd<float, SZ> Result = __esimd_dp2(Src0.data(), Src1.data());
631 if constexpr (std::is_same_v<Sat, __ESIMD_NS::saturation_off_tag>)
634 return __ESIMD_NS::saturate<T0>(Result);
647 template <
typename T0,
typename T1,
int SZ,
typename U,
648 class Sat = __ESIMD_NS::saturation_off_tag>
649 __ESIMD_API __ESIMD_NS::simd<T0, SZ>
dp3(__ESIMD_NS::simd<T1, SZ> src0, U src1,
651 static_assert(SZ % 4 == 0,
"result size is not a multiple of 4");
652 __ESIMD_NS::simd<float, SZ> Src0 = src0;
653 __ESIMD_NS::simd<float, SZ> Src1 = src1;
654 __ESIMD_NS::simd<float, SZ> Result = __esimd_dp3(Src0.data(), Src1.data());
655 if constexpr (std::is_same_v<Sat, __ESIMD_NS::saturation_off_tag>)
658 return __ESIMD_NS::saturate<T0>(Result);
671 template <
typename T0,
typename T1,
int SZ,
typename U,
672 class Sat = __ESIMD_NS::saturation_off_tag>
673 __ESIMD_API __ESIMD_NS::simd<T0, SZ>
dp4(__ESIMD_NS::simd<T1, SZ> src0, U src1,
675 static_assert(SZ % 4 == 0,
"result size is not a multiple of 4");
676 __ESIMD_NS::simd<float, SZ> Src0 = src0;
677 __ESIMD_NS::simd<float, SZ> Src1 = src1;
678 __ESIMD_NS::simd<float, SZ> Result = __esimd_dp4(Src0.data(), Src1.data());
679 if constexpr (std::is_same_v<Sat, __ESIMD_NS::saturation_off_tag>)
682 return __ESIMD_NS::saturate<T0>(Result);
695 template <
typename T0,
typename T1,
typename U,
int SZ,
696 class Sat = __ESIMD_NS::saturation_off_tag>
697 __ESIMD_API __ESIMD_NS::simd<T0, SZ>
dph(__ESIMD_NS::simd<T1, SZ> src0, U src1,
699 static_assert(SZ % 4 == 0,
"result size is not a multiple of 4");
700 __ESIMD_NS::simd<float, SZ> Src0 = src0;
701 __ESIMD_NS::simd<float, SZ> Src1 = src1;
702 __ESIMD_NS::simd<float, SZ> Result = __esimd_dph(Src0.data(), Src1.data());
703 if constexpr (std::is_same_v<Sat, __ESIMD_NS::saturation_off_tag>)
706 return __ESIMD_NS::saturate<T0>(Result);
720 template <
typename RT,
typename T1,
typename T2,
int SZ,
721 class Sat = __ESIMD_NS::saturation_off_tag>
722 __ESIMD_API __ESIMD_NS::simd<RT, SZ>
line(__ESIMD_NS::simd<T1, 4> src0,
723 __ESIMD_NS::simd<T2, SZ> src1,
725 static_assert(SZ % 4 == 0,
"result size is not a multiple of 4");
727 __ESIMD_NS::simd<float, 4> Src0 = src0;
728 __ESIMD_NS::simd<float, SZ> Src1 = src1;
729 __ESIMD_NS::simd<float, SZ> Result = __esimd_line(Src0.data(), Src1.data());
731 __ESIMD_NS::simd<RT, SZ> Result;
732 if constexpr (std::is_same_v<Sat, __ESIMD_NS::saturation_off_tag>)
735 return __ESIMD_NS::saturate<RT>(Result);
749 template <
typename RT,
typename T,
int SZ,
750 class Sat = __ESIMD_NS::saturation_off_tag>
751 __ESIMD_API __ESIMD_NS::simd<RT, SZ>
752 line(
float P,
float Q, __ESIMD_NS::simd<T, SZ> src1, Sat sat = {}) {
753 __ESIMD_NS::simd<float, 4> Src0 = P;
755 return esimd::line<RT>(Src0, src1, sat);
780 template <
typename T0,
typename T1,
int SZ,
typename U,
781 class Sat = __ESIMD_NS::saturation_off_tag>
782 ESIMD_NODEBUG ESIMD_INLINE
783 std::enable_if_t<__ESIMD_DNS::is_fp_or_dword_type<T1>::value &&
784 std::is_floating_point<T1>::value &&
785 __ESIMD_DNS::is_fp_or_dword_type<U>::value &&
786 std::is_floating_point<U>::value,
787 __ESIMD_NS::simd<T0, SZ>>
788 dp2(__ESIMD_NS::simd<T1, SZ> src0, U src1, Sat sat = {}) {
789 static_assert(SZ % 4 == 0,
"result size is not a multiple of 4");
791 __ESIMD_NS::simd<float, SZ> Src1 = src1;
792 __ESIMD_NS::simd<float, SZ> Result;
794 for (
int i = 0; i < SZ; i += 4) {
795 Result.select<4, 1>(i) = src0[i] * Src1[i] + src0[i + 1] * Src1[i + 1];
797 if constexpr (std::is_same_v<Sat, __ESIMD_NS::saturation_off_tag>)
800 return __ESIMD_NS::saturate<T1>(Result);
813 template <
typename T0,
typename T1,
int SZ,
typename U,
814 class Sat = __ESIMD_NS::saturation_off_tag>
815 ESIMD_NODEBUG ESIMD_INLINE
816 std::enable_if_t<__ESIMD_DNS::is_fp_or_dword_type<T1>::value &&
817 std::is_floating_point<T1>::value &&
818 __ESIMD_DNS::is_fp_or_dword_type<U>::value &&
819 std::is_floating_point<U>::value,
820 __ESIMD_NS::simd<T0, SZ>>
821 dp3(__ESIMD_NS::simd<T1, SZ> src0, U src1, Sat sat = {}) {
822 static_assert(SZ % 4 == 0,
"result size is not a multiple of 4");
824 __ESIMD_NS::simd<float, SZ> Src1 = src1;
825 __ESIMD_NS::simd<float, SZ> Result;
827 for (
int i = 0; i < SZ; i += 4) {
828 Result.select<4, 1>(i) = src0[i] * Src1[i] + src0[i + 1] * Src1[i + 1] +
829 src0[i + 2] * Src1[i + 2];
831 if constexpr (std::is_same_v<Sat, __ESIMD_NS::saturation_off_tag>)
834 return __ESIMD_NS::saturate<T1>(Result);
847 template <
typename T0,
typename T1,
int SZ,
typename U,
848 class Sat = __ESIMD_NS::saturation_off_tag>
849 ESIMD_NODEBUG ESIMD_INLINE
850 std::enable_if_t<__ESIMD_DNS::is_fp_or_dword_type<T1>::value &&
851 std::is_floating_point<T1>::value &&
852 __ESIMD_DNS::is_fp_or_dword_type<U>::value &&
853 std::is_floating_point<U>::value,
854 __ESIMD_NS::simd<T0, SZ>>
855 dp4(__ESIMD_NS::simd<T1, SZ> src0, U src1, Sat sat = {}) {
856 static_assert(SZ % 4 == 0,
"result size is not a multiple of 4");
858 __ESIMD_NS::simd<T1, SZ> Src1 = src1;
859 __ESIMD_NS::simd<float, SZ> Result;
861 for (
int i = 0; i < SZ; i += 4) {
862 Result.select<4, 1>(i) = src0[i] * Src1[i] + src0[i + 1] * Src1[i + 1] +
863 src0[i + 2] * Src1[i + 2] +
864 src0[i + 3] * Src1[i + 3];
866 if constexpr (std::is_same_v<Sat, __ESIMD_NS::saturation_off_tag>)
869 return __ESIMD_NS::saturate<T1>(Result);
882 template <
typename T,
typename U,
int SZ,
883 class Sat = __ESIMD_NS::saturation_off_tag>
884 ESIMD_NODEBUG ESIMD_INLINE
885 std::enable_if_t<__ESIMD_DNS::is_fp_or_dword_type<T>::value &&
886 std::is_floating_point<T>::value &&
887 __ESIMD_DNS::is_fp_or_dword_type<U>::value &&
888 std::is_floating_point<U>::value,
889 __ESIMD_NS::simd<T, SZ>>
890 dph(__ESIMD_NS::simd<T, SZ> src0, U src1, Sat sat = {}) {
891 static_assert(SZ % 4 == 0,
"result size is not a multiple of 4");
893 __ESIMD_NS::simd<float, SZ> Src1 = src1;
894 __ESIMD_NS::simd<float, SZ> Result;
896 for (
int i = 0; i < SZ; i += 4) {
897 Result.select<4, 1>(i) = src0[i] * Src1[i] + src0[i + 1] * Src1[i + 1] +
898 src0[i + 2] * Src1[i + 2] + 1.0 * Src1[i + 3];
900 if constexpr (std::is_same_v<Sat, __ESIMD_NS::saturation_off_tag>)
903 return __ESIMD_NS::saturate<T>(Result);
916 template <
typename T,
int SZ,
class Sat = __ESIMD_NS::saturation_off_tag>
918 ESIMD_INLINE std::enable_if_t<__ESIMD_DNS::is_fp_or_dword_type<T>::value &&
919 std::is_floating_point<T>::value,
920 __ESIMD_NS::simd<T, SZ>>
921 line(__ESIMD_NS::simd<T, 4> src0, __ESIMD_NS::simd<T, SZ> src1,
923 static_assert(SZ % 4 == 0,
"result size is not a multiple of 4");
925 __ESIMD_NS::simd<T, SZ> Src1 = src1;
926 __ESIMD_NS::simd<T, SZ> Result;
928 for (
int i = 0; i < SZ; i += 4) {
929 Result.select<4, 1>(i) = src0[0] * src1[i] + src0[3];
932 if constexpr (std::is_same_v<Sat, __ESIMD_NS::saturation_off_tag>)
935 return __ESIMD_NS::saturate<T>(Result);
949 template <
typename T,
int SZ,
class Sat = __ESIMD_NS::saturation_off_tag>
951 ESIMD_INLINE std::enable_if_t<__ESIMD_DNS::is_fp_or_dword_type<T>::value &&
952 std::is_floating_point<T>::value,
953 __ESIMD_NS::simd<T, SZ>>
954 line(
float P,
float Q, __ESIMD_NS::simd<T, SZ> src1, Sat sat = {}) {
955 __ESIMD_NS::simd<T, 4> Src0 = P;
957 return esimd::line<T>(Src0, src1, sat);
968 template <
typename T,
int SZ>
969 __ESIMD_API __ESIMD_NS::simd<T, SZ>
frc(__ESIMD_NS::simd<T, SZ> src0) {
970 __ESIMD_NS::simd<float, SZ> Src0 = src0;
971 return __esimd_frc(Src0.data());
979 template <
typename T> __ESIMD_API T
frc(T src0) {
980 __ESIMD_NS::simd<T, 1> Src0 = src0;
981 __ESIMD_NS::simd<T, 1> Result = esimd::frc<T>(Src0);
986 template <
typename RT,
typename T0,
int SZ,
987 class Sat = __ESIMD_NS::saturation_off_tag>
988 __ESIMD_API __ESIMD_NS::simd<RT, SZ>
lzd(__ESIMD_NS::simd<T0, SZ> src0,
991 __ESIMD_NS::simd<__ESIMD_NS::uint, SZ> Src0 = src0;
992 return __esimd_lzd<__ESIMD_NS::uint, SZ>(Src0.data());
995 template <
typename RT,
typename T0,
class Sat = __ESIMD_NS::saturation_off_tag>
997 ESIMD_INLINE std::enable_if_t<__ESIMD_DNS::is_esimd_scalar<RT>::value &&
998 __ESIMD_DNS::is_esimd_scalar<T0>::value,
999 std::remove_const_t<RT>>
1001 __ESIMD_NS::simd<T0, 1> Src0 = src0;
1002 __ESIMD_NS::simd<RT, 1> Result = esimd::lzd<RT>(Src0);
1007 #if defined(ESIMD_GEN7_5) || defined(ESIMD_GEN8) || defined(ESIMD_GEN8_5) || \
1008 defined(ESIMD_GEN9) || defined(ESIMD_GEN9_5)
1010 template <
int SZ,
typename U,
typename V,
1011 class Sat = __ESIMD_NS::saturation_off_tag>
1012 __ESIMD_API __ESIMD_NS::simd<float, SZ>
lrp(__ESIMD_NS::simd<float, SZ> src0,
1013 U src1, V src2, Sat sat = {}) {
1014 static_assert(SZ >= 4 && (SZ & 0x3) == 0,
1015 "vector size must be a multiple of 4");
1016 __ESIMD_NS::simd<float, SZ> Src1 = src1;
1017 __ESIMD_NS::simd<float, SZ> Src2 = src2;
1018 __ESIMD_NS::simd<float, SZ> Result =
1019 __esimd_lrp<SZ>(src0.data(), Src1.data(), Src2.data());
1021 if constexpr (std::is_same_v<Sat, __ESIMD_NS::saturation_off_tag>)
1024 return __ESIMD_NS::saturate<float>(Result);
1038 template <
typename T,
int SZ,
typename U,
typename V,
1039 class Sat = __ESIMD_NS::saturation_off_tag>
1040 ESIMD_NODEBUG ESIMD_INLINE
1041 std::enable_if_t<__ESIMD_DNS::is_fp_or_dword_type<T>::value &&
1042 std::is_floating_point<T>::value &&
1043 __ESIMD_DNS::is_fp_or_dword_type<U>::value &&
1044 std::is_floating_point<U>::value,
1045 __ESIMD_NS::simd<T, SZ>>
1046 lrp(__ESIMD_NS::simd<T, SZ> src0, U src1, V src2, Sat sat = {}) {
1048 __ESIMD_NS::simd<float, SZ> Src1 = src1;
1049 __ESIMD_NS::simd<float, SZ> Src2 = src2;
1050 __ESIMD_NS::simd<float, SZ> Result;
1051 Result = Src1 * src0 + Src2 * (1.0f - src0);
1052 if constexpr (std::is_same_v<Sat, __ESIMD_NS::saturation_off_tag>)
1055 return __ESIMD_NS::saturate<T>(Result);
1065 template <
typename T0,
typename T1,
int SZ>
1066 __ESIMD_API __ESIMD_NS::simd<T0, SZ>
bf_reverse(__ESIMD_NS::simd<T1, SZ> src0) {
1067 __ESIMD_NS::simd<unsigned, SZ> Src0 = src0;
1068 return __esimd_bfrev<unsigned>(Src0.data());
1072 template <
typename T0,
typename T1>
1074 ESIMD_INLINE std::enable_if_t<__ESIMD_DNS::is_esimd_scalar<T0>::value &&
1075 __ESIMD_DNS::is_esimd_scalar<T1>::value,
1076 std::remove_const_t<T0>>
1078 __ESIMD_NS::simd<T1, 1> Src0 = src0;
1079 __ESIMD_NS::simd<T0, 1> Result = esimd::bf_reverse<T0>(Src0);
1084 template <
typename T0,
typename T1,
int SZ,
typename U,
typename V,
typename W>
1085 ESIMD_NODEBUG ESIMD_INLINE
1086 std::enable_if_t<std::is_integral<T1>::value, __ESIMD_NS::simd<T0, SZ>>
1087 bf_insert(U src0, V src1, W src2, __ESIMD_NS::simd<T1, SZ> src3) {
1088 typedef typename __ESIMD_DNS::dword_type<T1> DT1;
1089 static_assert(std::is_integral<DT1>::value &&
sizeof(DT1) ==
sizeof(
int),
1090 "operand conversion failed");
1091 __ESIMD_NS::simd<DT1, SZ> Src0 = src0;
1092 __ESIMD_NS::simd<DT1, SZ> Src1 = src1;
1093 __ESIMD_NS::simd<DT1, SZ> Src2 = src2;
1094 __ESIMD_NS::simd<DT1, SZ> Src3 = src3;
1096 return __esimd_bfi<DT1>(Src0.data(), Src1.data(), Src2.data(), Src3.data());
1100 template <
typename T0,
typename T1,
typename T2,
typename T3,
typename T4>
1102 ESIMD_INLINE std::enable_if_t<__ESIMD_DNS::is_esimd_scalar<T0>::value &&
1103 __ESIMD_DNS::is_esimd_scalar<T4>::value,
1104 std::remove_const_t<T0>>
1106 __ESIMD_NS::simd<T4, 1> Src3 = src3;
1107 __ESIMD_NS::simd<T0, 1> Result = esimd::bf_insert<T0>(src0, src1, src2, Src3);
1112 template <
typename T0,
typename T1,
int SZ,
typename U,
typename V>
1113 ESIMD_NODEBUG ESIMD_INLINE
1114 std::enable_if_t<std::is_integral<T1>::value, __ESIMD_NS::simd<T0, SZ>>
1116 typedef typename __ESIMD_DNS::dword_type<T1> DT1;
1117 static_assert(std::is_integral<DT1>::value &&
sizeof(DT1) ==
sizeof(
int),
1118 "operand conversion failed");
1119 __ESIMD_NS::simd<DT1, SZ> Src0 = src0;
1120 __ESIMD_NS::simd<DT1, SZ> Src1 = src1;
1121 __ESIMD_NS::simd<DT1, SZ> Src2 = src2;
1123 return __esimd_sbfe<DT1>(Src0.data(), Src1.data(), Src2.data());
1127 template <
typename T0,
typename T1,
typename T2,
typename T3>
1129 ESIMD_INLINE std::enable_if_t<__ESIMD_DNS::is_esimd_scalar<T0>::value &&
1130 __ESIMD_DNS::is_esimd_scalar<T3>::value,
1131 std::remove_const_t<T0>>
1133 __ESIMD_NS::simd<T3, 1> Src2 = src2;
1134 __ESIMD_NS::simd<T0, 1> Result = esimd::bf_extract<T0>(src0, src1, Src2);
1144 template <
int SZ,
typename U,
class Sat = __ESIMD_NS::saturation_off_tag>
1145 __ESIMD_API __ESIMD_NS::simd<float, SZ>
1146 sincos(__ESIMD_NS::simd<float, SZ> &dstcos, U src0, Sat sat = {}) {
1155 constexpr
double __ESIMD_CONST_PI = 3.1415926535897932384626433832795;
1159 template <
typename T,
int SZ>
1160 ESIMD_NODEBUG ESIMD_INLINE __ESIMD_NS::simd<T, SZ>
1161 atan(__ESIMD_NS::simd<T, SZ> src0) {
1162 static_assert(std::is_floating_point<T>::value,
1163 "Floating point argument type is expected.");
1166 __ESIMD_NS::simd<T, SZ> OneP((T)1.0);
1167 __ESIMD_NS::simd<T, SZ> OneN((T)-1.0);
1168 __ESIMD_NS::simd<T, SZ> sign;
1169 __ESIMD_NS::simd_mask<SZ> Gt1 = Src0 > T(1.0);
1171 sign.merge(OneN, OneP, src0 < 0);
1175 __ESIMD_NS::simd<T, SZ> Src0P2 = Src0 * Src0;
1176 __ESIMD_NS::simd<T, SZ> Src0P4 = Src0P2 * Src0P2;
1178 __ESIMD_NS::simd<T, SZ> Result =
1179 (Src0P4 * T(0.185696) + ((Src0 * T(0.787997) + T(0.63693)) * Src0P2) +
1181 (((((Src0 * -T(0.000121387) + T(0.00202308)) * Src0P2) +
1182 (Src0 * -T(0.0149145)) + T(0.182569)) *
1184 ((Src0 * T(0.395889) + T(1.12158)) * Src0P2) + (Src0 * T(0.636918)) +
1187 Result.merge(Result - T(detail::__ESIMD_CONST_PI) / T(2.0), Gt1);
1192 template <
typename T> __ESIMD_API T
atan(T src0) {
1193 static_assert(std::is_floating_point<T>::value,
1194 "Floating point argument type is expected.");
1195 __ESIMD_NS::simd<T, 1> Src0 = src0;
1196 __ESIMD_NS::simd<T, 1> Result =
esimd::atan(Src0);
1202 template <
typename T,
int SZ>
1203 ESIMD_NODEBUG ESIMD_INLINE
1204 std::enable_if_t<std::is_floating_point<T>::value, __ESIMD_NS::simd<T, SZ>>
1205 acos(__ESIMD_NS::simd<T, SZ> src0) {
1208 __ESIMD_NS::simd_mask<SZ> Neg = src0 < T(0.0);
1209 __ESIMD_NS::simd_mask<SZ> TooBig = Src0 >= T(0.999998);
1213 Src0.merge(T(0.0), TooBig);
1215 __ESIMD_NS::simd<T, SZ> Src01m = T(1.0) - Src0;
1217 __ESIMD_NS::simd<T, SZ> Src0P2 = Src01m * Src01m;
1218 __ESIMD_NS::simd<T, SZ> Src0P4 = Src0P2 * Src0P2;
1220 __ESIMD_NS::simd<T, SZ> Result =
1221 (((Src01m * T(0.015098965761299077) - T(0.005516443930088506)) * Src0P4) +
1222 ((Src01m * T(0.047654245891495528) + T(0.163910606547823220)) * Src0P2) +
1223 Src01m * T(2.000291665285952400) - T(0.000007239283986332)) *
1226 Result.merge(T(0.0), TooBig);
1227 Result.merge(T(detail::__ESIMD_CONST_PI) - Result, Neg);
1231 template <
typename T>
1232 __ESIMD_API std::enable_if_t<std::is_floating_point<T>::value, T>
acos(T src0) {
1233 __ESIMD_NS::simd<T, 1> Src0 = src0;
1234 __ESIMD_NS::simd<T, 1> Result =
esimd::acos(Src0);
1240 template <
typename T,
int SZ>
1241 ESIMD_NODEBUG ESIMD_INLINE
1242 std::enable_if_t<std::is_floating_point<T>::value, __ESIMD_NS::simd<T, SZ>>
1243 asin(__ESIMD_NS::simd<T, SZ> src0) {
1244 __ESIMD_NS::simd_mask<SZ> Neg = src0 < T(0.0);
1246 __ESIMD_NS::simd<T, SZ> Result =
1249 Result.merge(-Result, Neg);
1253 template <
typename T>
1254 __ESIMD_API std::enable_if_t<std::is_floating_point<T>::value, T>
asin(T src0) {
1255 __ESIMD_NS::simd<T, 1> Src0 = src0;
1256 __ESIMD_NS::simd<T, 1> Result =
esimd::asin(Src0);
1267 __ESIMD_NS::simd<float, N>
atan2_fast(__ESIMD_NS::simd<float, N> y,
1268 __ESIMD_NS::simd<float, N> x);
1275 __ESIMD_NS::simd<float, N>
atan2(__ESIMD_NS::simd<float, N> y,
1276 __ESIMD_NS::simd<float, N> x);
1278 template <
typename T>
float atan2(T y, T x);
1283 __ESIMD_NS::simd<float, N>
fmod(__ESIMD_NS::simd<float, N> y,
1284 __ESIMD_NS::simd<float, N> x);
1286 template <
typename T>
float fmod(T y, T x);
1291 __ESIMD_NS::simd<float, N>
sin_emu(__ESIMD_NS::simd<float, N> x);
1298 __ESIMD_NS::simd<float, N>
cos_emu(__ESIMD_NS::simd<float, N> x);
1308 __ESIMD_NS::simd<float, N>
tanh_cody_waite(__ESIMD_NS::simd<float, N> x);
1311 float tanh(
float x);
1313 template <
int N> __ESIMD_NS::simd<float, N>
tanh(__ESIMD_NS::simd<float, N> x);
1320 ESIMD_INLINE __ESIMD_NS::simd<float, N>
1321 atan2_fast(__ESIMD_NS::simd<float, N> y, __ESIMD_NS::simd<float, N> x) {
1323 constexpr
float CONST_DBL_EPSILON = 0.00001f;
1324 __ESIMD_NS::simd<float, N> OneP(1.0f);
1325 __ESIMD_NS::simd<float, N> OneN(-1.0f);
1326 __ESIMD_NS::simd<float, N> sign;
1327 __ESIMD_NS::simd<float, N>
atan2;
1328 __ESIMD_NS::simd<float, N>
r;
1329 __ESIMD_NS::simd_mask<N> mask = x < 0;
1330 __ESIMD_NS::simd<float, N> abs_y =
__ESIMD_NS::abs(y) + CONST_DBL_EPSILON;
1332 r.merge((x + abs_y) / (abs_y - x), (x - abs_y) / (x + abs_y), mask);
1333 atan2.merge(
float(detail::__ESIMD_CONST_PI) * 0.75f,
1334 float(detail::__ESIMD_CONST_PI) * 0.25f, mask);
1335 atan2 += (0.1963f *
r *
r - 0.9817f) *
r;
1337 sign.merge(OneN, OneP, y < 0);
1339 return atan2 * sign;
1344 __ESIMD_NS::simd<float, 1> vy = y;
1345 __ESIMD_NS::simd<float, 1> vx = x;
1353 ESIMD_INLINE __ESIMD_NS::simd<float, N>
atan2(__ESIMD_NS::simd<float, N> y,
1354 __ESIMD_NS::simd<float, N> x) {
1355 __ESIMD_NS::simd<float, N> v_distance;
1356 __ESIMD_NS::simd<float, N>
atan2;
1357 __ESIMD_NS::simd_mask<N> mask;
1359 constexpr
float CONST_DBL_EPSILON = 0.00001f;
1361 mask = (x < -CONST_DBL_EPSILON && y < CONST_DBL_EPSILON && y >= 0.f);
1362 atan2.merge(
float(detail::__ESIMD_CONST_PI), 0.f, mask);
1363 mask = (x < -CONST_DBL_EPSILON && y > -CONST_DBL_EPSILON && y < 0);
1364 atan2.merge(
float(-detail::__ESIMD_CONST_PI), mask);
1365 mask = (x < CONST_DBL_EPSILON &&
__ESIMD_NS::abs(y) > CONST_DBL_EPSILON);
1376 template <> ESIMD_INLINE
float atan2(
float y,
float x) {
1377 __ESIMD_NS::simd<float, 1> vy = y;
1378 __ESIMD_NS::simd<float, 1> vx = x;
1386 ESIMD_INLINE __ESIMD_NS::simd<float, N>
fmod(__ESIMD_NS::simd<float, N> y,
1387 __ESIMD_NS::simd<float, N> x) {
1391 auto fmod_sign_mask = (y.template bit_cast_view<int32_t>()) & 0x80000000;
1393 __ESIMD_NS::simd<float, N> reminder =
1394 abs_y - abs_x * __ESIMD_NS::trunc<float>(abs_y / abs_x);
1396 abs_x.merge(0.0f, reminder >= 0);
1397 __ESIMD_NS::simd<float, N>
fmod = reminder + abs_x;
1401 (fmod_abs.template bit_cast_view<int32_t>()) | fmod_sign_mask;
1402 return fmod_bits.template bit_cast_view<float>();
1406 template <> ESIMD_INLINE
float fmod(
float y,
float x) {
1407 return fmod(__ESIMD_NS::simd<float, 1>(y), __ESIMD_NS::simd<float, 1>(x))[0];
1413 ESIMD_INLINE __ESIMD_NS::simd<float, N>
sin_emu(__ESIMD_NS::simd<float, N> x) {
1414 __ESIMD_NS::simd<float, N> x1;
1415 __ESIMD_NS::simd<float, N> x2;
1416 __ESIMD_NS::simd<float, N> t3;
1418 __ESIMD_NS::simd<float, N> sign;
1419 __ESIMD_NS::simd<float, N> fTrig;
1420 __ESIMD_NS::simd<float, N> TwoPI(
float(detail::__ESIMD_CONST_PI) * 2.0f);
1421 __ESIMD_NS::simd<float, N> CmpI((
float)detail::__ESIMD_CONST_PI);
1422 __ESIMD_NS::simd<float, N> OneP(1.0f);
1423 __ESIMD_NS::simd<float, N> OneN(-1.0f);
1426 x.merge(TwoPI + x, x < 0);
1428 x1.merge(CmpI - x, x - CmpI, (x <=
float(detail::__ESIMD_CONST_PI)));
1429 x1.merge(x, (x <=
float(detail::__ESIMD_CONST_PI) * 0.5f));
1430 x1.merge(TwoPI - x, (x >
float(detail::__ESIMD_CONST_PI) * 1.5f));
1432 sign.merge(OneN, OneP, (x >
float(detail::__ESIMD_CONST_PI)));
1435 t3 = x2 * x1 * 0.1666667f;
1438 x1 + t3 * (OneN + x2 * 0.05f *
1439 (OneP + x2 * 0.0238095f *
1440 (OneN + x2 * 0.0138889f *
1441 (OneP - x2 * 0.0090909f))));
1447 template <> ESIMD_INLINE
float sin_emu(
float x0) {
1454 ESIMD_INLINE __ESIMD_NS::simd<float, N>
cos_emu(__ESIMD_NS::simd<float, N> x) {
1455 return esimd::sin_emu(0.5f *
float(detail::__ESIMD_CONST_PI) - x);
1459 template <> ESIMD_INLINE
float cos_emu(
float x0) {
1467 ESIMD_INLINE __ESIMD_NS::simd<float, N>
1468 tanh_cody_waite_impl(__ESIMD_NS::simd<float, N> x) {
1479 constexpr
float p0 = -0.8237728127E+00f;
1480 constexpr
float p1 = -0.3831010665E-02f;
1481 constexpr
float q0 = 0.2471319654E+01f;
1482 constexpr
float q1 = 1.0000000000E+00f;
1483 constexpr
float xsmall = 4.22863966691620432990E-04f;
1484 constexpr
float xmedium = 0.54930614433405484570f;
1485 constexpr
float xlarge = 8.66433975699931636772f;
1487 using RT = __ESIMD_NS::simd<float, N>;
1493 sign.merge(-1.f, 1.f, x < 0.f);
1495 auto isLarge = absX > xlarge;
1496 auto minor = absX <= xlarge;
1497 auto isGtMed = minor & (absX > xmedium);
1498 auto isGtSmall = (absX > xsmall) & (absX <= xmedium);
1501 res.merge(sign, x, isLarge);
1503 temp = ((temp - 2.f) / temp) * sign;
1504 res.merge(temp, isGtMed);
1505 res.merge((absX + absX * g * (g * p1 + p0) / (g + q0)) * sign, isGtSmall);
1511 ESIMD_INLINE __ESIMD_NS::simd<float, N>
1512 tanh_impl(__ESIMD_NS::simd<float, N> x) {
1519 constexpr
float xsmall = 0.000045f;
1520 constexpr
float xlarge = 40.f;
1522 using RT = __ESIMD_NS::simd<float, N>;
1527 sign.merge(-1.f, 1.f, x < 0.f);
1529 auto isLarge = (absX > xlarge);
1530 auto isLessE = (absX <= xlarge);
1533 res.merge(sign, x, isLarge);
1538 res.merge(((
exp - 1.f) / (
exp + 1.f)) * sign, (absX > xsmall) & isLessE);
1548 return detail::tanh_cody_waite_impl(__ESIMD_NS::simd<float, 1>(x))[0];
1552 ESIMD_INLINE __ESIMD_NS::simd<float, N>
1554 return detail::tanh_cody_waite_impl(x);
1560 return esimd::detail::tanh_impl(__ESIMD_NS::simd<float, 1>(x))[0];
1564 ESIMD_INLINE __ESIMD_NS::simd<float, N>
tanh(__ESIMD_NS::simd<float, N> x) {
1565 return esimd::detail::tanh_impl(x);
1568 template <
typename T,
int N>
1569 __ESIMD_NS::simd<T, N>
dp4(__ESIMD_NS::simd<T, N> v1,
1570 __ESIMD_NS::simd<T, N> v2) {
1571 auto retv = __esimd_dp4<T, N>(v1.data(), v2.data());
1593 template <argument_type src1_precision, argument_type src2_precision,
1594 typename T,
int systolic_depth,
int repeat_count,
typename T0,
1595 typename T1,
typename T2,
int N,
int N1,
int N2,
1596 typename Sat = __ESIMD_NS::saturation_off_tag>
1598 __ESIMD_API __ESIMD_NS::
simd<T, N> dpas(
1599 __ESIMD_NS::
simd<T0, N> src0, __ESIMD_NS::
simd<T1, N1> src1,
1600 __ESIMD_NS::
simd<T2, N2> src2,
1604 src1_precision, src2_precision>(src0, src1, src2);
1605 if constexpr (std::is_same_v<Sat, __ESIMD_NS::saturation_off_tag>)
1608 return __ESIMD_NS::saturate<T>(result);
1621 template <argument_type src1_precision, argument_type src2_precision,
1622 int systolic_depth,
int repeat_count,
typename T,
typename T1,
1623 typename T2,
int N,
int N1,
int N2,
1624 typename Sat = __ESIMD_NS::saturation_off_tag>
1626 __ESIMD_API __ESIMD_NS::
simd<T, N> dpas(
1627 __ESIMD_NS::
simd<T, N> src0, __ESIMD_NS::
simd<T1, N1> src1,
1628 __ESIMD_NS::
simd<T2, N2> src2,
1630 return dpas<src1_precision, src2_precision, T, systolic_depth, repeat_count>(
1631 src0, src1, src2, sat);
1642 template <argument_type src1_precision, argument_type src2_precision,
1643 int systolic_depth,
int repeat_count,
typename T,
typename T1,
1644 typename T2,
int N,
int N1,
int N2,
1645 typename Sat = __ESIMD_NS::saturation_off_tag>
1647 __ESIMD_API __ESIMD_NS::
simd<T, N> dpas(
1648 __ESIMD_NS::
simd<T1, N1> src1, __ESIMD_NS::
simd<T2, N2> src2,
1651 __ESIMD_NS::simd<T, N> result =
1653 src1_precision, src2_precision>(src1, src2);
1655 if constexpr (std::is_same_v<Sat, __ESIMD_NS::saturation_off_tag>)
1658 return __ESIMD_NS::saturate<T>(result);
1671 template <argument_type src1_precision, argument_type src2_precision,
1672 int systolic_depth,
int repeat_count,
typename T,
typename T1,
1673 typename T2,
int N,
int N1,
int N2,
1674 typename Sat = __ESIMD_NS::saturation_off_tag>
1677 __ESIMD_NS::
simd<T, N> src0, __ESIMD_NS::
simd<T1, N1> src1,
1678 __ESIMD_NS::
simd<T2, N2> src2,
1681 __ESIMD_NS::simd<T, N> result =
1683 src1_precision, src2_precision>(src0, src1, src2);
1684 if constexpr (std::is_same_v<Sat, __ESIMD_NS::saturation_off_tag>)
1687 return __ESIMD_NS::saturate<T>(result);
1698 template <argument_type src1_precision, argument_type src2_precision,
1699 int systolic_depth,
int repeat_count,
typename T,
typename T1,
1700 typename T2,
int N,
int N1,
int N2,
1701 typename Sat = __ESIMD_NS::saturation_off_tag>
1704 __ESIMD_NS::
simd<T1, N1> src1, __ESIMD_NS::
simd<T2, N2> src2,
1707 __ESIMD_NS::simd<T, N> result =
1709 src1_precision, src2_precision>(src1, src2);
1711 if constexpr (std::is_same_v<Sat, __ESIMD_NS::saturation_off_tag>)
1714 return __ESIMD_NS::saturate<T>(result);
#define __SYCL_INLINE_VER_NAMESPACE(X)
#define __SYCL_DEPRECATED(message)
__ESIMD_API std::enable_if_t< __ESIMD_DNS::is_esimd_scalar< T0 >::value &&__ESIMD_DNS::is_esimd_scalar< T1 >::value &&__ESIMD_DNS::is_esimd_scalar< T2 >::value &&std::is_integral< T0 >::value &&std::is_integral< T1 >::value &&std::is_integral< T2 >::value, std::remove_const_t< T0 > > shr(T1 src0, T2 src1, Sat sat={})
Shift right operation (scalar version)
__ESIMD_API std::enable_if_t< __ESIMD_DNS::is_esimd_scalar< T0 >::value &&__ESIMD_DNS::is_esimd_scalar< T1 >::value &&__ESIMD_DNS::is_esimd_scalar< T2 >::value &&sycl::ext::intel::esimd::detail::is_type< T0, int16_t, uint16_t, int32_t, uint32_t, int64_t, uint64_t >) &&sycl::ext::intel::esimd::detail::is_type< T1, int16_t, uint16_t, int32_t, uint32_t, int64_t, uint64_t >) &&sycl::ext::intel::esimd::detail::is_type< T2, int16_t, uint16_t, int32_t, uint32_t, int64_t, uint64_t >), std::remove_const_t< T0 > > ror(T1 src0, T2 src1)
Rotate right operation with two scalar inputs.
ESIMD_NODEBUG ESIMD_INLINE std::enable_if_t< __ESIMD_DNS::is_esimd_scalar< T0 >::value &&__ESIMD_DNS::is_esimd_scalar< T4 >::value, std::remove_const_t< T0 > > bf_insert(T1 src0, T2 src1, T3 src2, T4 src3)
bf_insert
ESIMD_NODEBUG ESIMD_INLINE std::enable_if_t< __ESIMD_DNS::is_esimd_scalar< T0 >::value &&__ESIMD_DNS::is_esimd_scalar< T1 >::value, std::remove_const_t< T0 > > bf_reverse(T1 src0)
bf_reverse
__ESIMD_API std::enable_if_t< __ESIMD_DNS::is_esimd_scalar< T0 >::value &&__ESIMD_DNS::is_esimd_scalar< T1 >::value &&__ESIMD_DNS::is_esimd_scalar< T2 >::value &&sycl::ext::intel::esimd::detail::is_type< T0, int16_t, uint16_t, int32_t, uint32_t, int64_t, uint64_t >) &&sycl::ext::intel::esimd::detail::is_type< T1, int16_t, uint16_t, int32_t, uint32_t, int64_t, uint64_t >) &&sycl::ext::intel::esimd::detail::is_type< T2, int16_t, uint16_t, int32_t, uint32_t, int64_t, uint64_t >), std::remove_const_t< T0 > > rol(T1 src0, T2 src1)
Rotate left operation with two scalar inputs.
__ESIMD_API std::enable_if_t< __ESIMD_DNS::is_esimd_scalar< T0 >::value &&__ESIMD_DNS::is_esimd_scalar< T1 >::value &&__ESIMD_DNS::is_esimd_scalar< T2 >::value &&std::is_integral< T0 >::value &&std::is_integral< T1 >::value &&std::is_integral< T2 >::value, std::remove_const_t< T0 > > lsr(T1 src0, T2 src1, Sat sat={})
Logical Shift Right (scalar version)
__ESIMD_API std::enable_if_t< __ESIMD_DNS::is_esimd_scalar< T0 >::value &&__ESIMD_DNS::is_esimd_scalar< T1 >::value &&__ESIMD_DNS::is_esimd_scalar< T2 >::value &&std::is_integral< T0 >::value &&std::is_integral< T1 >::value &&std::is_integral< T2 >::value, std::remove_const_t< T0 > > asr(T1 src0, T2 src1, Sat sat={})
Arithmetical Shift Right (scalar version)
ESIMD_NODEBUG ESIMD_INLINE std::enable_if_t< __ESIMD_DNS::is_esimd_scalar< T0 >::value &&__ESIMD_DNS::is_esimd_scalar< T3 >::value, std::remove_const_t< T0 > > bf_extract(T1 src0, T2 src1, T3 src2)
bf_extract
__ESIMD_API std::enable_if_t< __ESIMD_DNS::is_esimd_scalar< T0 >::value &&__ESIMD_DNS::is_esimd_scalar< T1 >::value &&__ESIMD_DNS::is_esimd_scalar< T2 >::value &&std::is_integral< T0 >::value &&std::is_integral< T1 >::value &&std::is_integral< T2 >::value, std::remove_const_t< T0 > > shl(T1 src0, T2 src1, Sat sat={})
Shift left operation (scalar version)
__ESIMD_API T cos(T src, Sat sat={})
Scalar version.
__ESIMD_API T inv(T src, Sat sat={})
Scalar version.
__ESIMD_API T sin(T src, Sat sat={})
Scalar version.
__ESIMD_API T frc(T src0)
Performs truncate-to-minus-infinity fraction operation of src0.
ESIMD_INLINE float sin_emu(float x0)
sycl::ext::intel::esimd::simd< T, N > dp4(sycl::ext::intel::esimd::simd< T, N > v1, sycl::ext::intel::esimd::simd< T, N > v2)
ESIMD_INLINE float fmod(float y, float x)
ESIMD_INLINE sycl::ext::intel::esimd::simd< float, N > tanh(sycl::ext::intel::esimd::simd< float, N > x)
ESIMD_NODEBUG ESIMD_INLINE std::enable_if_t< __ESIMD_DNS::is_fp_or_dword_type< T >::value &&std::is_floating_point< T >::value, sycl::ext::intel::esimd::simd< T, SZ > > line(float P, float Q, sycl::ext::intel::esimd::simd< T, SZ > src1, Sat sat={})
Linear equation.
ESIMD_NODEBUG ESIMD_INLINE std::enable_if_t< __ESIMD_DNS::is_esimd_scalar< T >::value &&__ESIMD_DNS::is_esimd_scalar< U >::value &&__ESIMD_DNS::is_esimd_scalar< T0 >::value, T0 > imul(sycl::ext::intel::esimd::simd< T0, 1 > &rmd, T src0, U src1)
__ESIMD_API T atan(T src0)
ESIMD_NODEBUG ESIMD_INLINE std::enable_if_t< __ESIMD_DNS::is_esimd_scalar< RT >::value &&__ESIMD_DNS::is_esimd_scalar< T0 >::value, std::remove_const_t< RT > > lzd(T0 src0, Sat sat={})
ESIMD_NODEBUG ESIMD_INLINE std::enable_if_t< __ESIMD_DNS::is_fp_or_dword_type< T1 >::value &&std::is_floating_point< T1 >::value &&__ESIMD_DNS::is_fp_or_dword_type< U >::value &&std::is_floating_point< U >::value, sycl::ext::intel::esimd::simd< T0, SZ > > dp3(sycl::ext::intel::esimd::simd< T1, SZ > src0, U src1, Sat sat={})
Dot product on groups of 4 elements.
ESIMD_NODEBUG ESIMD_INLINE std::enable_if_t< __ESIMD_DNS::is_esimd_scalar< RT >::value &&__ESIMD_DNS::is_esimd_scalar< T0 >::value &&__ESIMD_DNS::is_esimd_scalar< T1 >::value, std::remove_const_t< RT > > div(sycl::ext::intel::esimd::simd< std::remove_const_t< RT >, 1 > &remainder, T0 src0, T1 src1)
Integral division (scalar version).
ESIMD_INLINE float atan2(float y, float x)
__ESIMD_API sycl::ext::intel::esimd::simd< float, SZ > sincos(sycl::ext::intel::esimd::simd< float, SZ > &dstcos, U src0, Sat sat={})
__ESIMD_API std::enable_if_t< std::is_floating_point< T >::value, T > asin(T src0)
__ESIMD_API std::enable_if_t< __ESIMD_DNS::is_esimd_scalar< T0 >::value &&__ESIMD_DNS::is_esimd_scalar< T1 >::value &&std::is_integral< T0 >::value &&std::is_integral< T1 >::value, std::remove_const_t< T0 > > quot(T0 src0, T1 src1)
Integral quotient (scalar version)
ESIMD_NODEBUG ESIMD_INLINE std::enable_if_t< __ESIMD_DNS::is_fp_or_dword_type< T >::value &&std::is_floating_point< T >::value &&__ESIMD_DNS::is_fp_or_dword_type< U >::value &&std::is_floating_point< U >::value, sycl::ext::intel::esimd::simd< T, SZ > > dph(sycl::ext::intel::esimd::simd< T, SZ > src0, U src1, Sat sat={})
Dot product on groups of 4 elements.
ESIMD_INLINE float atan2_fast(float y, float x)
ESIMD_NODEBUG ESIMD_INLINE std::enable_if_t< __ESIMD_DNS::is_fp_or_dword_type< T >::value &&std::is_floating_point< T >::value &&__ESIMD_DNS::is_fp_or_dword_type< U >::value &&std::is_floating_point< U >::value, sycl::ext::intel::esimd::simd< T, SZ > > lrp(sycl::ext::intel::esimd::simd< T, SZ > src0, U src1, V src2, Sat sat={})
ESIMD_INLINE float cos_emu(float x0)
ESIMD_NODEBUG ESIMD_INLINE std::enable_if_t< __ESIMD_DNS::is_fp_or_dword_type< T1 >::value &&std::is_floating_point< T1 >::value &&__ESIMD_DNS::is_fp_or_dword_type< U >::value &&std::is_floating_point< U >::value, sycl::ext::intel::esimd::simd< T0, SZ > > dp2(sycl::ext::intel::esimd::simd< T1, SZ > src0, U src1, Sat sat={})
Dot product on groups of 4 elements.
__ESIMD_API std::enable_if_t< std::is_floating_point< T >::value, T > acos(T src0)
ESIMD_NODEBUG ESIMD_INLINE T exp(T src0, Sat sat={})
__ESIMD_API std::enable_if_t< __ESIMD_DNS::is_esimd_scalar< T0 >::value &&__ESIMD_DNS::is_esimd_scalar< T1 >::value &&std::is_integral< T0 >::value &&std::is_integral< T1 >::value, std::remove_const_t< T0 > > mod(T0 src0, T1 src1)
Modulo (scalar version)
__ESIMD_API std::enable_if_t< detail::is_esimd_scalar< T1 >::value, std::remove_const_t< T1 > > abs(T1 src0)
Get absolute value (scalar version).
ESIMD_INLINE sycl::ext::intel::esimd::simd< float, N > tanh_cody_waite(sycl::ext::intel::esimd::simd< float, N > x)
__ESIMD_API sycl::ext::intel::esimd::simd< T, N > dpasw(sycl::ext::intel::esimd::simd< T, N > src0, sycl::ext::intel::esimd::simd< T1, N1 > src1, sycl::ext::intel::esimd::simd< T2, N2 > src2, std::enable_if_t< __ESIMD_DNS::is_saturation_tag_v< Sat >, Sat > sat={})
DPASW.
__ESIMD_API sycl::ext::intel::esimd::simd< T, N > dpasw2(sycl::ext::intel::esimd::simd< T1, N1 > src1, sycl::ext::intel::esimd::simd< T2, N2 > src2, std::enable_if_t< __ESIMD_DNS::is_saturation_tag_v< Sat >, Sat > sat={})
DPASW2.
__ESIMD_API sycl::ext::intel::esimd::simd< T, N > dpas(sycl::ext::intel::esimd::simd< T1, N1 > src1, sycl::ext::intel::esimd::simd< T2, N2 > src2, std::enable_if_t< __ESIMD_DNS::is_saturation_tag_v< Sat >, Sat > sat={})
DPAS.
conditional< sizeof(long)==8, long, long long >::type int64_t
typename std::enable_if< B, T >::type enable_if_t
constexpr bool is_saturation_tag_v
sycl::half2 rsqrt(sycl::half2 x)
sycl::half2 sqrt(sycl::half2 x)
std::experimental::simd< T, simd_abi::native_fixed_size< T, N > > simd
---— Error handling, matching OpenCL plugin semantics.