All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
IntrinsicTrait.h
Go to the documentation of this file.
1 //=================================================================================================
20 //=================================================================================================
21 
22 #ifndef _BLAZE_MATH_INTRINSICS_INTRINSICTRAIT_H_
23 #define _BLAZE_MATH_INTRINSICS_INTRINSICTRAIT_H_
24 
25 
26 //*************************************************************************************************
27 // Includes
28 //*************************************************************************************************
29 
33 #include <blaze/util/Complex.h>
35 #include <blaze/util/TypeTraits.h>
36 
37 
38 namespace blaze {
39 
40 //=================================================================================================
41 //
42 // CLASS INTRINSICTRAITHELPER
43 //
44 //=================================================================================================
45 
46 //*************************************************************************************************
54 template< size_t N >
55 struct IntrinsicTraitHelper;
57 //*************************************************************************************************
58 
59 
60 //*************************************************************************************************
65 #if BLAZE_AVX2_MODE
66 template<>
67 struct IntrinsicTraitHelper<1UL>
68 {
69  typedef sse_int8_t Type;
70  enum { size = 32,
71  addition = 1,
72  subtraction = 1,
73  multiplication = 0 };
74 };
75 #else
76 template<>
77 struct IntrinsicTraitHelper<1UL>
78 {
79  typedef sse_int8_t Type;
80  enum { size = ( BLAZE_SSE2_MODE )?( 16 ):( 1 ),
81  addition = BLAZE_SSE2_MODE,
82  subtraction = BLAZE_SSE2_MODE,
83  multiplication = 0 };
84 };
85 #endif
86 
87 //*************************************************************************************************
88 
89 
90 //*************************************************************************************************
95 #if BLAZE_AVX2_MODE
96 template<>
97 struct IntrinsicTraitHelper<2UL>
98 {
99  typedef sse_int16_t Type;
100  enum { size = 16,
101  addition = 1,
102  subtraction = 1,
103  multiplication = 1 };
104 };
105 #else
106 template<>
107 struct IntrinsicTraitHelper<2UL>
108 {
109  typedef sse_int16_t Type;
110  enum { size = ( BLAZE_SSE2_MODE )?( 8 ):( 1 ),
111  addition = BLAZE_SSE2_MODE,
112  subtraction = BLAZE_SSE2_MODE,
113  multiplication = BLAZE_SSE2_MODE };
114 };
115 #endif
116 
117 //*************************************************************************************************
118 
119 
120 //*************************************************************************************************
125 #if BLAZE_MIC_MODE
126 template<>
127 struct IntrinsicTraitHelper<4UL>
128 {
129  typedef sse_int32_t Type;
130  enum { size = 16,
131  addition = 1,
132  subtraction = 1,
133  multiplication = 1 };
134 };
135 #elif BLAZE_AVX2_MODE
136 template<>
137 struct IntrinsicTraitHelper<4UL>
138 {
139  typedef sse_int32_t Type;
140  enum { size = 8,
141  addition = 1,
142  subtraction = 1,
143  multiplication = 1 };
144 };
145 #else
146 template<>
147 struct IntrinsicTraitHelper<4UL>
148 {
149  typedef sse_int32_t Type;
150  enum { size = ( BLAZE_SSE2_MODE )?( 4 ):( 1 ),
151  addition = BLAZE_SSE2_MODE,
152  subtraction = BLAZE_SSE2_MODE,
153  multiplication = BLAZE_SSE4_MODE };
154 };
155 #endif
156 
157 //*************************************************************************************************
158 
159 
160 //*************************************************************************************************
165 #if BLAZE_MIC_MODE
166 template<>
167 struct IntrinsicTraitHelper<8UL>
168 {
169  typedef sse_int64_t Type;
170  enum { size = 8,
171  addition = 1,
172  subtraction = 0,
173  multiplication = 0 };
174 };
175 #elif BLAZE_AVX2_MODE
176 template<>
177 struct IntrinsicTraitHelper<8UL>
178 {
179  typedef sse_int64_t Type;
180  enum { size = 4,
181  addition = 1,
182  subtraction = 1,
183  multiplication = 0 };
184 };
185 #else
186 template<>
187 struct IntrinsicTraitHelper<8UL>
188 {
189  typedef sse_int64_t Type;
190  enum { size = ( BLAZE_SSE2_MODE )?( 2 ):( 1 ),
191  addition = BLAZE_SSE2_MODE,
192  subtraction = BLAZE_SSE2_MODE,
193  multiplication = 0 };
194 };
195 #endif
196 
197 //*************************************************************************************************
198 
199 
200 
201 
202 //=================================================================================================
203 //
204 // CLASS INTRINSICTRAITBASE
205 //
206 //=================================================================================================
207 
208 //*************************************************************************************************
213 template< typename T >
214 struct IntrinsicTraitBase
215 {
216  typedef T Type;
217  enum { size = 1,
218  alignment = AlignmentTrait<T>::value,
219  addition = 0,
220  subtraction = 0,
221  multiplication = 0 };
222 };
224 //*************************************************************************************************
225 
226 
227 //*************************************************************************************************
232 template<>
233 struct IntrinsicTraitBase<short>
234 {
235  private:
236  typedef IntrinsicTraitHelper<sizeof(short)> Helper;
237 
238  public:
239  typedef Helper::Type Type;
240  enum { size = Helper::size,
241  alignment = AlignmentTrait<short>::value,
242  addition = Helper::addition,
243  subtraction = Helper::subtraction,
244  multiplication = Helper::multiplication };
245 };
247 //*************************************************************************************************
248 
249 
250 //*************************************************************************************************
255 template<>
256 struct IntrinsicTraitBase<unsigned short>
257 {
258  private:
259  typedef IntrinsicTraitHelper<sizeof(unsigned short)> Helper;
260 
261  public:
262  typedef Helper::Type Type;
263  enum { size = Helper::size,
264  alignment = AlignmentTrait<unsigned short>::value,
265  addition = Helper::addition,
266  subtraction = Helper::subtraction,
267  multiplication = Helper::multiplication };
268 };
270 //*************************************************************************************************
271 
272 
273 //*************************************************************************************************
278 template<>
279 struct IntrinsicTraitBase<int>
280 {
281  private:
282  typedef IntrinsicTraitHelper<sizeof(int)> Helper;
283 
284  public:
285  typedef Helper::Type Type;
286  enum { size = Helper::size,
287  alignment = AlignmentTrait<int>::value,
288  addition = Helper::addition,
289  subtraction = Helper::subtraction,
290  multiplication = Helper::multiplication };
291 };
293 //*************************************************************************************************
294 
295 
296 //*************************************************************************************************
301 template<>
302 struct IntrinsicTraitBase<unsigned int>
303 {
304  private:
305  typedef IntrinsicTraitHelper<sizeof(unsigned int)> Helper;
306 
307  public:
308  typedef Helper::Type Type;
309  enum { size = Helper::size,
310  alignment = AlignmentTrait<unsigned int>::value,
311  addition = Helper::addition,
312  subtraction = Helper::subtraction,
313  multiplication = Helper::multiplication };
314 };
316 //*************************************************************************************************
317 
318 
319 //*************************************************************************************************
324 template<>
325 struct IntrinsicTraitBase<long>
326 {
327  private:
328  typedef IntrinsicTraitHelper<sizeof(long)> Helper;
329 
330  public:
331  typedef Helper::Type Type;
332  enum { size = Helper::size,
333  alignment = AlignmentTrait<long>::value,
334  addition = Helper::addition,
335  subtraction = Helper::subtraction,
336  multiplication = Helper::multiplication };
337 };
339 //*************************************************************************************************
340 
341 
342 //*************************************************************************************************
347 template<>
348 struct IntrinsicTraitBase<unsigned long>
349 {
350  private:
351  typedef IntrinsicTraitHelper<sizeof(unsigned long)> Helper;
352 
353  public:
354  typedef Helper::Type Type;
355  enum { size = Helper::size,
356  alignment = AlignmentTrait<unsigned long>::value,
357  addition = Helper::addition,
358  subtraction = Helper::subtraction,
359  multiplication = Helper::multiplication };
360 };
362 //*************************************************************************************************
363 
364 
365 //*************************************************************************************************
370 #if BLAZE_MIC_MODE
371 struct IntrinsicTraitBase<float>
372 {
373  typedef sse_float_t Type;
374  enum { size = ( 64UL / sizeof(float) ),
375  alignment = AlignmentTrait<float>::value,
376  addition = 1,
377  subtraction = 1,
378  multiplication = 1 };
379 };
380 #elif BLAZE_AVX_MODE
381 template<>
382 struct IntrinsicTraitBase<float>
383 {
384  typedef sse_float_t Type;
385  enum { size = ( 32UL / sizeof(float) ),
386  alignment = AlignmentTrait<float>::value,
387  addition = 1,
388  subtraction = 1,
389  multiplication = 1 };
390 };
391 #else
392 template<>
393 struct IntrinsicTraitBase<float>
394 {
395  typedef sse_float_t Type;
396  enum { size = ( BLAZE_SSE_MODE )?( 16UL / sizeof(float) ):( 1 ),
397  alignment = AlignmentTrait<float>::value,
398  addition = BLAZE_SSE_MODE,
399  subtraction = BLAZE_SSE_MODE,
400  multiplication = BLAZE_SSE_MODE };
401 };
402 #endif
403 
404 //*************************************************************************************************
405 
406 
407 //*************************************************************************************************
412 #if BLAZE_MIC_MODE
413 template<>
414 struct IntrinsicTraitBase<double>
415 {
416  typedef sse_double_t Type;
417  enum { size = ( 64UL / sizeof(double) ),
418  alignment = AlignmentTrait<double>::value,
419  addition = 1,
420  subtraction = 1,
421  multiplication = 1 };
422 };
423 #elif BLAZE_AVX_MODE
424 template<>
425 struct IntrinsicTraitBase<double>
426 {
427  typedef sse_double_t Type;
428  enum { size = ( 32UL / sizeof(double) ),
429  alignment = AlignmentTrait<double>::value,
430  addition = 1,
431  subtraction = 1,
432  multiplication = 1 };
433 };
434 #else
435 template<>
436 struct IntrinsicTraitBase<double>
437 {
438  typedef sse_double_t Type;
439  enum { size = ( BLAZE_SSE_MODE )?( 16UL / sizeof(double) ):( 1 ),
440  alignment = AlignmentTrait<double>::value,
441  addition = BLAZE_SSE2_MODE,
442  subtraction = BLAZE_SSE2_MODE,
443  multiplication = BLAZE_SSE2_MODE };
444 };
445 #endif
446 
447 //*************************************************************************************************
448 
449 
450 //*************************************************************************************************
455 #if BLAZE_AVX_MODE
456 template<>
457 struct IntrinsicTraitBase< complex<float> >
458 {
459  typedef sse_cfloat_t Type;
460  enum { size = ( 32UL / sizeof(complex<float>) ),
461  alignment = AlignmentTrait< complex<float> >::value,
462  addition = 1,
463  subtraction = 1,
464  multiplication = 1 };
465 
466  BLAZE_STATIC_ASSERT( sizeof( complex<float> ) == 2UL*sizeof( float ) );
467 };
468 #else
469 template<>
470 struct IntrinsicTraitBase< complex<float> >
471 {
472  typedef sse_cfloat_t Type;
473  enum { size = ( BLAZE_SSE_MODE )?( 16UL / sizeof(complex<float>) ):( 1 ),
474  alignment = AlignmentTrait< complex<float> >::value,
475  addition = BLAZE_SSE_MODE,
476  subtraction = BLAZE_SSE_MODE,
477  multiplication = BLAZE_SSE3_MODE };
478 
479  BLAZE_STATIC_ASSERT( sizeof( complex<float> ) == 2UL*sizeof( float ) );
480 };
481 #endif
482 
483 //*************************************************************************************************
484 
485 
486 //*************************************************************************************************
491 #if BLAZE_AVX_MODE
492 template<>
493 struct IntrinsicTraitBase< complex<double> >
494 {
495  typedef sse_cdouble_t Type;
496  enum { size = ( 32UL / sizeof(complex<double>) ),
497  alignment = AlignmentTrait< complex<double> >::value,
498  addition = 1,
499  subtraction = 1,
500  multiplication = 1 };
501 
502  BLAZE_STATIC_ASSERT( sizeof( complex<double> ) == 2UL*sizeof( double ) );
503 };
504 #else
505 template<>
506 struct IntrinsicTraitBase< complex<double> >
507 {
508  typedef sse_cdouble_t Type;
509  enum { size = ( BLAZE_SSE_MODE )?( 16UL / sizeof(complex<double>) ):( 1 ),
510  alignment = AlignmentTrait< complex<double> >::value,
511  addition = BLAZE_SSE2_MODE,
512  subtraction = BLAZE_SSE2_MODE,
513  multiplication = BLAZE_SSE3_MODE };
514 
515  BLAZE_STATIC_ASSERT( sizeof( complex<double> ) == 2UL*sizeof( double ) );
516 };
517 #endif
518 
519 //*************************************************************************************************
520 
521 
522 
523 
524 //=================================================================================================
525 //
526 // CLASS INTRINSICTRAIT
527 //
528 //=================================================================================================
529 
530 //*************************************************************************************************
550 template< typename T >
551 class IntrinsicTrait : public IntrinsicTraitBase< typename RemoveCV<T>::Type >
552 {};
553 //*************************************************************************************************
554 
555 } // namespace blaze
556 
557 #endif