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