35 #ifndef _BLAZE_MATH_SIMD_BASICTYPES_H_ 36 #define _BLAZE_MATH_SIMD_BASICTYPES_H_ 65 template<
typename T >
67 :
public SIMDPack< T >
80 :
public SIMDi8< SIMDint8 >
82 using This = SIMDint8;
84 using ValueType = int8_t;
86 #if BLAZE_AVX512BW_MODE 87 using IntrinsicType = __m512i;
89 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
90 static constexpr
size_t size = 64UL;
92 using IntrinsicType = ValueType;
95 static constexpr
size_t size = 1UL;
97 using IntrinsicType = __m256i;
99 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
100 static constexpr
size_t size = 32UL;
101 #elif BLAZE_SSE2_MODE 102 using IntrinsicType = __m128i;
104 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
105 static constexpr
size_t size = 16UL;
107 using IntrinsicType = ValueType;
110 static constexpr
size_t size = 1UL;
115 template<
typename T >
118 template<
typename T >
119 BLAZE_ALWAYS_INLINE SIMDint8& operator=(
const SIMDi8<T>& v ) noexcept { value = (~v).value;
return *
this; }
134 :
public SIMDi8< SIMDuint8 >
136 using This = SIMDuint8;
138 using ValueType = uint8_t;
140 #if BLAZE_AVX512BW_MODE 141 using IntrinsicType = __m512i;
143 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
144 static constexpr
size_t size = 64UL;
146 using IntrinsicType = ValueType;
149 static constexpr
size_t size = 1UL;
150 #elif BLAZE_AVX2_MODE 151 using IntrinsicType = __m256i;
153 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
154 static constexpr
size_t size = 32UL;
155 #elif BLAZE_SSE2_MODE 156 using IntrinsicType = __m128i;
158 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
159 static constexpr
size_t size = 16UL;
161 using IntrinsicType = ValueType;
164 static constexpr
size_t size = 1UL;
169 template<
typename T >
172 template<
typename T >
173 BLAZE_ALWAYS_INLINE SIMDuint8& operator=(
const SIMDi8<T>& v ) noexcept { value = (~v).value;
return *
this; }
195 template<
typename T >
197 :
public SIMDPack< T >
210 :
public SIMDci8< SIMDcint8 >
212 using This = SIMDcint8;
214 using ValueType = complex<int8_t>;
216 #if BLAZE_AVX512BW_MODE 217 using IntrinsicType = __m512i;
219 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
220 static constexpr
size_t size = 32UL;
222 using IntrinsicType = ValueType;
225 static constexpr
size_t size = 1UL;
226 #elif BLAZE_AVX2_MODE 227 using IntrinsicType = __m256i;
229 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
230 static constexpr
size_t size = 16UL;
231 #elif BLAZE_SSE2_MODE 232 using IntrinsicType = __m128i;
234 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
235 static constexpr
size_t size = 8UL;
237 using IntrinsicType = ValueType;
240 static constexpr
size_t size = 1UL;
245 template<
typename T >
248 template<
typename T >
249 BLAZE_ALWAYS_INLINE SIMDcint8& operator=(
const SIMDci8<T>& v ) noexcept { value = (~v).value;
return *
this; }
264 :
public SIMDci8< SIMDcuint8 >
266 using This = SIMDcuint8;
268 using ValueType = complex<uint8_t>;
270 #if BLAZE_AVX512BW_MODE 271 using IntrinsicType = __m512i;
273 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
274 static constexpr
size_t size = 32UL;
276 using IntrinsicType = ValueType;
279 static constexpr
size_t size = 1UL;
280 #elif BLAZE_AVX2_MODE 281 using IntrinsicType = __m256i;
283 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
284 static constexpr
size_t size = 16UL;
285 #elif BLAZE_SSE2_MODE 286 using IntrinsicType = __m128i;
288 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
289 static constexpr
size_t size = 8UL;
291 using IntrinsicType = ValueType;
294 static constexpr
size_t size = 1UL;
299 template<
typename T >
302 template<
typename T >
303 BLAZE_ALWAYS_INLINE SIMDcuint8& operator=(
const SIMDci8<T>& v ) noexcept { value = (~v).value;
return *
this; }
325 template<
typename T >
327 :
public SIMDPack< T >
340 :
public SIMDi16< SIMDint16 >
342 using This = SIMDint16;
344 using ValueType = int16_t;
346 #if BLAZE_AVX512BW_MODE 347 using IntrinsicType = __m512i;
349 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
350 static constexpr
size_t size = 32UL;
352 using IntrinsicType = ValueType;
355 static constexpr
size_t size = 1UL;
356 #elif BLAZE_AVX2_MODE 357 using IntrinsicType = __m256i;
359 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
360 static constexpr
size_t size = 16UL;
361 #elif BLAZE_SSE2_MODE 362 using IntrinsicType = __m128i;
364 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
365 static constexpr
size_t size = 8UL;
367 using IntrinsicType = ValueType;
370 static constexpr
size_t size = 1UL;
375 template<
typename T >
378 template<
typename T >
379 BLAZE_ALWAYS_INLINE SIMDint16& operator=(
const SIMDi16<T>& v ) noexcept { value = (~v).value;
return *
this; }
394 :
public SIMDi16< SIMDuint16 >
396 using This = SIMDuint16;
398 using ValueType = uint16_t;
400 #if BLAZE_AVX512BW_MODE 401 using IntrinsicType = __m512i;
403 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
404 static constexpr
size_t size = 32UL;
406 using IntrinsicType = ValueType;
409 static constexpr
size_t size = 1UL;
410 #elif BLAZE_AVX2_MODE 411 using IntrinsicType = __m256i;
413 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
414 static constexpr
size_t size = 16UL;
415 #elif BLAZE_SSE2_MODE 416 using IntrinsicType = __m128i;
418 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
419 static constexpr
size_t size = 8UL;
421 using IntrinsicType = ValueType;
424 static constexpr
size_t size = 1UL;
429 template<
typename T >
432 template<
typename T >
433 BLAZE_ALWAYS_INLINE SIMDuint16& operator=(
const SIMDi16<T>& v ) noexcept { value = (~v).value;
return *
this; }
455 template<
typename T >
457 :
public SIMDPack< T >
470 :
public SIMDci16< SIMDcint16 >
472 using This = SIMDcint16;
474 using ValueType = complex<int16_t>;
476 #if BLAZE_AVX512BW_MODE 477 using IntrinsicType = __m512i;
479 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
480 static constexpr
size_t size = 16UL;
482 using IntrinsicType = ValueType;
485 static constexpr
size_t size = 1UL;
486 #elif BLAZE_AVX2_MODE 487 using IntrinsicType = __m256i;
489 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
490 static constexpr
size_t size = 8UL;
491 #elif BLAZE_SSE2_MODE 492 using IntrinsicType = __m128i;
494 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
495 static constexpr
size_t size = 4UL;
497 using IntrinsicType = ValueType;
500 static constexpr
size_t size = 1UL;
505 template<
typename T >
508 template<
typename T >
509 BLAZE_ALWAYS_INLINE SIMDcint16& operator=(
const SIMDci16<T>& v ) noexcept { value = (~v).value;
return *
this; }
524 :
public SIMDci16< SIMDcuint16 >
526 using This = SIMDcuint16;
528 using ValueType = complex<uint16_t>;
530 #if BLAZE_AVX512BW_MODE 531 using IntrinsicType = __m512i;
533 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
534 static constexpr
size_t size = 16UL;
536 using IntrinsicType = ValueType;
539 static constexpr
size_t size = 1UL;
540 #elif BLAZE_AVX2_MODE 541 using IntrinsicType = __m256i;
543 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
544 static constexpr
size_t size = 8UL;
545 #elif BLAZE_SSE2_MODE 546 using IntrinsicType = __m128i;
548 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
549 static constexpr
size_t size = 4UL;
551 using IntrinsicType = ValueType;
554 static constexpr
size_t size = 1UL;
559 template<
typename T >
562 template<
typename T >
563 BLAZE_ALWAYS_INLINE SIMDcuint16& operator=(
const SIMDci16<T>& v ) noexcept { value = (~v).value;
return *
this; }
585 template<
typename T >
587 :
public SIMDPack< T >
600 :
public SIMDi32< SIMDint32 >
602 using This = SIMDint32;
604 using ValueType = int32_t;
606 #if BLAZE_AVX512F_MODE || BLAZE_MIC_MODE 607 using IntrinsicType = __m512i;
609 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
610 static constexpr
size_t size = 16UL;
611 #elif BLAZE_AVX2_MODE 612 using IntrinsicType = __m256i;
614 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
615 static constexpr
size_t size = 8UL;
616 #elif BLAZE_SSE2_MODE 617 using IntrinsicType = __m128i;
619 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
620 static constexpr
size_t size = 4UL;
622 using IntrinsicType = ValueType;
625 static constexpr
size_t size = 1UL;
630 template<
typename T >
633 template<
typename T >
634 BLAZE_ALWAYS_INLINE SIMDint32& operator=(
const SIMDi32<T>& v ) noexcept { value = (~v).value;
return *
this; }
649 :
public SIMDi32< SIMDuint32 >
651 using This = SIMDuint32;
653 using ValueType = uint32_t;
655 #if BLAZE_AVX512F_MODE || BLAZE_MIC_MODE 656 using IntrinsicType = __m512i;
658 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
659 static constexpr
size_t size = 16UL;
660 #elif BLAZE_AVX2_MODE 661 using IntrinsicType = __m256i;
663 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
664 static constexpr
size_t size = 8UL;
665 #elif BLAZE_SSE2_MODE 666 using IntrinsicType = __m128i;
668 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
669 static constexpr
size_t size = 4UL;
671 using IntrinsicType = ValueType;
674 static constexpr
size_t size = 1UL;
679 template<
typename T >
682 template<
typename T >
683 BLAZE_ALWAYS_INLINE SIMDuint32& operator=(
const SIMDi32<T>& v ) noexcept { value = (~v).value;
return *
this; }
705 template<
typename T >
707 :
public SIMDPack< T >
720 :
public SIMDci32< SIMDcint32 >
722 using This = SIMDcint32;
724 using ValueType = complex<int32_t>;
726 #if BLAZE_AVX512F_MODE || BLAZE_MIC_MODE 727 using IntrinsicType = __m512i;
729 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
730 static constexpr
size_t size = 8UL;
731 #elif BLAZE_AVX2_MODE 732 using IntrinsicType = __m256i;
734 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
735 static constexpr
size_t size = 4UL;
736 #elif BLAZE_SSE2_MODE 737 using IntrinsicType = __m128i;
739 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
740 static constexpr
size_t size = 2UL;
742 using IntrinsicType = ValueType;
745 static constexpr
size_t size = 1UL;
750 template<
typename T >
753 template<
typename T >
754 BLAZE_ALWAYS_INLINE SIMDcint32& operator=(
const SIMDci32<T>& v ) noexcept { value = (~v).value;
return *
this; }
769 :
public SIMDci32< SIMDcuint32 >
771 using This = SIMDcuint32;
773 using ValueType = complex<uint32_t>;
775 #if BLAZE_AVX512F_MODE || BLAZE_MIC_MODE 776 using IntrinsicType = __m512i;
778 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
779 static constexpr
size_t size = 8UL;
780 #elif BLAZE_AVX2_MODE 781 using IntrinsicType = __m256i;
783 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
784 static constexpr
size_t size = 4UL;
785 #elif BLAZE_SSE2_MODE 786 using IntrinsicType = __m128i;
788 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
789 static constexpr
size_t size = 2UL;
791 using IntrinsicType = ValueType;
794 static constexpr
size_t size = 1UL;
799 template<
typename T >
802 template<
typename T >
803 BLAZE_ALWAYS_INLINE SIMDcuint32& operator=(
const SIMDci32<T>& v ) noexcept { value = (~v).value;
return *
this; }
825 template<
typename T >
827 :
public SIMDPack< T >
840 :
public SIMDi64< SIMDint64 >
842 using This = SIMDint64;
844 using ValueType = int64_t;
846 #if BLAZE_AVX512F_MODE || BLAZE_MIC_MODE 847 using IntrinsicType = __m512i;
849 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
850 static constexpr
size_t size = 8UL;
851 #elif BLAZE_AVX2_MODE 852 using IntrinsicType = __m256i;
854 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
855 static constexpr
size_t size = 4UL;
856 #elif BLAZE_SSE2_MODE 857 using IntrinsicType = __m128i;
859 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
860 static constexpr
size_t size = 2UL;
862 using IntrinsicType = ValueType;
865 static constexpr
size_t size = 1UL;
870 template<
typename T >
873 template<
typename T >
874 BLAZE_ALWAYS_INLINE SIMDint64& operator=(
const SIMDi64<T>& v ) noexcept { value = (~v).value;
return *
this; }
889 :
public SIMDi64< SIMDuint64 >
891 using This = SIMDuint64;
893 using ValueType = uint64_t;
895 #if BLAZE_AVX512F_MODE || BLAZE_MIC_MODE 896 using IntrinsicType = __m512i;
898 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
899 static constexpr
size_t size = 8UL;
900 #elif BLAZE_AVX2_MODE 901 using IntrinsicType = __m256i;
903 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
904 static constexpr
size_t size = 4UL;
905 #elif BLAZE_SSE2_MODE 906 using IntrinsicType = __m128i;
908 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
909 static constexpr
size_t size = 2UL;
911 using IntrinsicType = ValueType;
914 static constexpr
size_t size = 1UL;
919 template<
typename T >
922 template<
typename T >
923 BLAZE_ALWAYS_INLINE SIMDuint64& operator=(
const SIMDi64<T>& v ) noexcept { value = (~v).value;
return *
this; }
945 template<
typename T >
947 :
public SIMDPack< T >
960 :
public SIMDci64< SIMDcint64 >
962 using This = SIMDcint64;
964 using ValueType = complex<int64_t>;
966 #if BLAZE_AVX512F_MODE || BLAZE_MIC_MODE 967 using IntrinsicType = __m512i;
969 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
970 static constexpr
size_t size = 4UL;
971 #elif BLAZE_AVX2_MODE 972 using IntrinsicType = __m256i;
974 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
975 static constexpr
size_t size = 2UL;
976 #elif BLAZE_SSE2_MODE 977 using IntrinsicType = __m128i;
979 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
980 static constexpr
size_t size = 1UL;
982 using IntrinsicType = ValueType;
985 static constexpr
size_t size = 1UL;
990 template<
typename T >
993 template<
typename T >
994 BLAZE_ALWAYS_INLINE SIMDcint64& operator=(
const SIMDci64<T>& v ) noexcept { value = (~v).value;
return *
this; }
1009 :
public SIMDci64< SIMDcuint64 >
1011 using This = SIMDcuint64;
1013 using ValueType = complex<uint64_t>;
1015 #if BLAZE_AVX512F_MODE || BLAZE_MIC_MODE 1016 using IntrinsicType = __m512i;
1018 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
1019 static constexpr
size_t size = 4UL;
1020 #elif BLAZE_AVX2_MODE 1021 using IntrinsicType = __m256i;
1023 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
1024 static constexpr
size_t size = 2UL;
1025 #elif BLAZE_SSE2_MODE 1026 using IntrinsicType = __m128i;
1028 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
1029 static constexpr
size_t size = 1UL;
1031 using IntrinsicType = ValueType;
1034 static constexpr
size_t size = 1UL;
1039 template<
typename T >
1042 template<
typename T >
1043 BLAZE_ALWAYS_INLINE SIMDcuint64& operator=(
const SIMDci64<T>& v ) noexcept { value = (~v).value;
return *
this; }
1045 IntrinsicType value;
1065 template<
typename T >
1067 :
public SIMDPack< T >
1080 :
public SIMDf32< SIMDfloat >
1082 using This = SIMDfloat;
1084 using ValueType = float;
1086 #if BLAZE_AVX512F_MODE || BLAZE_MIC_MODE 1087 using IntrinsicType = __m512;
1089 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
1090 static constexpr
size_t size = 16UL;
1091 #elif BLAZE_AVX_MODE 1092 using IntrinsicType = __m256;
1094 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
1095 static constexpr
size_t size = 8UL;
1096 #elif BLAZE_SSE_MODE 1097 using IntrinsicType = __m128;
1099 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
1100 static constexpr
size_t size = 4UL;
1102 using IntrinsicType = ValueType;
1105 static constexpr
size_t size = 1UL;
1110 template<
typename T >
1113 template<
typename T >
1114 BLAZE_ALWAYS_INLINE SIMDfloat& operator=(
const SIMDf32<T>& v ) noexcept { value = (~v).
eval().value;
return *
this; }
1118 IntrinsicType value;
1138 template<
typename T >
1140 :
public SIMDPack< T >
1153 :
public SIMDcf32< SIMDcfloat >
1155 using This = SIMDcfloat;
1157 using ValueType = complex<float>;
1159 #if BLAZE_AVX512F_MODE || BLAZE_MIC_MODE 1160 using IntrinsicType = __m512;
1162 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
1163 static constexpr
size_t size = 8UL;
1164 #elif BLAZE_AVX_MODE 1165 using IntrinsicType = __m256;
1167 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
1168 static constexpr
size_t size = 4UL;
1169 #elif BLAZE_SSE_MODE 1170 using IntrinsicType = __m128;
1172 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
1173 static constexpr
size_t size = 2UL;
1175 using IntrinsicType = ValueType;
1178 static constexpr
size_t size = 1UL;
1183 template<
typename T >
1186 template<
typename T >
1187 BLAZE_ALWAYS_INLINE SIMDcfloat& operator=(
const SIMDcf32<T>& v ) noexcept { value = (~v).value;
return *
this; }
1189 IntrinsicType value;
1209 template<
typename T >
1211 :
public SIMDPack< T >
1224 :
public SIMDf64< SIMDdouble >
1226 using This = SIMDdouble;
1228 using ValueType = double;
1230 #if BLAZE_AVX512F_MODE || BLAZE_MIC_MODE 1231 using IntrinsicType = __m512d;
1233 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
1234 static constexpr
size_t size = 8UL;
1235 #elif BLAZE_AVX_MODE 1236 using IntrinsicType = __m256d;
1238 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
1239 static constexpr
size_t size = 4UL;
1240 #elif BLAZE_SSE2_MODE 1241 using IntrinsicType = __m128d;
1243 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
1244 static constexpr
size_t size = 2UL;
1246 using IntrinsicType = ValueType;
1249 static constexpr
size_t size = 1UL;
1254 template<
typename T >
1257 template<
typename T >
1258 BLAZE_ALWAYS_INLINE SIMDdouble& operator=(
const SIMDf64<T>& v ) noexcept { value = (~v).
eval().value;
return *
this; }
1262 IntrinsicType value;
1282 template<
typename T >
1284 :
public SIMDPack< T >
1297 :
public SIMDcf64< SIMDcdouble >
1299 using This = SIMDcdouble;
1301 using ValueType = complex<double>;
1303 #if BLAZE_AVX512F_MODE || BLAZE_MIC_MODE 1304 using IntrinsicType = __m512d;
1306 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
1307 static constexpr
size_t size = 4UL;
1308 #elif BLAZE_AVX_MODE 1309 using IntrinsicType = __m256d;
1311 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
1312 static constexpr
size_t size = 2UL;
1313 #elif BLAZE_SSE2_MODE 1314 using IntrinsicType = __m128d;
1316 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
1317 static constexpr
size_t size = 1UL;
1319 using IntrinsicType = ValueType;
1322 static constexpr
size_t size = 1UL;
1327 template<
typename T >
1330 template<
typename T >
1331 BLAZE_ALWAYS_INLINE SIMDcdouble& operator=(
const SIMDcf64<T>& v ) noexcept { value = (~v).value;
return *
this; }
1333 IntrinsicType value;
1355 template<
typename T1
1359 (~lhs) = (~lhs) + (~rhs);
1373 template<
typename T1
1377 (~lhs) = (~lhs) - (~rhs);
1391 template<
typename T1
1395 (~lhs) = (~lhs) * (~rhs);
1409 template<
typename T1
1413 (~lhs) = (~lhs) / (~rhs);
auto operator/=(DenseMatrix< MT, SO > &mat, ST scalar) -> EnableIf_t< IsNumeric_v< ST >, MT & >
Division assignment operator for the division of a dense matrix by a scalar value ( )...
Definition: DenseMatrix.h:354
Header file for basic type definitions.
CompressedMatrix< Type, true > This
Type of this CompressedMatrix instance.
Definition: CompressedMatrix.h:3075
Header file for the SIMDPack base class.
Namespace of the Blaze C++ math library.
Definition: Blaze.h:58
#define BLAZE_ALWAYS_INLINE
Platform dependent setup of an enforced inline keyword.
Definition: Inline.h:85
SparseMatrix< This, true > BaseType
Base type of this CompressedMatrix instance.
Definition: CompressedMatrix.h:3076
Base class for all SIMD data types.The SIMDPack class template is a base class for all SIMD data type...
Definition: SIMDPack.h:63
decltype(auto) eval(const DenseMatrix< MT, SO > &dm)
Forces the evaluation of the given dense matrix expression dm.
Definition: DMatEvalExpr.h:786
BLAZE_ALWAYS_INLINE T1 & operator+=(SIMDPack< T1 > &lhs, const SIMDPack< T2 > &rhs)
Addition assignment operator for the addition of two SIMD packs.
Definition: BasicTypes.h:1357
constexpr size_t size(const Matrix< MT, SO > &matrix) noexcept
Returns the total number of elements of the matrix.
Definition: Matrix.h:530
auto operator*=(DenseMatrix< MT, SO > &mat, ST scalar) -> EnableIf_t< IsNumeric_v< ST >, MT & >
Multiplication assignment operator for the multiplication of a dense matrix and a scalar value ( )...
Definition: DenseMatrix.h:290
System settings for the SSE mode.
Header file for the complex data type.
BLAZE_ALWAYS_INLINE T1 & operator-=(SIMDPack< T1 > &lhs, const SIMDPack< T2 > &rhs)
Subtraction assignment operator for the subtraction of two SIMD packs.
Definition: BasicTypes.h:1375
System settings for the inline keywords.
Header file for the TrueType type/value trait base class.