All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
IntrinsicTrait.h
Go to the documentation of this file.
1 //=================================================================================================
33 //=================================================================================================
34 
35 #ifndef _BLAZE_MATH_INTRINSICS_INTRINSICTRAIT_H_
36 #define _BLAZE_MATH_INTRINSICS_INTRINSICTRAIT_H_
37 
38 
39 //*************************************************************************************************
40 // Includes
41 //*************************************************************************************************
42 
46 #include <blaze/util/Complex.h>
48 #include <blaze/util/TypeTraits.h>
49 
50 
51 namespace blaze {
52 
53 //=================================================================================================
54 //
55 // CLASS INTRINSICTRAITHELPER
56 //
57 //=================================================================================================
58 
59 //*************************************************************************************************
67 template< size_t N >
68 struct IntrinsicTraitHelper;
70 //*************************************************************************************************
71 
72 
73 //*************************************************************************************************
78 #if BLAZE_AVX2_MODE
79 template<>
80 struct IntrinsicTraitHelper<1UL>
81 {
82  typedef sse_int8_t Type;
83  enum { size = 32,
84  addition = 1,
85  subtraction = 1,
86  multiplication = 0,
87  division = 0,
88  absoluteValue = 1 };
89 };
90 #else
91 template<>
92 struct IntrinsicTraitHelper<1UL>
93 {
94  typedef sse_int8_t Type;
95  enum { size = ( BLAZE_SSE2_MODE )?( 16 ):( 1 ),
96  addition = BLAZE_SSE2_MODE,
97  subtraction = BLAZE_SSE2_MODE,
98  multiplication = 0,
99  division = 0,
100  absoluteValue = BLAZE_SSSE3_MODE };
101 };
102 #endif
103 
104 //*************************************************************************************************
105 
106 
107 //*************************************************************************************************
112 #if BLAZE_AVX2_MODE
113 template<>
114 struct IntrinsicTraitHelper<2UL>
115 {
116  typedef sse_int16_t Type;
117  enum { size = 16,
118  addition = 1,
119  subtraction = 1,
120  multiplication = 1,
121  division = 0,
122  absoluteValue = 1 };
123 };
124 #else
125 template<>
126 struct IntrinsicTraitHelper<2UL>
127 {
128  typedef sse_int16_t Type;
129  enum { size = ( BLAZE_SSE2_MODE )?( 8 ):( 1 ),
130  addition = BLAZE_SSE2_MODE,
131  subtraction = BLAZE_SSE2_MODE,
132  multiplication = BLAZE_SSE2_MODE,
133  division = 0,
134  absoluteValue = BLAZE_SSSE3_MODE };
135 };
136 #endif
137 
138 //*************************************************************************************************
139 
140 
141 //*************************************************************************************************
146 #if BLAZE_MIC_MODE
147 template<>
148 struct IntrinsicTraitHelper<4UL>
149 {
150  typedef sse_int32_t Type;
151  enum { size = 16,
152  addition = 1,
153  subtraction = 1,
154  multiplication = 1,
155  division = 1,
156  absoluteValue = 0 };
157 };
158 #elif BLAZE_AVX2_MODE
159 template<>
160 struct IntrinsicTraitHelper<4UL>
161 {
162  typedef sse_int32_t Type;
163  enum { size = 8,
164  addition = 1,
165  subtraction = 1,
166  multiplication = 1,
167  division = 0,
168  absoluteValue = 1 };
169 };
170 #else
171 template<>
172 struct IntrinsicTraitHelper<4UL>
173 {
174  typedef sse_int32_t Type;
175  enum { size = ( BLAZE_SSE2_MODE )?( 4 ):( 1 ),
176  addition = BLAZE_SSE2_MODE,
177  subtraction = BLAZE_SSE2_MODE,
178  multiplication = BLAZE_SSE4_MODE,
179  division = 0,
180  absoluteValue = BLAZE_SSSE3_MODE };
181 };
182 #endif
183 
184 //*************************************************************************************************
185 
186 
187 //*************************************************************************************************
192 #if BLAZE_MIC_MODE
193 template<>
194 struct IntrinsicTraitHelper<8UL>
195 {
196  typedef sse_int64_t Type;
197  enum { size = 8,
198  addition = 1,
199  subtraction = 0,
200  multiplication = 0,
201  division = 1,
202  absoluteValue = 0 };
203 };
204 #elif BLAZE_AVX2_MODE
205 template<>
206 struct IntrinsicTraitHelper<8UL>
207 {
208  typedef sse_int64_t Type;
209  enum { size = 4,
210  addition = 1,
211  subtraction = 1,
212  multiplication = 0,
213  division = 0,
214  absoluteValue = 0 };
215 };
216 #else
217 template<>
218 struct IntrinsicTraitHelper<8UL>
219 {
220  typedef sse_int64_t Type;
221  enum { size = ( BLAZE_SSE2_MODE )?( 2 ):( 1 ),
222  addition = BLAZE_SSE2_MODE,
223  subtraction = BLAZE_SSE2_MODE,
224  multiplication = 0,
225  division = 0,
226  absoluteValue = 0 };
227 };
228 #endif
229 
230 //*************************************************************************************************
231 
232 
233 
234 
235 //=================================================================================================
236 //
237 // CLASS INTRINSICTRAITBASE
238 //
239 //=================================================================================================
240 
241 //*************************************************************************************************
246 template< typename T >
247 struct IntrinsicTraitBase
248 {
249  typedef T Type;
250  enum { size = 1,
251  alignment = AlignmentTrait<T>::value,
252  addition = 0,
253  subtraction = 0,
254  multiplication = 0,
255  division = 0,
256  absoluteValue = 0 };
257 };
259 //*************************************************************************************************
260 
261 
262 //*************************************************************************************************
267 template<>
268 struct IntrinsicTraitBase<char>
269 {
270  private:
271  typedef IntrinsicTraitHelper<sizeof(char)> Helper;
272 
273  public:
274  typedef Helper::Type Type;
275  enum { size = Helper::size,
276  alignment = AlignmentTrait<char>::value,
277  addition = Helper::addition,
278  subtraction = Helper::subtraction,
279  multiplication = Helper::multiplication,
280  division = Helper::division,
281  absoluteValue = Helper::absoluteValue };
282 };
284 //*************************************************************************************************
285 
286 
287 //*************************************************************************************************
292 template<>
293 struct IntrinsicTraitBase<signed char>
294 {
295  private:
296  typedef IntrinsicTraitHelper<sizeof(signed char)> Helper;
297 
298  public:
299  typedef Helper::Type Type;
300  enum { size = Helper::size,
301  alignment = AlignmentTrait<signed char>::value,
302  addition = Helper::addition,
303  subtraction = Helper::subtraction,
304  multiplication = Helper::multiplication,
305  division = Helper::division,
306  absoluteValue = Helper::absoluteValue };
307 };
309 //*************************************************************************************************
310 
311 
312 //*************************************************************************************************
317 template<>
318 struct IntrinsicTraitBase<unsigned char>
319 {
320  private:
321  typedef IntrinsicTraitHelper<sizeof(unsigned char)> Helper;
322 
323  public:
324  typedef Helper::Type Type;
325  enum { size = Helper::size,
326  alignment = AlignmentTrait<unsigned char>::value,
327  addition = Helper::addition,
328  subtraction = Helper::subtraction,
329  multiplication = Helper::multiplication,
330  division = Helper::division,
331  absoluteValue = Helper::absoluteValue };
332 };
334 //*************************************************************************************************
335 
336 
337 //*************************************************************************************************
342 template<>
343 struct IntrinsicTraitBase<wchar_t>
344 {
345  private:
346  typedef IntrinsicTraitHelper<sizeof(wchar_t)> Helper;
347 
348  public:
349  typedef Helper::Type Type;
350  enum { size = Helper::size,
351  alignment = AlignmentTrait<wchar_t>::value,
352  addition = Helper::addition,
353  subtraction = Helper::subtraction,
354  multiplication = Helper::multiplication,
355  division = Helper::division,
356  absoluteValue = Helper::absoluteValue };
357 };
359 //*************************************************************************************************
360 
361 
362 //*************************************************************************************************
367 template<>
368 struct IntrinsicTraitBase<short>
369 {
370  private:
371  typedef IntrinsicTraitHelper<sizeof(short)> Helper;
372 
373  public:
374  typedef Helper::Type Type;
375  enum { size = Helper::size,
376  alignment = AlignmentTrait<short>::value,
377  addition = Helper::addition,
378  subtraction = Helper::subtraction,
379  multiplication = Helper::multiplication,
380  division = Helper::division,
381  absoluteValue = Helper::absoluteValue };
382 };
384 //*************************************************************************************************
385 
386 
387 //*************************************************************************************************
392 template<>
393 struct IntrinsicTraitBase<unsigned short>
394 {
395  private:
396  typedef IntrinsicTraitHelper<sizeof(unsigned short)> Helper;
397 
398  public:
399  typedef Helper::Type Type;
400  enum { size = Helper::size,
401  alignment = AlignmentTrait<unsigned short>::value,
402  addition = Helper::addition,
403  subtraction = Helper::subtraction,
404  multiplication = Helper::multiplication,
405  division = Helper::division,
406  absoluteValue = Helper::absoluteValue };
407 };
409 //*************************************************************************************************
410 
411 
412 //*************************************************************************************************
417 template<>
418 struct IntrinsicTraitBase<int>
419 {
420  private:
421  typedef IntrinsicTraitHelper<sizeof(int)> Helper;
422 
423  public:
424  typedef Helper::Type Type;
425  enum { size = Helper::size,
426  alignment = AlignmentTrait<int>::value,
427  addition = Helper::addition,
428  subtraction = Helper::subtraction,
429  multiplication = Helper::multiplication,
430  division = Helper::division,
431  absoluteValue = Helper::absoluteValue };
432 };
434 //*************************************************************************************************
435 
436 
437 //*************************************************************************************************
442 template<>
443 struct IntrinsicTraitBase<unsigned int>
444 {
445  private:
446  typedef IntrinsicTraitHelper<sizeof(unsigned int)> Helper;
447 
448  public:
449  typedef Helper::Type Type;
450  enum { size = Helper::size,
451  alignment = AlignmentTrait<unsigned int>::value,
452  addition = Helper::addition,
453  subtraction = Helper::subtraction,
454  multiplication = Helper::multiplication,
455  division = Helper::division,
456  absoluteValue = Helper::absoluteValue };
457 };
459 //*************************************************************************************************
460 
461 
462 //*************************************************************************************************
467 template<>
468 struct IntrinsicTraitBase<long>
469 {
470  private:
471  typedef IntrinsicTraitHelper<sizeof(long)> Helper;
472 
473  public:
474  typedef Helper::Type Type;
475  enum { size = Helper::size,
476  alignment = AlignmentTrait<long>::value,
477  addition = Helper::addition,
478  subtraction = Helper::subtraction,
479  multiplication = Helper::multiplication,
480  division = Helper::division,
481  absoluteValue = Helper::absoluteValue };
482 };
484 //*************************************************************************************************
485 
486 
487 //*************************************************************************************************
492 template<>
493 struct IntrinsicTraitBase<unsigned long>
494 {
495  private:
496  typedef IntrinsicTraitHelper<sizeof(unsigned long)> Helper;
497 
498  public:
499  typedef Helper::Type Type;
500  enum { size = Helper::size,
501  alignment = AlignmentTrait<unsigned long>::value,
502  addition = Helper::addition,
503  subtraction = Helper::subtraction,
504  multiplication = Helper::multiplication,
505  division = Helper::division,
506  absoluteValue = Helper::absoluteValue };
507 };
509 //*************************************************************************************************
510 
511 
512 //*************************************************************************************************
517 #if BLAZE_MIC_MODE
518 struct IntrinsicTraitBase<float>
519 {
520  typedef sse_float_t Type;
521  enum { size = ( 64UL / sizeof(float) ),
522  alignment = AlignmentTrait<float>::value,
523  addition = 1,
524  subtraction = 1,
525  multiplication = 1,
526  division = 1,
527  absoluteValue = 0 };
528 };
529 #elif BLAZE_AVX_MODE
530 template<>
531 struct IntrinsicTraitBase<float>
532 {
533  typedef sse_float_t Type;
534  enum { size = ( 32UL / sizeof(float) ),
535  alignment = AlignmentTrait<float>::value,
536  addition = 1,
537  subtraction = 1,
538  multiplication = 1,
539  division = 1,
540  absoluteValue = 0 };
541 };
542 #else
543 template<>
544 struct IntrinsicTraitBase<float>
545 {
546  typedef sse_float_t Type;
547  enum { size = ( BLAZE_SSE_MODE )?( 16UL / sizeof(float) ):( 1 ),
548  alignment = AlignmentTrait<float>::value,
549  addition = BLAZE_SSE_MODE,
550  subtraction = BLAZE_SSE_MODE,
551  multiplication = BLAZE_SSE_MODE,
552  division = BLAZE_SSE_MODE,
553  absoluteValue = 0 };
554 };
555 #endif
556 
557 //*************************************************************************************************
558 
559 
560 //*************************************************************************************************
565 #if BLAZE_MIC_MODE
566 template<>
567 struct IntrinsicTraitBase<double>
568 {
569  typedef sse_double_t Type;
570  enum { size = ( 64UL / sizeof(double) ),
571  alignment = AlignmentTrait<double>::value,
572  addition = 1,
573  subtraction = 1,
574  multiplication = 1,
575  division = 1,
576  absoluteValue = 0 };
577 };
578 #elif BLAZE_AVX_MODE
579 template<>
580 struct IntrinsicTraitBase<double>
581 {
582  typedef sse_double_t Type;
583  enum { size = ( 32UL / sizeof(double) ),
584  alignment = AlignmentTrait<double>::value,
585  addition = 1,
586  subtraction = 1,
587  multiplication = 1,
588  division = 1,
589  absoluteValue = 0 };
590 };
591 #else
592 template<>
593 struct IntrinsicTraitBase<double>
594 {
595  typedef sse_double_t Type;
596  enum { size = ( BLAZE_SSE_MODE )?( 16UL / sizeof(double) ):( 1 ),
597  alignment = AlignmentTrait<double>::value,
598  addition = BLAZE_SSE2_MODE,
599  subtraction = BLAZE_SSE2_MODE,
600  multiplication = BLAZE_SSE2_MODE,
601  division = BLAZE_SSE2_MODE,
602  absoluteValue = 0 };
603 };
604 #endif
605 
606 //*************************************************************************************************
607 
608 
609 //*************************************************************************************************
614 #if BLAZE_MIC_MODE
615 template<>
616 struct IntrinsicTraitBase< complex<float> >
617 {
618  typedef sse_cfloat_t Type;
619  enum { size = ( 64UL / sizeof(complex<float>) ),
620  alignment = AlignmentTrait< complex<float> >::value,
621  addition = 1,
622  subtraction = 1,
623  multiplication = 0,
624  division = 0,
625  absoluteValue = 0 };
626 
627  BLAZE_STATIC_ASSERT( sizeof( complex<float> ) == 2UL*sizeof( float ) );
628 };
629 #elif BLAZE_AVX_MODE
630 template<>
631 struct IntrinsicTraitBase< complex<float> >
632 {
633  typedef sse_cfloat_t Type;
634  enum { size = ( 32UL / sizeof(complex<float>) ),
635  alignment = AlignmentTrait< complex<float> >::value,
636  addition = 1,
637  subtraction = 1,
638  multiplication = 1,
639  division = 0,
640  absoluteValue = 0 };
641 
642  BLAZE_STATIC_ASSERT( sizeof( complex<float> ) == 2UL*sizeof( float ) );
643 };
644 #else
645 template<>
646 struct IntrinsicTraitBase< complex<float> >
647 {
648  typedef sse_cfloat_t Type;
649  enum { size = ( BLAZE_SSE_MODE )?( 16UL / sizeof(complex<float>) ):( 1 ),
650  alignment = AlignmentTrait< complex<float> >::value,
651  addition = BLAZE_SSE_MODE,
652  subtraction = BLAZE_SSE_MODE,
653  multiplication = BLAZE_SSE3_MODE,
654  division = 0,
655  absoluteValue = 0 };
656 
657  BLAZE_STATIC_ASSERT( sizeof( complex<float> ) == 2UL*sizeof( float ) );
658 };
659 #endif
660 
661 //*************************************************************************************************
662 
663 
664 //*************************************************************************************************
669 #if BLAZE_MIC_MODE
670 template<>
671 struct IntrinsicTraitBase< complex<double> >
672 {
673  typedef sse_cdouble_t Type;
674  enum { size = ( 64UL / sizeof(complex<double>) ),
675  alignment = AlignmentTrait< complex<double> >::value,
676  addition = 1,
677  subtraction = 1,
678  multiplication = 0,
679  division = 0,
680  absoluteValue = 0 };
681 
682  BLAZE_STATIC_ASSERT( sizeof( complex<double> ) == 2UL*sizeof( double ) );
683 };
684 #elif BLAZE_AVX_MODE
685 template<>
686 struct IntrinsicTraitBase< complex<double> >
687 {
688  typedef sse_cdouble_t Type;
689  enum { size = ( 32UL / sizeof(complex<double>) ),
690  alignment = AlignmentTrait< complex<double> >::value,
691  addition = 1,
692  subtraction = 1,
693  multiplication = 1,
694  division = 0,
695  absoluteValue = 0 };
696 
697  BLAZE_STATIC_ASSERT( sizeof( complex<double> ) == 2UL*sizeof( double ) );
698 };
699 #else
700 template<>
701 struct IntrinsicTraitBase< complex<double> >
702 {
703  typedef sse_cdouble_t Type;
704  enum { size = ( BLAZE_SSE_MODE )?( 16UL / sizeof(complex<double>) ):( 1 ),
705  alignment = AlignmentTrait< complex<double> >::value,
706  addition = BLAZE_SSE2_MODE,
707  subtraction = BLAZE_SSE2_MODE,
708  multiplication = BLAZE_SSE3_MODE,
709  division = 0,
710  absoluteValue = 0 };
711 
712  BLAZE_STATIC_ASSERT( sizeof( complex<double> ) == 2UL*sizeof( double ) );
713 };
714 #endif
715 
716 //*************************************************************************************************
717 
718 
719 
720 
721 //=================================================================================================
722 //
723 // CLASS INTRINSICTRAIT
724 //
725 //=================================================================================================
726 
727 //*************************************************************************************************
747 template< typename T >
748 class IntrinsicTrait : public IntrinsicTraitBase< typename RemoveCV<T>::Type >
749 {};
750 //*************************************************************************************************
751 
752 } // namespace blaze
753 
754 #endif
#define BLAZE_SSE3_MODE
Compilation switch for the SSE3 mode.This compilation switch enables/disables the SSE3 mode...
Definition: Vectorization.h:101
#define BLAZE_SSSE3_MODE
Compilation switch for the SSSE3 mode.This compilation switch enables/disables the SSSE3 mode...
Definition: Vectorization.h:118
Compile time assertion.
#define BLAZE_SSE_MODE
Compilation switch for the SSE mode.This compilation switch enables/disables the SSE mode...
Definition: Vectorization.h:67
Header file for the basic intrinsic types.
Header file for all type traits.
Intrinsic characteristics of data types.The IntrinsicTrait class template provides the intrinsic char...
Definition: IntrinsicTrait.h:748
#define BLAZE_SSE4_MODE
Compilation switch for the SSE4 mode.This compilation switch enables/disables the SSE4 mode...
Definition: Vectorization.h:135
Header file for the alignment trait.
System settings for the SSE mode.
Header file for the complex data type.
#define BLAZE_SSE2_MODE
Compilation switch for the SSE2 mode.This compilation switch enables/disables the SSE2 mode...
Definition: Vectorization.h:84
#define BLAZE_STATIC_ASSERT(expr)
Compile time assertion macro.In case of an invalid compile time expression, a compilation error is cr...
Definition: StaticAssert.h:143