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 ) const { return reinterpret_cast<const int8_t*>( &value )[i]; }
67  __m256i value; // Contains 32 8-bit integral data values
68 };
69 #elif BLAZE_SSE2_MODE
70 struct sse_int8_t {
71  inline sse_int8_t() : value( _mm_setzero_si128() ) {}
72  inline sse_int8_t( __m128i v ) : value( v ) {}
73  inline int8_t operator[]( size_t i ) const { return reinterpret_cast<const int8_t*>( &value )[i]; }
74  __m128i value; // Contains 16 8-bit integral data values
75 };
76 #else
77 struct sse_int8_t {
78  inline sse_int8_t() : value( 0 ) {}
79  inline sse_int8_t( int8_t v ) : value( v ) {}
80  inline int8_t operator[]( size_t /*i*/ ) const { return value; }
81  int8_t value;
82 };
83 #endif
84 
85 //*************************************************************************************************
86 
87 
88 //*************************************************************************************************
94 #if BLAZE_AVX2_MODE
95 struct sse_int16_t {
96  inline sse_int16_t() : value( _mm256_setzero_si256() ) {}
97  inline sse_int16_t( __m256i v ) : value( v ) {}
98  inline int16_t operator[]( size_t i ) const { return reinterpret_cast<const int16_t*>( &value )[i]; }
99  __m256i value; // Contains 16 16-bit integral data values
100 };
101 #elif BLAZE_SSE2_MODE
102 struct sse_int16_t {
103  inline sse_int16_t() : value( _mm_setzero_si128() ) {}
104  inline sse_int16_t( __m128i v ) : value( v ) {}
105  inline int16_t operator[]( size_t i ) const { return reinterpret_cast<const int16_t*>( &value )[i]; }
106  __m128i value; // Contains 8 16-bit integral data values
107 };
108 #else
109 struct sse_int16_t {
110  inline sse_int16_t() : value( 0 ) {}
111  inline sse_int16_t( int16_t v ) : value( v ) {}
112  inline int16_t operator[]( size_t /*i*/ ) const { return value; }
113  int16_t value;
114 };
115 #endif
116 
117 //*************************************************************************************************
118 
119 
120 //*************************************************************************************************
126 #if BLAZE_MIC_MODE
127 struct sse_int32_t {
128  inline sse_int32_t() : value( _mm512_setzero_epi32() ) {}
129  inline sse_int32_t( __m512i v ) : value( v ) {}
130  inline int32_t operator[]( size_t i ) const { return reinterpret_cast<const int32_t*>( &value )[i]; }
131  __m512i value; // Contains 16 32-bit integral data values
132 };
133 #elif BLAZE_AVX2_MODE
134 struct sse_int32_t {
135  inline sse_int32_t() : value( _mm256_setzero_si256() ) {}
136  inline sse_int32_t( __m256i v ) : value( v ) {}
137  inline int32_t operator[]( size_t i ) const { return reinterpret_cast<const int32_t*>( &value )[i]; }
138  __m256i value; // Contains 8 32-bit integral data values
139 };
140 #elif BLAZE_SSE2_MODE
141 struct sse_int32_t {
142  inline sse_int32_t() : value( _mm_setzero_si128() ) {}
143  inline sse_int32_t( __m128i v ) : value( v ) {}
144  inline int32_t operator[]( size_t i ) const { return reinterpret_cast<const int32_t*>( &value )[i]; }
145  __m128i value; // Contains 4 32-bit integral data values
146 };
147 #else
148 struct sse_int32_t {
149  inline sse_int32_t() : value( 0 ) {}
150  inline sse_int32_t( int32_t v ) : value( v ) {}
151  inline int32_t operator[]( size_t /*i*/ ) const { return value; }
152  int32_t value;
153 };
154 #endif
155 
156 //*************************************************************************************************
157 
158 
159 //*************************************************************************************************
165 #if BLAZE_MIC_MODE
166 struct sse_int64_t {
167  inline sse_int64_t() : value( _mm512_setzero_epi32() ) {}
168  inline sse_int64_t( __m512i v ) : value( v ) {}
169  inline int64_t operator[]( size_t i ) const { return reinterpret_cast<const int64_t*>( &value )[i]; }
170  __m512i value; // Contains 8 64-bit integral data values
171 };
172 #elif BLAZE_AVX2_MODE
173 struct sse_int64_t {
174  inline sse_int64_t() : value( _mm256_setzero_si256() ) {}
175  inline sse_int64_t( __m256i v ) : value( v ) {}
176  inline int64_t operator[]( size_t i ) const { return reinterpret_cast<const int64_t*>( &value )[i]; }
177  __m256i value; // Contains 4 64-bit integral data values
178 };
179 #elif BLAZE_SSE2_MODE
180 struct sse_int64_t {
181  inline sse_int64_t() : value( _mm_setzero_si128() ) {}
182  inline sse_int64_t( __m128i v ) : value( v ) {}
183  inline int64_t operator[]( size_t i ) const { return reinterpret_cast<const int64_t*>( &value )[i]; }
184  __m128i value; // Contains 2 64-bit integral data values
185 };
186 #else
187 struct sse_int64_t {
188  inline sse_int64_t() : value( 0 ) {}
189  inline sse_int64_t( int64_t v ) : value( v ) {}
190  inline int64_t operator[]( size_t /*i*/ ) const { return value; }
191  int64_t value;
192 };
193 #endif
194 
195 //*************************************************************************************************
196 
197 
198 //*************************************************************************************************
204 #if BLAZE_MIC_MODE
205 struct sse_float_t {
206  inline sse_float_t() : value( _mm512_setzero_ps() ) {}
207  inline sse_float_t( __m512 v ) : value( v ) {}
208  inline float operator[]( size_t i ) const { return reinterpret_cast<const float*>( &value )[i]; }
209  __m512 value; // Contains 16 32-bit single precision floating point values
210 };
211 #elif BLAZE_AVX_MODE
212 struct sse_float_t {
213  inline sse_float_t() : value( _mm256_setzero_ps() ) {}
214  inline sse_float_t( __m256 v ) : value( v ) {}
215  inline float operator[]( size_t i ) const { return reinterpret_cast<const float*>( &value )[i]; }
216  __m256 value; // Contains 8 32-bit single precision floating point values
217 };
218 #elif BLAZE_SSE_MODE
219 struct sse_float_t {
220  inline sse_float_t() : value( _mm_setzero_ps() ) {}
221  inline sse_float_t( __m128 v ) : value( v ) {}
222  inline float operator[]( size_t i ) const { return reinterpret_cast<const float*>( &value )[i]; }
223  __m128 value; // Contains 4 32-bit single precision floating point values
224 };
225 #else
226 struct sse_float_t {
227  inline sse_float_t() : value( 0.0F ) {}
228  inline sse_float_t( float v ) : value( v ) {}
229  inline float operator[]( size_t /*i*/ ) const { return value; }
230  float value;
231 };
232 #endif
233 
234 //*************************************************************************************************
235 
236 
237 //*************************************************************************************************
243 #if BLAZE_MIC_MODE
244 struct sse_double_t {
245  inline sse_double_t() : value( _mm512_setzero_pd() ) {}
246  inline sse_double_t( __m512d v ) : value( v ) {}
247  inline double operator[]( size_t i ) const { return reinterpret_cast<const double*>( &value )[i]; }
248  __m512d value; // Contains 8 64-bit double precision floating point values
249 };
250 #elif BLAZE_AVX_MODE
251 struct sse_double_t {
252  inline sse_double_t() : value( _mm256_setzero_pd() ) {}
253  inline sse_double_t( __m256d v ) : value( v ) {}
254  inline double operator[]( size_t i ) const { return reinterpret_cast<const double*>( &value )[i]; }
255  __m256d value; // Contains 4 64-bit double precision floating point values
256 };
257 #elif BLAZE_SSE2_MODE
258 struct sse_double_t {
259  inline sse_double_t() : value( _mm_setzero_pd() ) {}
260  inline sse_double_t( __m128d v ) : value( v ) {}
261  inline double operator[]( size_t i ) const { return reinterpret_cast<const double*>( &value )[i]; }
262  __m128d value; // Contains 2 64-bit double precision floating point values
263 };
264 #else
265 struct sse_double_t {
266  inline sse_double_t() : value( 0.0 ) {}
267  inline sse_double_t( double v ) : value( v ) {}
268  inline double operator[]( size_t /*i*/ ) const { return value; }
269  double value;
270 };
271 #endif
272 
273 //*************************************************************************************************
274 
275 
276 //*************************************************************************************************
282 #if BLAZE_MIC_MODE
283 struct sse_cfloat_t {
284  inline sse_cfloat_t() : value( _mm512_setzero_ps() ) {}
285  inline sse_cfloat_t( __m512 v ) : value( v ) {}
286  inline complex<float> operator[]( size_t i ) const { return reinterpret_cast<const complex<float>*>( &value )[i]; }
287  __m512 value; // Contains 8 32-bit single precision complex values
288 };
289 #elif BLAZE_AVX_MODE
290 struct sse_cfloat_t {
291  inline sse_cfloat_t() : value( _mm256_setzero_ps() ) {}
292  inline sse_cfloat_t( __m256 v ) : value( v ) {}
293  inline complex<float> operator[]( size_t i ) const { return reinterpret_cast<const complex<float>*>( &value )[i]; }
294  __m256 value; // Contains 4 32-bit single precision complex values
295 };
296 #elif BLAZE_SSE_MODE
297 struct sse_cfloat_t {
298  inline sse_cfloat_t() : value( _mm_setzero_ps() ) {}
299  inline sse_cfloat_t( __m128 v ) : value( v ) {}
300  inline complex<float> operator[]( size_t i ) const { return reinterpret_cast<const complex<float>*>( &value )[i]; }
301  __m128 value; // Contains 2 32-bit single precision complex values
302 };
303 #else
304 struct sse_cfloat_t {
305  inline sse_cfloat_t() : value( 0.0F, 0.0F ) {}
306  inline sse_cfloat_t( complex<float> v ) : value( v ) {}
307  inline complex<float> operator[]( size_t /*i*/ ) const { return value; }
308  complex<float> value;
309 };
310 #endif
311 
312 //*************************************************************************************************
313 
314 
315 //*************************************************************************************************
321 #if BLAZE_MIC_MODE
322 struct sse_cdouble_t {
323  inline sse_cdouble_t() : value( _mm512_setzero_pd() ) {}
324  inline sse_cdouble_t( __m512d v ) : value( v ) {}
325  inline complex<double> operator[]( size_t i ) const { return reinterpret_cast<const complex<double>*>( &value )[i]; }
326  __m512d value; // Contains 4 64-bit double precision complex value
327 };
328 #elif BLAZE_AVX_MODE
329 struct sse_cdouble_t {
330  inline sse_cdouble_t() : value( _mm256_setzero_pd() ) {}
331  inline sse_cdouble_t( __m256d v ) : value( v ) {}
332  inline complex<double> operator[]( size_t i ) const { return reinterpret_cast<const complex<double>*>( &value )[i]; }
333  __m256d value; // Contains 2 64-bit double precision complex value
334 };
335 #elif BLAZE_SSE2_MODE
336 struct sse_cdouble_t {
337  inline sse_cdouble_t() : value( _mm_setzero_pd() ) {}
338  inline sse_cdouble_t( __m128d v ) : value( v ) {}
339  inline complex<double> operator[]( size_t i ) const { return reinterpret_cast<const complex<double>*>( &value )[i]; }
340  __m128d value; // Contains 1 64-bit double precision complex value
341 };
342 #else
343 struct sse_cdouble_t {
344  inline sse_cdouble_t() : value( 0.0, 0.0 ) {}
345  inline sse_cdouble_t( complex<double> v ) : value( v ) {}
346  inline complex<double> operator[]( size_t /*i*/ ) const { return value; }
347  complex<double> value;
348 };
349 #endif
350 
351 //*************************************************************************************************
352 
353 } // namespace blaze
354 
355 #endif
Header file for basic type definitions.
System settings for the SSE mode.
Header file for the complex data type.