All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
BasicTypes.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_INTRINSICS_BASICTYPES_H_
36 #define _BLAZE_MATH_INTRINSICS_BASICTYPES_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
44 #include <blaze/util/Complex.h>
45 #include <blaze/util/Types.h>
46 
47 
48 namespace blaze {
49 
50 //=================================================================================================
51 //
52 // BASIC INTRINSIC TYPES
53 //
54 //=================================================================================================
55 
56 //*************************************************************************************************
62 #if BLAZE_AVX2_MODE
63 struct sse_int8_t {
64  inline sse_int8_t() : value( _mm256_setzero_si256() ) {}
65  inline sse_int8_t( __m256i v ) : value( v ) {}
66  inline int8_t& operator[]( size_t i ) { return reinterpret_cast<int8_t* >( &value )[i]; }
67  inline const int8_t& operator[]( size_t i ) const { return reinterpret_cast<const int8_t*>( &value )[i]; }
68  __m256i value; // Contains 32 8-bit integral data values
69 };
70 #elif BLAZE_SSE2_MODE
71 struct sse_int8_t {
72  inline sse_int8_t() : value( _mm_setzero_si128() ) {}
73  inline sse_int8_t( __m128i v ) : value( v ) {}
74  inline int8_t& operator[]( size_t i ) { return reinterpret_cast<int8_t* >( &value )[i]; }
75  inline const int8_t& operator[]( size_t i ) const { return reinterpret_cast<const int8_t*>( &value )[i]; }
76  __m128i value; // Contains 16 8-bit integral data values
77 };
78 #else
79 struct sse_int8_t {
80  inline sse_int8_t() : value( 0 ) {}
81  inline sse_int8_t( int8_t v ) : value( v ) {}
82  inline int8_t& operator[]( size_t /*i*/ ) { return value; }
83  inline const int8_t& operator[]( size_t /*i*/ ) const { return value; }
84  int8_t value;
85 };
86 #endif
87 
88 //*************************************************************************************************
89 
90 
91 //*************************************************************************************************
97 #if BLAZE_AVX2_MODE
98 struct sse_int16_t {
99  inline sse_int16_t() : value( _mm256_setzero_si256() ) {}
100  inline sse_int16_t( __m256i v ) : value( v ) {}
101  inline int16_t& operator[]( size_t i ) { return reinterpret_cast<int16_t* >( &value )[i]; }
102  inline const int16_t& operator[]( size_t i ) const { return reinterpret_cast<const int16_t*>( &value )[i]; }
103  __m256i value; // Contains 16 16-bit integral data values
104 };
105 #elif BLAZE_SSE2_MODE
106 struct sse_int16_t {
107  inline sse_int16_t() : value( _mm_setzero_si128() ) {}
108  inline sse_int16_t( __m128i v ) : value( v ) {}
109  inline int16_t& operator[]( size_t i ) { return reinterpret_cast<int16_t* >( &value )[i]; }
110  inline const int16_t& operator[]( size_t i ) const { return reinterpret_cast<const int16_t*>( &value )[i]; }
111  __m128i value; // Contains 8 16-bit integral data values
112 };
113 #else
114 struct sse_int16_t {
115  inline sse_int16_t() : value( 0 ) {}
116  inline sse_int16_t( int16_t v ) : value( v ) {}
117  inline int16_t& operator[]( size_t /*i*/ ) { return value; }
118  inline const int16_t& operator[]( size_t /*i*/ ) const { return value; }
119  int16_t value;
120 };
121 #endif
122 
123 //*************************************************************************************************
124 
125 
126 //*************************************************************************************************
132 #if BLAZE_MIC_MODE
133 struct sse_int32_t {
134  inline sse_int32_t() : value( _mm512_setzero_epi32() ) {}
135  inline sse_int32_t( __m512i v ) : value( v ) {}
136  inline int32_t& operator[]( size_t i ) { return reinterpret_cast<int32_t* >( &value )[i]; }
137  inline const int32_t& operator[]( size_t i ) const { return reinterpret_cast<const int32_t*>( &value )[i]; }
138  __m512i value; // Contains 16 32-bit integral data values
139 };
140 #elif BLAZE_AVX2_MODE
141 struct sse_int32_t {
142  inline sse_int32_t() : value( _mm256_setzero_si256() ) {}
143  inline sse_int32_t( __m256i v ) : value( v ) {}
144  inline int32_t& operator[]( size_t i ) { return reinterpret_cast<int32_t* >( &value )[i]; }
145  inline const int32_t& operator[]( size_t i ) const { return reinterpret_cast<const int32_t*>( &value )[i]; }
146  __m256i value; // Contains 8 32-bit integral data values
147 };
148 #elif BLAZE_SSE2_MODE
149 struct sse_int32_t {
150  inline sse_int32_t() : value( _mm_setzero_si128() ) {}
151  inline sse_int32_t( __m128i v ) : value( v ) {}
152  inline int32_t& operator[]( size_t i ) { return reinterpret_cast<int32_t* >( &value )[i]; }
153  inline const int32_t& operator[]( size_t i ) const { return reinterpret_cast<const int32_t*>( &value )[i]; }
154  __m128i value; // Contains 4 32-bit integral data values
155 };
156 #else
157 struct sse_int32_t {
158  inline sse_int32_t() : value( 0 ) {}
159  inline sse_int32_t( int32_t v ) : value( v ) {}
160  inline int32_t& operator[]( size_t /*i*/ ) { return value; }
161  inline const int32_t& operator[]( size_t /*i*/ ) const { return value; }
162  int32_t value;
163 };
164 #endif
165 
166 //*************************************************************************************************
167 
168 
169 //*************************************************************************************************
175 #if BLAZE_MIC_MODE
176 struct sse_int64_t {
177  inline sse_int64_t() : value( _mm512_setzero_epi32() ) {}
178  inline sse_int64_t( __m512i v ) : value( v ) {}
179  inline int64_t& operator[]( size_t i ) { return reinterpret_cast<int64_t* >( &value )[i]; }
180  inline const int64_t& operator[]( size_t i ) const { return reinterpret_cast<const int64_t*>( &value )[i]; }
181  __m512i value; // Contains 8 64-bit integral data values
182 };
183 #elif BLAZE_AVX2_MODE
184 struct sse_int64_t {
185  inline sse_int64_t() : value( _mm256_setzero_si256() ) {}
186  inline sse_int64_t( __m256i v ) : value( v ) {}
187  inline int64_t& operator[]( size_t i ) { return reinterpret_cast<int64_t* >( &value )[i]; }
188  inline const int64_t& operator[]( size_t i ) const { return reinterpret_cast<const int64_t*>( &value )[i]; }
189  __m256i value; // Contains 4 64-bit integral data values
190 };
191 #elif BLAZE_SSE2_MODE
192 struct sse_int64_t {
193  inline sse_int64_t() : value( _mm_setzero_si128() ) {}
194  inline sse_int64_t( __m128i v ) : value( v ) {}
195  inline int64_t& operator[]( size_t i ) { return reinterpret_cast<int64_t* >( &value )[i]; }
196  inline const int64_t& operator[]( size_t i ) const { return reinterpret_cast<const int64_t*>( &value )[i]; }
197  __m128i value; // Contains 2 64-bit integral data values
198 };
199 #else
200 struct sse_int64_t {
201  inline sse_int64_t() : value( 0 ) {}
202  inline sse_int64_t( int64_t v ) : value( v ) {}
203  inline int64_t& operator[]( size_t /*i*/ ) { return value; }
204  inline const int64_t& operator[]( size_t /*i*/ ) const { return value; }
205  int64_t value;
206 };
207 #endif
208 
209 //*************************************************************************************************
210 
211 
212 //*************************************************************************************************
218 #if BLAZE_MIC_MODE
219 struct sse_float_t {
220  inline sse_float_t() : value( _mm512_setzero_ps() ) {}
221  inline sse_float_t( __m512 v ) : value( v ) {}
222  inline float& operator[]( size_t i ) { return reinterpret_cast<float* >( &value )[i]; }
223  inline const float& operator[]( size_t i ) const { return reinterpret_cast<const float*>( &value )[i]; }
224  __m512 value; // Contains 16 32-bit single precision floating point values
225 };
226 #elif BLAZE_AVX_MODE
227 struct sse_float_t {
228  inline sse_float_t() : value( _mm256_setzero_ps() ) {}
229  inline sse_float_t( __m256 v ) : value( v ) {}
230  inline float& operator[]( size_t i ) { return reinterpret_cast<float* >( &value )[i]; }
231  inline const float& operator[]( size_t i ) const { return reinterpret_cast<const float*>( &value )[i]; }
232  __m256 value; // Contains 8 32-bit single precision floating point values
233 };
234 #elif BLAZE_SSE_MODE
235 struct sse_float_t {
236  inline sse_float_t() : value( _mm_setzero_ps() ) {}
237  inline sse_float_t( __m128 v ) : value( v ) {}
238  inline float& operator[]( size_t i ) { return reinterpret_cast<float* >( &value )[i]; }
239  inline const float& operator[]( size_t i ) const { return reinterpret_cast<const float*>( &value )[i]; }
240  __m128 value; // Contains 4 32-bit single precision floating point values
241 };
242 #else
243 struct sse_float_t {
244  inline sse_float_t() : value( 0.0F ) {}
245  inline sse_float_t( float v ) : value( v ) {}
246  inline float& operator[]( size_t /*i*/ ) { return value; }
247  inline const float& operator[]( size_t /*i*/ ) const { return value; }
248  float value;
249 };
250 #endif
251 
252 //*************************************************************************************************
253 
254 
255 //*************************************************************************************************
261 #if BLAZE_MIC_MODE
262 struct sse_double_t {
263  inline sse_double_t() : value( _mm512_setzero_pd() ) {}
264  inline sse_double_t( __m512d v ) : value( v ) {}
265  inline double& operator[]( size_t i ) { return reinterpret_cast<double* >( &value )[i]; }
266  inline const double& operator[]( size_t i ) const { return reinterpret_cast<const double*>( &value )[i]; }
267  __m512d value; // Contains 8 64-bit double precision floating point values
268 };
269 #elif BLAZE_AVX_MODE
270 struct sse_double_t {
271  inline sse_double_t() : value( _mm256_setzero_pd() ) {}
272  inline sse_double_t( __m256d v ) : value( v ) {}
273  inline double& operator[]( size_t i ) { return reinterpret_cast<double* >( &value )[i]; }
274  inline const double& operator[]( size_t i ) const { return reinterpret_cast<const double*>( &value )[i]; }
275  __m256d value; // Contains 4 64-bit double precision floating point values
276 };
277 #elif BLAZE_SSE2_MODE
278 struct sse_double_t {
279  inline sse_double_t() : value( _mm_setzero_pd() ) {}
280  inline sse_double_t( __m128d v ) : value( v ) {}
281  inline double& operator[]( size_t i ) { return reinterpret_cast<double* >( &value )[i]; }
282  inline const double& operator[]( size_t i ) const { return reinterpret_cast<const double*>( &value )[i]; }
283  __m128d value; // Contains 2 64-bit double precision floating point values
284 };
285 #else
286 struct sse_double_t {
287  inline sse_double_t() : value( 0.0 ) {}
288  inline sse_double_t( double v ) : value( v ) {}
289  inline double& operator[]( size_t /*i*/ ) { return value; }
290  inline const double& operator[]( size_t /*i*/ ) const { return value; }
291  double value;
292 };
293 #endif
294 
295 //*************************************************************************************************
296 
297 
298 //*************************************************************************************************
304 #if BLAZE_MIC_MODE
305 struct sse_cfloat_t {
306  inline sse_cfloat_t() : value( _mm512_setzero_ps() ) {}
307  inline sse_cfloat_t( __m512 v ) : value( v ) {}
308  inline complex<float>& operator[]( size_t i ) { return reinterpret_cast<complex<float>* >( &value )[i]; }
309  inline const complex<float>& operator[]( size_t i ) const { return reinterpret_cast<const complex<float>*>( &value )[i]; }
310  __m512 value; // Contains 8 32-bit single precision complex values
311 };
312 #elif BLAZE_AVX_MODE
313 struct sse_cfloat_t {
314  inline sse_cfloat_t() : value( _mm256_setzero_ps() ) {}
315  inline sse_cfloat_t( __m256 v ) : value( v ) {}
316  inline complex<float>& operator[]( size_t i ) { return reinterpret_cast<complex<float>* >( &value )[i]; }
317  inline const complex<float>& operator[]( size_t i ) const { return reinterpret_cast<const complex<float>*>( &value )[i]; }
318  __m256 value; // Contains 4 32-bit single precision complex values
319 };
320 #elif BLAZE_SSE_MODE
321 struct sse_cfloat_t {
322  inline sse_cfloat_t() : value( _mm_setzero_ps() ) {}
323  inline sse_cfloat_t( __m128 v ) : value( v ) {}
324  inline complex<float>& operator[]( size_t i ) { return reinterpret_cast<complex<float>* >( &value )[i]; }
325  inline const complex<float>& operator[]( size_t i ) const { return reinterpret_cast<const complex<float>*>( &value )[i]; }
326  __m128 value; // Contains 2 32-bit single precision complex values
327 };
328 #else
329 struct sse_cfloat_t {
330  inline sse_cfloat_t() : value( 0.0F, 0.0F ) {}
331  inline sse_cfloat_t( complex<float> v ) : value( v ) {}
332  inline complex<float>& operator[]( size_t /*i*/ ) { return value; }
333  inline const complex<float>& operator[]( size_t /*i*/ ) const { return value; }
334  complex<float> value;
335 };
336 #endif
337 
338 //*************************************************************************************************
339 
340 
341 //*************************************************************************************************
347 #if BLAZE_MIC_MODE
348 struct sse_cdouble_t {
349  inline sse_cdouble_t() : value( _mm512_setzero_pd() ) {}
350  inline sse_cdouble_t( __m512d v ) : value( v ) {}
351  inline complex<double>& operator[]( size_t i ) { return reinterpret_cast<complex<double>* >( &value )[i]; }
352  inline const complex<double>& operator[]( size_t i ) const { return reinterpret_cast<const complex<double>*>( &value )[i]; }
353  __m512d value; // Contains 4 64-bit double precision complex value
354 };
355 #elif BLAZE_AVX_MODE
356 struct sse_cdouble_t {
357  inline sse_cdouble_t() : value( _mm256_setzero_pd() ) {}
358  inline sse_cdouble_t( __m256d v ) : value( v ) {}
359  inline complex<double>& operator[]( size_t i ) { return reinterpret_cast<complex<double>* >( &value )[i]; }
360  inline const complex<double>& operator[]( size_t i ) const { return reinterpret_cast<const complex<double>*>( &value )[i]; }
361  __m256d value; // Contains 2 64-bit double precision complex value
362 };
363 #elif BLAZE_SSE2_MODE
364 struct sse_cdouble_t {
365  inline sse_cdouble_t() : value( _mm_setzero_pd() ) {}
366  inline sse_cdouble_t( __m128d v ) : value( v ) {}
367  inline complex<double>& operator[]( size_t i ) { return reinterpret_cast<complex<double>* >( &value )[i]; }
368  inline const complex<double>& operator[]( size_t i ) const { return reinterpret_cast<const complex<double>*>( &value )[i]; }
369  __m128d value; // Contains 1 64-bit double precision complex value
370 };
371 #else
372 struct sse_cdouble_t {
373  inline sse_cdouble_t() : value( 0.0, 0.0 ) {}
374  inline sse_cdouble_t( complex<double> v ) : value( v ) {}
375  inline complex<double>& operator[]( size_t /*i*/ ) { return value; }
376  inline const complex<double>& operator[]( size_t /*i*/ ) const { return value; }
377  complex<double> value;
378 };
379 #endif
380 
381 //*************************************************************************************************
382 
383 } // namespace blaze
384 
385 #endif
Header file for basic type definitions.
System settings for the SSE mode.
Header file for the complex data type.