All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
BasicTypes.h
Go to the documentation of this file.
1 //=================================================================================================
20 //=================================================================================================
21 
22 #ifndef _BLAZE_MATH_INTRINSICS_BASICTYPES_H_
23 #define _BLAZE_MATH_INTRINSICS_BASICTYPES_H_
24 
25 
26 //*************************************************************************************************
27 // Includes
28 //*************************************************************************************************
29 
31 #include <blaze/util/Complex.h>
32 #include <blaze/util/Types.h>
33 
34 
35 namespace blaze {
36 
37 //=================================================================================================
38 //
39 // BASIC INTRINSIC TYPES
40 //
41 //=================================================================================================
42 
43 //*************************************************************************************************
49 #if BLAZE_AVX2_MODE
50 struct sse_int8_t {
51  inline sse_int8_t() : value( _mm256_setzero_si256() ) {}
52  inline sse_int8_t( __m256i v ) : value( v ) {}
53  inline int8_t& operator[]( size_t i ) { return reinterpret_cast<int8_t* >( &value )[i]; }
54  inline const int8_t& operator[]( size_t i ) const { return reinterpret_cast<const int8_t*>( &value )[i]; }
55  __m256i value; // Contains 32 8-bit integral data values
56 };
57 #elif BLAZE_SSE2_MODE
58 struct sse_int8_t {
59  inline sse_int8_t() : value( _mm_setzero_si128() ) {}
60  inline sse_int8_t( __m128i v ) : value( v ) {}
61  inline int8_t& operator[]( size_t i ) { return reinterpret_cast<int8_t* >( &value )[i]; }
62  inline const int8_t& operator[]( size_t i ) const { return reinterpret_cast<const int8_t*>( &value )[i]; }
63  __m128i value; // Contains 16 8-bit integral data values
64 };
65 #else
66 struct sse_int8_t {
67  inline sse_int8_t() : value( 0 ) {}
68  inline sse_int8_t( int8_t v ) : value( v ) {}
69  inline int8_t& operator[]( size_t /*i*/ ) { return value; }
70  inline const int8_t& operator[]( size_t /*i*/ ) const { return value; }
71  int8_t value;
72 };
73 #endif
74 
75 //*************************************************************************************************
76 
77 
78 //*************************************************************************************************
84 #if BLAZE_AVX2_MODE
85 struct sse_int16_t {
86  inline sse_int16_t() : value( _mm256_setzero_si256() ) {}
87  inline sse_int16_t( __m256i v ) : value( v ) {}
88  inline int16_t& operator[]( size_t i ) { return reinterpret_cast<int16_t* >( &value )[i]; }
89  inline const int16_t& operator[]( size_t i ) const { return reinterpret_cast<const int16_t*>( &value )[i]; }
90  __m256i value; // Contains 16 16-bit integral data values
91 };
92 #elif BLAZE_SSE2_MODE
93 struct sse_int16_t {
94  inline sse_int16_t() : value( _mm_setzero_si128() ) {}
95  inline sse_int16_t( __m128i v ) : value( v ) {}
96  inline int16_t& operator[]( size_t i ) { return reinterpret_cast<int16_t* >( &value )[i]; }
97  inline const int16_t& operator[]( size_t i ) const { return reinterpret_cast<const int16_t*>( &value )[i]; }
98  __m128i value; // Contains 8 16-bit integral data values
99 };
100 #else
101 struct sse_int16_t {
102  inline sse_int16_t() : value( 0 ) {}
103  inline sse_int16_t( int16_t v ) : value( v ) {}
104  inline int16_t& operator[]( size_t /*i*/ ) { return value; }
105  inline const int16_t& operator[]( size_t /*i*/ ) const { return value; }
106  int16_t value;
107 };
108 #endif
109 
110 //*************************************************************************************************
111 
112 
113 //*************************************************************************************************
119 #if BLAZE_MIC_MODE
120 struct sse_int32_t {
121  inline sse_int32_t() : value( _mm512_setzero_epi32() ) {}
122  inline sse_int32_t( __m512i v ) : value( v ) {}
123  inline int32_t& operator[]( size_t i ) { return reinterpret_cast<int32_t* >( &value )[i]; }
124  inline const int32_t& operator[]( size_t i ) const { return reinterpret_cast<const int32_t*>( &value )[i]; }
125  __m512i value; // Contains 16 32-bit integral data values
126 };
127 #elif BLAZE_AVX2_MODE
128 struct sse_int32_t {
129  inline sse_int32_t() : value( _mm256_setzero_si256() ) {}
130  inline sse_int32_t( __m256i v ) : value( v ) {}
131  inline int32_t& operator[]( size_t i ) { return reinterpret_cast<int32_t* >( &value )[i]; }
132  inline const int32_t& operator[]( size_t i ) const { return reinterpret_cast<const int32_t*>( &value )[i]; }
133  __m256i value; // Contains 8 32-bit integral data values
134 };
135 #elif BLAZE_SSE2_MODE
136 struct sse_int32_t {
137  inline sse_int32_t() : value( _mm_setzero_si128() ) {}
138  inline sse_int32_t( __m128i v ) : value( v ) {}
139  inline int32_t& operator[]( size_t i ) { return reinterpret_cast<int32_t* >( &value )[i]; }
140  inline const int32_t& operator[]( size_t i ) const { return reinterpret_cast<const int32_t*>( &value )[i]; }
141  __m128i value; // Contains 4 32-bit integral data values
142 };
143 #else
144 struct sse_int32_t {
145  inline sse_int32_t() : value( 0 ) {}
146  inline sse_int32_t( int32_t v ) : value( v ) {}
147  inline int32_t& operator[]( size_t /*i*/ ) { return value; }
148  inline const int32_t& operator[]( size_t /*i*/ ) const { return value; }
149  int32_t value;
150 };
151 #endif
152 
153 //*************************************************************************************************
154 
155 
156 //*************************************************************************************************
162 #if BLAZE_MIC_MODE
163 struct sse_int64_t {
164  inline sse_int64_t() : value( _mm512_setzero_epi32() ) {}
165  inline sse_int64_t( __m512i v ) : value( v ) {}
166  inline int64_t& operator[]( size_t i ) { return reinterpret_cast<int64_t* >( &value )[i]; }
167  inline const int64_t& operator[]( size_t i ) const { return reinterpret_cast<const int64_t*>( &value )[i]; }
168  __m512i value; // Contains 8 64-bit integral data values
169 };
170 #elif BLAZE_AVX2_MODE
171 struct sse_int64_t {
172  inline sse_int64_t() : value( _mm256_setzero_si256() ) {}
173  inline sse_int64_t( __m256i v ) : value( v ) {}
174  inline int64_t& operator[]( size_t i ) { return reinterpret_cast<int64_t* >( &value )[i]; }
175  inline const int64_t& operator[]( size_t i ) const { return reinterpret_cast<const int64_t*>( &value )[i]; }
176  __m256i value; // Contains 4 64-bit integral data values
177 };
178 #elif BLAZE_SSE2_MODE
179 struct sse_int64_t {
180  inline sse_int64_t() : value( _mm_setzero_si128() ) {}
181  inline sse_int64_t( __m128i v ) : value( v ) {}
182  inline int64_t& operator[]( size_t i ) { return reinterpret_cast<int64_t* >( &value )[i]; }
183  inline const 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*/ ) { return value; }
191  inline const int64_t& operator[]( size_t /*i*/ ) const { return value; }
192  int64_t value;
193 };
194 #endif
195 
196 //*************************************************************************************************
197 
198 
199 //*************************************************************************************************
205 #if BLAZE_MIC_MODE
206 struct sse_float_t {
207  inline sse_float_t() : value( _mm512_setzero_ps() ) {}
208  inline sse_float_t( __m512 v ) : value( v ) {}
209  inline float& operator[]( size_t i ) { return reinterpret_cast<float* >( &value )[i]; }
210  inline const float& operator[]( size_t i ) const { return reinterpret_cast<const float*>( &value )[i]; }
211  __m512 value; // Contains 16 32-bit single precision floating point values
212 };
213 #elif BLAZE_AVX_MODE
214 struct sse_float_t {
215  inline sse_float_t() : value( _mm256_setzero_ps() ) {}
216  inline sse_float_t( __m256 v ) : value( v ) {}
217  inline float& operator[]( size_t i ) { return reinterpret_cast<float* >( &value )[i]; }
218  inline const float& operator[]( size_t i ) const { return reinterpret_cast<const float*>( &value )[i]; }
219  __m256 value; // Contains 8 32-bit single precision floating point values
220 };
221 #elif BLAZE_SSE_MODE
222 struct sse_float_t {
223  inline sse_float_t() : value( _mm_setzero_ps() ) {}
224  inline sse_float_t( __m128 v ) : value( v ) {}
225  inline float& operator[]( size_t i ) { return reinterpret_cast<float* >( &value )[i]; }
226  inline const float& operator[]( size_t i ) const { return reinterpret_cast<const float*>( &value )[i]; }
227  __m128 value; // Contains 4 32-bit single precision floating point values
228 };
229 #else
230 struct sse_float_t {
231  inline sse_float_t() : value( 0.0F ) {}
232  inline sse_float_t( float v ) : value( v ) {}
233  inline float& operator[]( size_t /*i*/ ) { return value; }
234  inline const float& operator[]( size_t /*i*/ ) const { return value; }
235  float value;
236 };
237 #endif
238 
239 //*************************************************************************************************
240 
241 
242 //*************************************************************************************************
248 #if BLAZE_MIC_MODE
249 struct sse_double_t {
250  inline sse_double_t() : value( _mm512_setzero_pd() ) {}
251  inline sse_double_t( __m512d v ) : value( v ) {}
252  inline double& operator[]( size_t i ) { return reinterpret_cast<double* >( &value )[i]; }
253  inline const double& operator[]( size_t i ) const { return reinterpret_cast<const double*>( &value )[i]; }
254  __m512d value; // Contains 8 64-bit double precision floating point values
255 };
256 #elif BLAZE_AVX_MODE
257 struct sse_double_t {
258  inline sse_double_t() : value( _mm256_setzero_pd() ) {}
259  inline sse_double_t( __m256d v ) : value( v ) {}
260  inline double& operator[]( size_t i ) { return reinterpret_cast<double* >( &value )[i]; }
261  inline const double& operator[]( size_t i ) const { return reinterpret_cast<const double*>( &value )[i]; }
262  __m256d value; // Contains 4 64-bit double precision floating point values
263 };
264 #elif BLAZE_SSE2_MODE
265 struct sse_double_t {
266  inline sse_double_t() : value( _mm_setzero_pd() ) {}
267  inline sse_double_t( __m128d v ) : value( v ) {}
268  inline double& operator[]( size_t i ) { return reinterpret_cast<double* >( &value )[i]; }
269  inline const double& operator[]( size_t i ) const { return reinterpret_cast<const double*>( &value )[i]; }
270  __m128d value; // Contains 2 64-bit double precision floating point values
271 };
272 #else
273 struct sse_double_t {
274  inline sse_double_t() : value( 0.0 ) {}
275  inline sse_double_t( double v ) : value( v ) {}
276  inline double& operator[]( size_t /*i*/ ) { return value; }
277  inline const double& operator[]( size_t /*i*/ ) const { return value; }
278  double value;
279 };
280 #endif
281 
282 //*************************************************************************************************
283 
284 
285 //*************************************************************************************************
291 #if BLAZE_AVX_MODE
292 struct sse_cfloat_t {
293  inline sse_cfloat_t() : value( _mm256_setzero_ps() ) {}
294  inline sse_cfloat_t( __m256 v ) : value( v ) {}
295  inline complex<float>& operator[]( size_t i ) { return reinterpret_cast<complex<float>* >( &value )[i]; }
296  inline const complex<float>& operator[]( size_t i ) const { return reinterpret_cast<const complex<float>*>( &value )[i]; }
297  __m256 value; // Contains 4 32-bit single precision complex values
298 };
299 #elif BLAZE_SSE_MODE
300 struct sse_cfloat_t {
301  inline sse_cfloat_t() : value( _mm_setzero_ps() ) {}
302  inline sse_cfloat_t( __m128 v ) : value( v ) {}
303  inline complex<float>& operator[]( size_t i ) { return reinterpret_cast<complex<float>* >( &value )[i]; }
304  inline const complex<float>& operator[]( size_t i ) const { return reinterpret_cast<const complex<float>*>( &value )[i]; }
305  __m128 value; // Contains 2 32-bit single precision complex values
306 };
307 #else
308 struct sse_cfloat_t {
309  inline sse_cfloat_t() : value( 0.0F, 0.0F ) {}
310  inline sse_cfloat_t( complex<float> v ) : value( v ) {}
311  inline complex<float>& operator[]( size_t /*i*/ ) { return value; }
312  inline const complex<float>& operator[]( size_t /*i*/ ) const { return value; }
313  complex<float> value;
314 };
315 #endif
316 
317 //*************************************************************************************************
318 
319 
320 //*************************************************************************************************
326 #if BLAZE_AVX_MODE
327 struct sse_cdouble_t {
328  inline sse_cdouble_t() : value( _mm256_setzero_pd() ) {}
329  inline sse_cdouble_t( __m256d v ) : value( v ) {}
330  inline complex<double>& operator[]( size_t i ) { return reinterpret_cast<complex<double>* >( &value )[i]; }
331  inline const complex<double>& operator[]( size_t i ) const { return reinterpret_cast<const complex<double>*>( &value )[i]; }
332  __m256d value; // Contains 2 64-bit double precision complex value
333 };
334 #elif BLAZE_SSE2_MODE
335 struct sse_cdouble_t {
336  inline sse_cdouble_t() : value( _mm_setzero_pd() ) {}
337  inline sse_cdouble_t( __m128d v ) : value( v ) {}
338  inline complex<double>& operator[]( size_t i ) { return reinterpret_cast<complex<double>* >( &value )[i]; }
339  inline const 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*/ ) { return value; }
347  inline const complex<double>& operator[]( size_t /*i*/ ) const { return value; }
348  complex<double> value;
349 };
350 #endif
351 
352 //*************************************************************************************************
353 
354 } // namespace blaze
355 
356 #endif