35 #ifndef _BLAZE_MATH_SIMD_BASICTYPES_H_
36 #define _BLAZE_MATH_SIMD_BASICTYPES_H_
65 template<
typename T >
66 struct SIMDi8 :
public SIMDPack< T >
78 struct SIMDint8 :
public SIMDi8< SIMDint8 >
80 using This = SIMDint8;
82 using ValueType = int8_t;
85 using IntrinsicType = ValueType;
88 enum :
size_t {
size = 1UL };
90 using IntrinsicType = __m256i;
92 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
93 enum :
size_t {
size = 32UL };
95 using IntrinsicType = __m128i;
97 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
98 enum :
size_t {
size = 16UL };
100 using IntrinsicType = ValueType;
103 enum :
size_t {
size = 1UL };
108 template<
typename T >
111 template<
typename T >
112 BLAZE_ALWAYS_INLINE SIMDint8& operator=(
const SIMDi8<T>& v ) noexcept { value = (~v).value;
return *
this; }
126 struct SIMDuint8 :
public SIMDi8< SIMDuint8 >
128 using This = SIMDuint8;
130 using ValueType = uint8_t;
133 using IntrinsicType = ValueType;
136 enum :
size_t {
size = 1UL };
137 #elif BLAZE_AVX2_MODE
138 using IntrinsicType = __m256i;
140 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
141 enum :
size_t {
size = 32UL };
142 #elif BLAZE_SSE2_MODE
143 using IntrinsicType = __m128i;
145 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
146 enum :
size_t {
size = 16UL };
148 using IntrinsicType = ValueType;
151 enum :
size_t {
size = 1UL };
156 template<
typename T >
159 template<
typename T >
160 BLAZE_ALWAYS_INLINE SIMDuint8& operator=(
const SIMDi8<T>& v ) noexcept { value = (~v).value;
return *
this; }
182 template<
typename T >
183 struct SIMDci8 :
public SIMDPack< T >
195 struct SIMDcint8 :
public SIMDci8< SIMDcint8 >
197 using This = SIMDcint8;
199 using ValueType = complex<int8_t>;
202 using IntrinsicType = ValueType;
205 enum :
size_t {
size = 1UL };
206 #elif BLAZE_AVX2_MODE
207 using IntrinsicType = __m256i;
209 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
210 enum :
size_t {
size = 16UL };
211 #elif BLAZE_SSE2_MODE
212 using IntrinsicType = __m128i;
214 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
215 enum :
size_t {
size = 8UL };
217 using IntrinsicType = ValueType;
220 enum :
size_t {
size = 1UL };
225 template<
typename T >
228 template<
typename T >
229 BLAZE_ALWAYS_INLINE SIMDcint8& operator=(
const SIMDci8<T>& v ) noexcept { value = (~v).value;
return *
this; }
243 struct SIMDcuint8 :
public SIMDci8< SIMDcuint8 >
245 using This = SIMDcuint8;
247 using ValueType = complex<uint8_t>;
250 using IntrinsicType = ValueType;
253 enum :
size_t {
size = 1UL };
254 #elif BLAZE_AVX2_MODE
255 using IntrinsicType = __m256i;
257 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
258 enum :
size_t {
size = 16UL };
259 #elif BLAZE_SSE2_MODE
260 using IntrinsicType = __m128i;
262 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
263 enum :
size_t {
size = 8UL };
265 using IntrinsicType = ValueType;
268 enum :
size_t {
size = 1UL };
273 template<
typename T >
276 template<
typename T >
277 BLAZE_ALWAYS_INLINE SIMDcuint8& operator=(
const SIMDci8<T>& v ) noexcept { value = (~v).value;
return *
this; }
299 template<
typename T >
300 struct SIMDi16 :
public SIMDPack< T >
312 struct SIMDint16 :
public SIMDi16< SIMDint16 >
314 using This = SIMDint16;
316 using ValueType = int16_t;
319 using IntrinsicType = ValueType;
322 enum :
size_t {
size = 1UL };
323 #elif BLAZE_AVX2_MODE
324 using IntrinsicType = __m256i;
326 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
327 enum :
size_t {
size = 16UL };
328 #elif BLAZE_SSE2_MODE
329 using IntrinsicType = __m128i;
331 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
332 enum :
size_t {
size = 8UL };
334 using IntrinsicType = ValueType;
337 enum :
size_t {
size = 1UL };
342 template<
typename T >
345 template<
typename T >
346 BLAZE_ALWAYS_INLINE SIMDint16& operator=(
const SIMDi16<T>& v ) noexcept { value = (~v).value;
return *
this; }
360 struct SIMDuint16 :
public SIMDi16< SIMDuint16 >
362 using This = SIMDuint16;
364 using ValueType = uint16_t;
367 using IntrinsicType = ValueType;
370 enum :
size_t {
size = 1UL };
371 #elif BLAZE_AVX2_MODE
372 using IntrinsicType = __m256i;
374 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
375 enum :
size_t {
size = 16UL };
376 #elif BLAZE_SSE2_MODE
377 using IntrinsicType = __m128i;
379 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
380 enum :
size_t {
size = 8UL };
382 using IntrinsicType = ValueType;
385 enum :
size_t {
size = 1UL };
390 template<
typename T >
393 template<
typename T >
394 BLAZE_ALWAYS_INLINE SIMDuint16& operator=(
const SIMDi16<T>& v ) noexcept { value = (~v).value;
return *
this; }
416 template<
typename T >
417 struct SIMDci16 :
public SIMDPack< T >
429 struct SIMDcint16 :
public SIMDci16< SIMDcint16 >
431 using This = SIMDcint16;
433 using ValueType = complex<int16_t>;
436 using IntrinsicType = ValueType;
439 enum :
size_t {
size = 1UL };
440 #elif BLAZE_AVX2_MODE
441 using IntrinsicType = __m256i;
443 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
444 enum :
size_t {
size = 8UL };
445 #elif BLAZE_SSE2_MODE
446 using IntrinsicType = __m128i;
448 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
449 enum :
size_t {
size = 4UL };
451 using IntrinsicType = ValueType;
454 enum :
size_t {
size = 1UL };
459 template<
typename T >
462 template<
typename T >
463 BLAZE_ALWAYS_INLINE SIMDcint16& operator=(
const SIMDci16<T>& v ) noexcept { value = (~v).value;
return *
this; }
477 struct SIMDcuint16 :
public SIMDci16< SIMDcuint16 >
479 using This = SIMDcuint16;
481 using ValueType = complex<uint16_t>;
484 using IntrinsicType = ValueType;
487 enum :
size_t {
size = 1UL };
488 #elif BLAZE_AVX2_MODE
489 using IntrinsicType = __m256i;
491 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
492 enum :
size_t {
size = 8UL };
493 #elif BLAZE_SSE2_MODE
494 using IntrinsicType = __m128i;
496 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
497 enum :
size_t {
size = 4UL };
499 using IntrinsicType = ValueType;
502 enum :
size_t {
size = 1UL };
507 template<
typename T >
510 template<
typename T >
511 BLAZE_ALWAYS_INLINE SIMDcuint16& operator=(
const SIMDci16<T>& v ) noexcept { value = (~v).value;
return *
this; }
533 template<
typename T >
534 struct SIMDi32 :
public SIMDPack< T >
546 struct SIMDint32 :
public SIMDi32< SIMDint32 >
548 using This = SIMDint32;
550 using ValueType = int32_t;
553 using IntrinsicType = __m512i;
555 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
556 enum :
size_t {
size = 16UL };
557 #elif BLAZE_AVX2_MODE
558 using IntrinsicType = __m256i;
560 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
561 enum :
size_t {
size = 8UL };
562 #elif BLAZE_SSE2_MODE
563 using IntrinsicType = __m128i;
565 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
566 enum :
size_t {
size = 4UL };
568 using IntrinsicType = ValueType;
571 enum :
size_t {
size = 1UL };
576 template<
typename T >
579 template<
typename T >
580 BLAZE_ALWAYS_INLINE SIMDint32& operator=(
const SIMDi32<T>& v ) noexcept { value = (~v).value;
return *
this; }
594 struct SIMDuint32 :
public SIMDi32< SIMDuint32 >
596 using This = SIMDuint32;
598 using ValueType = uint32_t;
601 using IntrinsicType = __m512i;
603 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
604 enum :
size_t {
size = 16UL };
605 #elif BLAZE_AVX2_MODE
606 using IntrinsicType = __m256i;
608 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
609 enum :
size_t {
size = 8UL };
610 #elif BLAZE_SSE2_MODE
611 using IntrinsicType = __m128i;
613 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
614 enum :
size_t {
size = 4UL };
616 using IntrinsicType = ValueType;
619 enum :
size_t {
size = 1UL };
624 template<
typename T >
627 template<
typename T >
628 BLAZE_ALWAYS_INLINE SIMDuint32& operator=(
const SIMDi32<T>& v ) noexcept { value = (~v).value;
return *
this; }
650 template<
typename T >
651 struct SIMDci32 :
public SIMDPack< T >
663 struct SIMDcint32 :
public SIMDci32< SIMDcint32 >
665 using This = SIMDcint32;
667 using ValueType = complex<int32_t>;
670 using IntrinsicType = __m512i;
672 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
673 enum :
size_t {
size = 8UL };
674 #elif BLAZE_AVX2_MODE
675 using IntrinsicType = __m256i;
677 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
678 enum :
size_t {
size = 4UL };
679 #elif BLAZE_SSE2_MODE
680 using IntrinsicType = __m128i;
682 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
683 enum :
size_t {
size = 2UL };
685 using IntrinsicType = ValueType;
688 enum :
size_t {
size = 1UL };
693 template<
typename T >
696 template<
typename T >
697 BLAZE_ALWAYS_INLINE SIMDcint32& operator=(
const SIMDci32<T>& v ) noexcept { value = (~v).value;
return *
this; }
711 struct SIMDcuint32 :
public SIMDci32< SIMDcuint32 >
713 using This = SIMDcuint32;
715 using ValueType = complex<uint32_t>;
718 using IntrinsicType = __m512i;
720 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
721 enum :
size_t {
size = 8UL };
722 #elif BLAZE_AVX2_MODE
723 using IntrinsicType = __m256i;
725 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
726 enum :
size_t {
size = 4UL };
727 #elif BLAZE_SSE2_MODE
728 using IntrinsicType = __m128i;
730 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
731 enum :
size_t {
size = 2UL };
733 using IntrinsicType = ValueType;
736 enum :
size_t {
size = 1UL };
741 template<
typename T >
744 template<
typename T >
745 BLAZE_ALWAYS_INLINE SIMDcuint32& operator=(
const SIMDci32<T>& v ) noexcept { value = (~v).value;
return *
this; }
767 template<
typename T >
768 struct SIMDi64 :
public SIMDPack< T >
780 struct SIMDint64 :
public SIMDi64< SIMDint64 >
782 using This = SIMDint64;
784 using ValueType = int64_t;
787 using IntrinsicType = __m512i;
789 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
790 enum :
size_t {
size = 8UL };
791 #elif BLAZE_AVX2_MODE
792 using IntrinsicType = __m256i;
794 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
795 enum :
size_t {
size = 4UL };
796 #elif BLAZE_SSE2_MODE
797 using IntrinsicType = __m128i;
799 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
800 enum :
size_t {
size = 2UL };
802 using IntrinsicType = ValueType;
805 enum :
size_t {
size = 1UL };
810 template<
typename T >
813 template<
typename T >
814 BLAZE_ALWAYS_INLINE SIMDint64& operator=(
const SIMDi64<T>& v ) noexcept { value = (~v).value;
return *
this; }
828 struct SIMDuint64 :
public SIMDi64< SIMDuint64 >
830 using This = SIMDuint64;
832 using ValueType = uint64_t;
835 using IntrinsicType = __m512i;
837 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
838 enum :
size_t {
size = 8UL };
839 #elif BLAZE_AVX2_MODE
840 using IntrinsicType = __m256i;
842 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
843 enum :
size_t {
size = 4UL };
844 #elif BLAZE_SSE2_MODE
845 using IntrinsicType = __m128i;
847 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
848 enum :
size_t {
size = 2UL };
850 using IntrinsicType = ValueType;
853 enum :
size_t {
size = 1UL };
858 template<
typename T >
861 template<
typename T >
862 BLAZE_ALWAYS_INLINE SIMDuint64& operator=(
const SIMDi64<T>& v ) noexcept { value = (~v).value;
return *
this; }
884 template<
typename T >
885 struct SIMDci64 :
public SIMDPack< T >
897 struct SIMDcint64 :
public SIMDci64< SIMDcint64 >
899 using This = SIMDcint64;
901 using ValueType = complex<int64_t>;
904 using IntrinsicType = __m512i;
906 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
907 enum :
size_t {
size = 4UL };
908 #elif BLAZE_AVX2_MODE
909 using IntrinsicType = __m256i;
911 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
912 enum :
size_t {
size = 2UL };
913 #elif BLAZE_SSE2_MODE
914 using IntrinsicType = __m128i;
916 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
917 enum :
size_t {
size = 1UL };
919 using IntrinsicType = ValueType;
922 enum :
size_t {
size = 1UL };
927 template<
typename T >
930 template<
typename T >
931 BLAZE_ALWAYS_INLINE SIMDcint64& operator=(
const SIMDci64<T>& v ) noexcept { value = (~v).value;
return *
this; }
945 struct SIMDcuint64 :
public SIMDci64< SIMDcuint64 >
947 using This = SIMDcuint64;
949 using ValueType = complex<uint64_t>;
952 using IntrinsicType = __m512i;
954 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
955 enum :
size_t {
size = 4UL };
956 #elif BLAZE_AVX2_MODE
957 using IntrinsicType = __m256i;
959 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
960 enum :
size_t {
size = 2UL };
961 #elif BLAZE_SSE2_MODE
962 using IntrinsicType = __m128i;
964 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
965 enum :
size_t {
size = 1UL };
967 using IntrinsicType = ValueType;
970 enum :
size_t {
size = 1UL };
975 template<
typename T >
978 template<
typename T >
979 BLAZE_ALWAYS_INLINE SIMDcuint64& operator=(
const SIMDci64<T>& v ) noexcept { value = (~v).value;
return *
this; }
1001 template<
typename T >
1002 struct SIMDf32 :
public SIMDPack< T >
1014 struct SIMDfloat :
public SIMDf32< SIMDfloat >
1016 using This = SIMDfloat;
1018 using ValueType = float;
1021 using IntrinsicType = __m512;
1023 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
1024 enum :
size_t {
size = 16UL };
1025 #elif BLAZE_AVX_MODE
1026 using IntrinsicType = __m256;
1028 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
1029 enum :
size_t {
size = 8UL };
1030 #elif BLAZE_SSE_MODE
1031 using IntrinsicType = __m128;
1033 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
1034 enum :
size_t {
size = 4UL };
1036 using IntrinsicType = ValueType;
1039 enum :
size_t {
size = 1UL };
1044 template<
typename T >
1047 template<
typename T >
1048 BLAZE_ALWAYS_INLINE SIMDfloat& operator=(
const SIMDf32<T>& v ) noexcept { value = (~v).
eval().value;
return *
this; }
1052 IntrinsicType value;
1072 template<
typename T >
1073 struct SIMDcf32 :
public SIMDPack< T >
1085 struct SIMDcfloat :
public SIMDcf32< SIMDcfloat >
1087 using This = SIMDcfloat;
1089 using ValueType = complex<float>;
1092 using IntrinsicType = __m512;
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_AVX_MODE
1097 using IntrinsicType = __m256;
1099 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
1100 enum :
size_t {
size = 4UL };
1101 #elif BLAZE_SSE_MODE
1102 using IntrinsicType = __m128;
1104 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
1105 enum :
size_t {
size = 2UL };
1107 using IntrinsicType = ValueType;
1110 enum :
size_t {
size = 1UL };
1115 template<
typename T >
1118 template<
typename T >
1119 BLAZE_ALWAYS_INLINE SIMDcfloat& operator=(
const SIMDcf32<T>& v ) noexcept { value = (~v).value;
return *
this; }
1121 IntrinsicType value;
1141 template<
typename T >
1142 struct SIMDf64 :
public SIMDPack< T >
1154 struct SIMDdouble :
public SIMDf64< SIMDdouble >
1156 using This = SIMDdouble;
1158 using ValueType = double;
1161 using IntrinsicType = __m512d;
1163 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
1164 enum :
size_t {
size = 8UL };
1165 #elif BLAZE_AVX_MODE
1166 using IntrinsicType = __m256d;
1168 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
1169 enum :
size_t {
size = 4UL };
1170 #elif BLAZE_SSE2_MODE
1171 using IntrinsicType = __m128d;
1173 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
1174 enum :
size_t {
size = 2UL };
1176 using IntrinsicType = ValueType;
1179 enum :
size_t {
size = 1UL };
1184 template<
typename T >
1187 template<
typename T >
1188 BLAZE_ALWAYS_INLINE SIMDdouble& operator=(
const SIMDf64<T>& v ) noexcept { value = (~v).
eval().value;
return *
this; }
1192 IntrinsicType value;
1212 template<
typename T >
1213 struct SIMDcf64 :
public SIMDPack< T >
1225 struct SIMDcdouble :
public SIMDcf64< SIMDcdouble >
1227 using This = SIMDcdouble;
1229 using ValueType = complex<double>;
1232 using IntrinsicType = __m512d;
1234 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
1235 enum :
size_t {
size = 4UL };
1236 #elif BLAZE_AVX_MODE
1237 using IntrinsicType = __m256d;
1239 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
1240 enum :
size_t {
size = 2UL };
1241 #elif BLAZE_SSE2_MODE
1242 using IntrinsicType = __m128d;
1244 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
1245 enum :
size_t {
size = 1UL };
1247 using IntrinsicType = ValueType;
1250 enum :
size_t {
size = 1UL };
1255 template<
typename T >
1258 template<
typename T >
1259 BLAZE_ALWAYS_INLINE SIMDcdouble& operator=(
const SIMDcf64<T>& v ) noexcept { value = (~v).value;
return *
this; }
1261 IntrinsicType value;
1283 template<
typename T1
1287 (~lhs) = (~lhs) + (~rhs);
1301 template<
typename T1
1305 (~lhs) = (~lhs) - (~rhs);
1319 template<
typename T1
1323 (~lhs) = (~lhs) * (~rhs);
1337 template<
typename T1
1341 (~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:258
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:1339
CompressedMatrix< Type, true > This
Type of this CompressedMatrix instance.
Definition: CompressedMatrix.h:2636
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:1321
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
Base class for all SIMD data types.The SIMDPack class template is a base class for all SIMD data type...
Definition: SIMDPack.h:63
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:1285
const DMatEvalExpr< MT, SO > eval(const DenseMatrix< MT, SO > &dm)
Forces the evaluation of the given dense matrix expression dm.
Definition: DMatEvalExpr.h:705
SparseMatrix< This, true > BaseType
Base type of this CompressedMatrix instance.
Definition: CompressedMatrix.h:2637
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:1303
System settings for the inline keywords.
Header file for the TrueType type/value trait base class.