35#ifndef _BLAZE_MATH_SIMD_BASICTYPES_H_
36#define _BLAZE_MATH_SIMD_BASICTYPES_H_
66 :
public SIMDPack< T >
79 :
public SIMDi8< SIMDint8 >
82 using BaseType = SIMDi8<This>;
85#if BLAZE_AVX512BW_MODE
86 using IntrinsicType = __m512i;
88 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
89 static constexpr size_t size = 64UL;
91 using IntrinsicType = ValueType;
94 static constexpr size_t size = 1UL;
96 using IntrinsicType = __m256i;
98 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
99 static constexpr size_t size = 32UL;
101 using IntrinsicType = __m128i;
103 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
104 static constexpr size_t size = 16UL;
106 using IntrinsicType = ValueType;
109 static constexpr size_t size = 1UL;
114 template<
typename T >
117 template<
typename T >
133 :
public SIMDi8< SIMDuint8 >
136 using BaseType = SIMDi8<This>;
139#if BLAZE_AVX512BW_MODE
140 using IntrinsicType = __m512i;
142 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
143 static constexpr size_t size = 64UL;
145 using IntrinsicType = ValueType;
148 static constexpr size_t size = 1UL;
150 using IntrinsicType = __m256i;
152 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
153 static constexpr size_t size = 32UL;
155 using IntrinsicType = __m128i;
157 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
158 static constexpr size_t size = 16UL;
160 using IntrinsicType = ValueType;
163 static constexpr size_t size = 1UL;
168 template<
typename T >
171 template<
typename T >
194template<
typename T >
196 :
public SIMDPack< T >
209 :
public SIMDci8< SIMDcint8 >
212 using BaseType = SIMDci8<This>;
215#if BLAZE_AVX512BW_MODE
216 using IntrinsicType = __m512i;
218 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
219 static constexpr size_t size = 32UL;
221 using IntrinsicType = ValueType;
224 static constexpr size_t size = 1UL;
226 using IntrinsicType = __m256i;
228 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
229 static constexpr size_t size = 16UL;
231 using IntrinsicType = __m128i;
233 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
234 static constexpr size_t size = 8UL;
236 using IntrinsicType = ValueType;
239 static constexpr size_t size = 1UL;
244 template<
typename T >
247 template<
typename T >
263 :
public SIMDci8< SIMDcuint8 >
266 using BaseType = SIMDci8<This>;
269#if BLAZE_AVX512BW_MODE
270 using IntrinsicType = __m512i;
272 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
273 static constexpr size_t size = 32UL;
275 using IntrinsicType = ValueType;
278 static constexpr size_t size = 1UL;
280 using IntrinsicType = __m256i;
282 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
283 static constexpr size_t size = 16UL;
285 using IntrinsicType = __m128i;
287 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
288 static constexpr size_t size = 8UL;
290 using IntrinsicType = ValueType;
293 static constexpr size_t size = 1UL;
298 template<
typename T >
301 template<
typename T >
324template<
typename T >
326 :
public SIMDPack< T >
339 :
public SIMDi16< SIMDint16 >
342 using BaseType = SIMDi16<This>;
345#if BLAZE_AVX512BW_MODE
346 using IntrinsicType = __m512i;
348 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
349 static constexpr size_t size = 32UL;
351 using IntrinsicType = ValueType;
354 static constexpr size_t size = 1UL;
356 using IntrinsicType = __m256i;
358 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
359 static constexpr size_t size = 16UL;
361 using IntrinsicType = __m128i;
363 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
364 static constexpr size_t size = 8UL;
366 using IntrinsicType = ValueType;
369 static constexpr size_t size = 1UL;
374 template<
typename T >
377 template<
typename T >
393 :
public SIMDi16< SIMDuint16 >
396 using BaseType = SIMDi16<This>;
399#if BLAZE_AVX512BW_MODE
400 using IntrinsicType = __m512i;
402 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
403 static constexpr size_t size = 32UL;
405 using IntrinsicType = ValueType;
408 static constexpr size_t size = 1UL;
410 using IntrinsicType = __m256i;
412 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
413 static constexpr size_t size = 16UL;
415 using IntrinsicType = __m128i;
417 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
418 static constexpr size_t size = 8UL;
420 using IntrinsicType = ValueType;
423 static constexpr size_t size = 1UL;
428 template<
typename T >
431 template<
typename T >
454template<
typename T >
456 :
public SIMDPack< T >
469 :
public SIMDci16< SIMDcint16 >
472 using BaseType = SIMDci16<This>;
475#if BLAZE_AVX512BW_MODE
476 using IntrinsicType = __m512i;
478 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
479 static constexpr size_t size = 16UL;
481 using IntrinsicType = ValueType;
484 static constexpr size_t size = 1UL;
486 using IntrinsicType = __m256i;
488 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
489 static constexpr size_t size = 8UL;
491 using IntrinsicType = __m128i;
493 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
494 static constexpr size_t size = 4UL;
496 using IntrinsicType = ValueType;
499 static constexpr size_t size = 1UL;
504 template<
typename T >
507 template<
typename T >
523 :
public SIMDci16< SIMDcuint16 >
526 using BaseType = SIMDci16<This>;
529#if BLAZE_AVX512BW_MODE
530 using IntrinsicType = __m512i;
532 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
533 static constexpr size_t size = 16UL;
535 using IntrinsicType = ValueType;
538 static constexpr size_t size = 1UL;
540 using IntrinsicType = __m256i;
542 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
543 static constexpr size_t size = 8UL;
545 using IntrinsicType = __m128i;
547 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
548 static constexpr size_t size = 4UL;
550 using IntrinsicType = ValueType;
553 static constexpr size_t size = 1UL;
558 template<
typename T >
561 template<
typename T >
584template<
typename T >
586 :
public SIMDPack< T >
599 :
public SIMDi32< SIMDint32 >
602 using BaseType = SIMDi32<This>;
605#if BLAZE_AVX512F_MODE || BLAZE_MIC_MODE
606 using IntrinsicType = __m512i;
608 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
609 static constexpr size_t size = 16UL;
611 using IntrinsicType = __m256i;
613 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
614 static constexpr size_t size = 8UL;
616 using IntrinsicType = __m128i;
618 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
619 static constexpr size_t size = 4UL;
621 using IntrinsicType = ValueType;
624 static constexpr size_t size = 1UL;
629 template<
typename T >
632 template<
typename T >
648 :
public SIMDi32< SIMDuint32 >
651 using BaseType = SIMDi32<This>;
654#if BLAZE_AVX512F_MODE || BLAZE_MIC_MODE
655 using IntrinsicType = __m512i;
657 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
658 static constexpr size_t size = 16UL;
660 using IntrinsicType = __m256i;
662 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
663 static constexpr size_t size = 8UL;
665 using IntrinsicType = __m128i;
667 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
668 static constexpr size_t size = 4UL;
670 using IntrinsicType = ValueType;
673 static constexpr size_t size = 1UL;
678 template<
typename T >
681 template<
typename T >
704template<
typename T >
706 :
public SIMDPack< T >
719 :
public SIMDci32< SIMDcint32 >
722 using BaseType = SIMDci32<This>;
725#if BLAZE_AVX512F_MODE || BLAZE_MIC_MODE
726 using IntrinsicType = __m512i;
728 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
729 static constexpr size_t size = 8UL;
731 using IntrinsicType = __m256i;
733 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
734 static constexpr size_t size = 4UL;
736 using IntrinsicType = __m128i;
738 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
739 static constexpr size_t size = 2UL;
741 using IntrinsicType = ValueType;
744 static constexpr size_t size = 1UL;
749 template<
typename T >
752 template<
typename T >
768 :
public SIMDci32< SIMDcuint32 >
771 using BaseType = SIMDci32<This>;
774#if BLAZE_AVX512F_MODE || BLAZE_MIC_MODE
775 using IntrinsicType = __m512i;
777 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
778 static constexpr size_t size = 8UL;
780 using IntrinsicType = __m256i;
782 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
783 static constexpr size_t size = 4UL;
785 using IntrinsicType = __m128i;
787 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
788 static constexpr size_t size = 2UL;
790 using IntrinsicType = ValueType;
793 static constexpr size_t size = 1UL;
798 template<
typename T >
801 template<
typename T >
824template<
typename T >
826 :
public SIMDPack< T >
839 :
public SIMDi64< SIMDint64 >
842 using BaseType = SIMDi64<This>;
845#if BLAZE_AVX512F_MODE || BLAZE_MIC_MODE
846 using IntrinsicType = __m512i;
848 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
849 static constexpr size_t size = 8UL;
851 using IntrinsicType = __m256i;
853 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
854 static constexpr size_t size = 4UL;
856 using IntrinsicType = __m128i;
858 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
859 static constexpr size_t size = 2UL;
861 using IntrinsicType = ValueType;
864 static constexpr size_t size = 1UL;
869 template<
typename T >
872 template<
typename T >
888 :
public SIMDi64< SIMDuint64 >
891 using BaseType = SIMDi64<This>;
894#if BLAZE_AVX512F_MODE || BLAZE_MIC_MODE
895 using IntrinsicType = __m512i;
897 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
898 static constexpr size_t size = 8UL;
900 using IntrinsicType = __m256i;
902 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
903 static constexpr size_t size = 4UL;
905 using IntrinsicType = __m128i;
907 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
908 static constexpr size_t size = 2UL;
910 using IntrinsicType = ValueType;
913 static constexpr size_t size = 1UL;
918 template<
typename T >
921 template<
typename T >
944template<
typename T >
946 :
public SIMDPack< T >
959 :
public SIMDci64< SIMDcint64 >
962 using BaseType = SIMDci64<This>;
965#if BLAZE_AVX512F_MODE || BLAZE_MIC_MODE
966 using IntrinsicType = __m512i;
968 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
969 static constexpr size_t size = 4UL;
971 using IntrinsicType = __m256i;
973 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
974 static constexpr size_t size = 2UL;
976 using IntrinsicType = __m128i;
978 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
979 static constexpr size_t size = 1UL;
981 using IntrinsicType = ValueType;
984 static constexpr size_t size = 1UL;
989 template<
typename T >
992 template<
typename T >
1008 :
public SIMDci64< SIMDcuint64 >
1011 using BaseType = SIMDci64<This>;
1014#if BLAZE_AVX512F_MODE || BLAZE_MIC_MODE
1015 using IntrinsicType = __m512i;
1017 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
1018 static constexpr size_t size = 4UL;
1019#elif BLAZE_AVX2_MODE
1020 using IntrinsicType = __m256i;
1022 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
1023 static constexpr size_t size = 2UL;
1024#elif BLAZE_SSE2_MODE
1025 using IntrinsicType = __m128i;
1027 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
1028 static constexpr size_t size = 1UL;
1030 using IntrinsicType = ValueType;
1033 static constexpr size_t size = 1UL;
1038 template<
typename T >
1041 template<
typename T >
1044 IntrinsicType value;
1064template<
typename T >
1066 :
public SIMDPack< T >
1079 :
public SIMDf32< SIMDfloat >
1082 using BaseType = SIMDf32<This>;
1083 using ValueType = float;
1085#if BLAZE_AVX512F_MODE || BLAZE_MIC_MODE
1086 using IntrinsicType = __m512;
1088 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
1089 static constexpr size_t size = 16UL;
1091 using IntrinsicType = __m256;
1093 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
1094 static constexpr size_t size = 8UL;
1096 using IntrinsicType = __m128;
1098 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
1099 static constexpr size_t size = 4UL;
1101 using IntrinsicType = ValueType;
1104 static constexpr size_t size = 1UL;
1109 template<
typename T >
1112 template<
typename T >
1117 IntrinsicType value;
1137template<
typename T >
1139 :
public SIMDPack< T >
1152 :
public SIMDcf32< SIMDcfloat >
1155 using BaseType = SIMDcf32<This>;
1158#if BLAZE_AVX512F_MODE || BLAZE_MIC_MODE
1159 using IntrinsicType = __m512;
1161 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
1162 static constexpr size_t size = 8UL;
1164 using IntrinsicType = __m256;
1166 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
1167 static constexpr size_t size = 4UL;
1169 using IntrinsicType = __m128;
1171 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
1172 static constexpr size_t size = 2UL;
1174 using IntrinsicType = ValueType;
1177 static constexpr size_t size = 1UL;
1182 template<
typename T >
1185 template<
typename T >
1188 IntrinsicType value;
1208template<
typename T >
1210 :
public SIMDPack< T >
1223 :
public SIMDf64< SIMDdouble >
1226 using BaseType = SIMDf64<This>;
1227 using ValueType = double;
1229#if BLAZE_AVX512F_MODE || BLAZE_MIC_MODE
1230 using IntrinsicType = __m512d;
1232 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
1233 static constexpr size_t size = 8UL;
1235 using IntrinsicType = __m256d;
1237 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
1238 static constexpr size_t size = 4UL;
1239#elif BLAZE_SSE2_MODE
1240 using IntrinsicType = __m128d;
1242 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
1243 static constexpr size_t size = 2UL;
1245 using IntrinsicType = ValueType;
1248 static constexpr size_t size = 1UL;
1253 template<
typename T >
1256 template<
typename T >
1261 IntrinsicType value;
1281template<
typename T >
1283 :
public SIMDPack< T >
1296 :
public SIMDcf64< SIMDcdouble >
1299 using BaseType = SIMDcf64<This>;
1302#if BLAZE_AVX512F_MODE || BLAZE_MIC_MODE
1303 using IntrinsicType = __m512d;
1305 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
1306 static constexpr size_t size = 4UL;
1308 using IntrinsicType = __m256d;
1310 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
1311 static constexpr size_t size = 2UL;
1312#elif BLAZE_SSE2_MODE
1313 using IntrinsicType = __m128d;
1315 BLAZE_ALWAYS_INLINE ValueType operator[](
size_t i )
const noexcept {
return reinterpret_cast<const ValueType*
>( &value )[i]; }
1316 static constexpr size_t size = 1UL;
1318 using IntrinsicType = ValueType;
1321 static constexpr size_t size = 1UL;
1326 template<
typename T >
1329 template<
typename T >
1332 IntrinsicType value;
1354template<
typename T1
1358 (*lhs) = (*lhs) + (*rhs);
1372template<
typename T1
1376 (*lhs) = (*lhs) - (*rhs);
1390template<
typename T1
1394 (*lhs) = (*lhs) * (*rhs);
1408template<
typename T1
1412 (*lhs) = (*lhs) / (*rhs);
Header file for the complex data type.
Base class for all SIMD data types.
Definition: SIMDPack.h:64
SIMD type for 64-bit double precision complex values.
SIMD type for 32-bit single precision complex values.
SIMD type for 16-bit signed integral complex values.
SIMD type for 32-bit signed integral complex values.
SIMD type for 64-bit signed integral complex values.
SIMD type for 8-bit signed integral complex values.
SIMD type for 16-bit unsigned integral complex values.
SIMD type for 32-bit unsigned integral complex values.
SIMD type for 64-bit unsigned integral complex values.
SIMD type for 8-bit unsigned integral complex values.
SIMD type for 64-bit double precision floating point data values.
SIMD type for 32-bit single precision floating point data values.
SIMD type for 16-bit signed integral data values.
SIMD type for 32-bit signed integral data values.
SIMD type for 64-bit integral data values.
SIMD type for 8-bit signed integral data values.
SIMD type for 16-bit unsigned integral data values.
SIMD type for 32-bit unsigned integral data values.
SIMD type for 64-bit unsigned integral data values.
SIMD type for 8-bit unsigned integral data values.
Complex data type of the Blaze library.
16-bit signed integer type of the Blaze library.
32-bit signed integer type of the Blaze library.
64-bit signed integer type of the Blaze library.
8-bit signed integer type of the Blaze library.
16-bit unsigned integer type of the Blaze library.
32-bit unsigned integer type of the Blaze library.
64-bit unsigned integer type of the Blaze library.
8-bit unsigned integer type of the Blaze library.
decltype(auto) eval(const DenseMatrix< MT, SO > &dm)
Forces the evaluation of the given dense matrix expression dm.
Definition: DMatEvalExpr.h:790
constexpr size_t size(const Matrix< MT, SO > &matrix) noexcept
Returns the total number of elements of the matrix.
Definition: Matrix.h:676
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:1410
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:1392
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:1356
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:1374
#define BLAZE_ALWAYS_INLINE
Platform dependent setup of an enforced inline keyword.
Definition: Inline.h:85
Header file for the SIMDPack base class.
System settings for the inline keywords.
System settings for the SSE mode.
Header file for basic type definitions.