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 enum :
size_t {
size = 64UL };
92 using IntrinsicType = ValueType;
95 enum :
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 enum :
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 enum :
size_t {
size = 16UL };
107 using IntrinsicType = ValueType;
110 enum :
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 enum :
size_t {
size = 64UL };
146 using IntrinsicType = ValueType;
149 enum :
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 enum :
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 enum :
size_t {
size = 16UL };
161 using IntrinsicType = ValueType;
164 enum :
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 enum :
size_t {
size = 32UL };
222 using IntrinsicType = ValueType;
225 enum :
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 enum :
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 enum :
size_t {
size = 8UL };
237 using IntrinsicType = ValueType;
240 enum :
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 enum :
size_t {
size = 32UL };
276 using IntrinsicType = ValueType;
279 enum :
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 enum :
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 enum :
size_t {
size = 8UL };
291 using IntrinsicType = ValueType;
294 enum :
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 enum :
size_t {
size = 32UL };
352 using IntrinsicType = ValueType;
355 enum :
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 enum :
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 enum :
size_t {
size = 8UL };
367 using IntrinsicType = ValueType;
370 enum :
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 enum :
size_t {
size = 32UL };
406 using IntrinsicType = ValueType;
409 enum :
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 enum :
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 enum :
size_t {
size = 8UL };
421 using IntrinsicType = ValueType;
424 enum :
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 enum :
size_t {
size = 16UL };
482 using IntrinsicType = ValueType;
485 enum :
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 enum :
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 enum :
size_t {
size = 4UL };
497 using IntrinsicType = ValueType;
500 enum :
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 enum :
size_t {
size = 16UL };
536 using IntrinsicType = ValueType;
539 enum :
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 enum :
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 enum :
size_t {
size = 4UL };
551 using IntrinsicType = ValueType;
554 enum :
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 enum :
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 enum :
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 enum :
size_t {
size = 4UL };
622 using IntrinsicType = ValueType;
625 enum :
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 enum :
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 enum :
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 enum :
size_t {
size = 4UL };
671 using IntrinsicType = ValueType;
674 enum :
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 enum :
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 enum :
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 enum :
size_t {
size = 2UL };
742 using IntrinsicType = ValueType;
745 enum :
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 enum :
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 enum :
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 enum :
size_t {
size = 2UL };
791 using IntrinsicType = ValueType;
794 enum :
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 enum :
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 enum :
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 enum :
size_t {
size = 2UL };
862 using IntrinsicType = ValueType;
865 enum :
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 enum :
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 enum :
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 enum :
size_t {
size = 2UL };
911 using IntrinsicType = ValueType;
914 enum :
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 enum :
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 enum :
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 enum :
size_t {
size = 1UL };
982 using IntrinsicType = ValueType;
985 enum :
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 enum :
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 enum :
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 enum :
size_t {
size = 1UL };
1031 using IntrinsicType = ValueType;
1034 enum :
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 enum :
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 enum :
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 enum :
size_t {
size = 4UL };
1102 using IntrinsicType = ValueType;
1105 enum :
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 enum :
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 enum :
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 enum :
size_t {
size = 2UL };
1175 using IntrinsicType = ValueType;
1178 enum :
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 enum :
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 enum :
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 enum :
size_t {
size = 2UL };
1246 using IntrinsicType = ValueType;
1249 enum :
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 enum :
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 enum :
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 enum :
size_t {
size = 1UL };
1319 using IntrinsicType = ValueType;
1322 enum :
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);
Header file for basic type definitions.
BLAZE_ALWAYS_INLINE size_t size(const Vector< VT, TF > &vector) noexcept
Returns the current size/dimension of the vector.
Definition: Vector.h:265
BLAZE_ALWAYS_INLINE T1 & operator/=(SIMDPack< T1 > &lhs, const SIMDPack< T2 > &rhs)
Division assignment operator for the division of two SIMD packs.
Definition: BasicTypes.h:1411
CompressedMatrix< Type, true > This
Type of this CompressedMatrix instance.
Definition: CompressedMatrix.h:3076
BLAZE_ALWAYS_INLINE T1 & operator*=(SIMDPack< T1 > &lhs, const SIMDPack< T2 > &rhs)
Multiplication assignment operator for the multiplication of two SIMD packs.
Definition: BasicTypes.h:1393
Header file for the SIMDPack base class.
Namespace of the Blaze C++ math library.
Definition: Blaze.h:57
#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:3077
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:797
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
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.