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< bool C, size_t N >
69 struct IntrinsicTraitHelper;
71 //*************************************************************************************************
72 
73 
74 //*************************************************************************************************
79 #if BLAZE_AVX2_MODE
80 template<>
81 struct IntrinsicTraitHelper<false,1UL>
82 {
83  typedef simd_int8_t Type;
84  enum { size = 32,
85  addition = 1,
86  subtraction = 1,
87  multiplication = 0,
88  division = 0,
89  absoluteValue = 1,
90  conjugate = 1 };
91 };
92 #else
93 template<>
94 struct IntrinsicTraitHelper<false,1UL>
95 {
96  typedef simd_int8_t Type;
97  enum { size = ( BLAZE_SSE2_MODE )?( 16 ):( 1 ),
98  addition = BLAZE_SSE2_MODE,
99  subtraction = BLAZE_SSE2_MODE,
100  multiplication = 0,
101  division = 0,
102  absoluteValue = BLAZE_SSSE3_MODE,
103  conjugate = 1 };
104 };
105 #endif
106 
107 //*************************************************************************************************
108 
109 
110 //*************************************************************************************************
115 #if BLAZE_AVX2_MODE
116 template<>
117 struct IntrinsicTraitHelper<false,2UL>
118 {
119  typedef simd_int16_t Type;
120  enum { size = 16,
121  addition = 1,
122  subtraction = 1,
123  multiplication = 1,
124  division = 0,
125  absoluteValue = 1,
126  conjugate = 1 };
127 };
128 #else
129 template<>
130 struct IntrinsicTraitHelper<false,2UL>
131 {
132  typedef simd_int16_t Type;
133  enum { size = ( BLAZE_SSE2_MODE )?( 8 ):( 1 ),
134  addition = BLAZE_SSE2_MODE,
135  subtraction = BLAZE_SSE2_MODE,
136  multiplication = BLAZE_SSE2_MODE,
137  division = 0,
138  absoluteValue = BLAZE_SSSE3_MODE,
139  conjugate = 1 };
140 };
141 #endif
142 
143 //*************************************************************************************************
144 
145 
146 //*************************************************************************************************
151 #if BLAZE_MIC_MODE
152 template<>
153 struct IntrinsicTraitHelper<false,4UL>
154 {
155  typedef simd_int32_t Type;
156  enum { size = 16,
157  addition = 1,
158  subtraction = 1,
159  multiplication = 1,
160  division = 1,
161  absoluteValue = 0,
162  conjugate = 1 };
163 };
164 #elif BLAZE_AVX2_MODE
165 template<>
166 struct IntrinsicTraitHelper<false,4UL>
167 {
168  typedef simd_int32_t Type;
169  enum { size = 8,
170  addition = 1,
171  subtraction = 1,
172  multiplication = 1,
173  division = 0,
174  absoluteValue = 1,
175  conjugate = 1 };
176 };
177 #else
178 template<>
179 struct IntrinsicTraitHelper<false,4UL>
180 {
181  typedef simd_int32_t Type;
182  enum { size = ( BLAZE_SSE2_MODE )?( 4 ):( 1 ),
183  addition = BLAZE_SSE2_MODE,
184  subtraction = BLAZE_SSE2_MODE,
185  multiplication = BLAZE_SSE4_MODE,
186  division = 0,
187  absoluteValue = BLAZE_SSSE3_MODE,
188  conjugate = 1 };
189 };
190 #endif
191 
192 //*************************************************************************************************
193 
194 
195 //*************************************************************************************************
200 #if BLAZE_MIC_MODE
201 template<>
202 struct IntrinsicTraitHelper<false,8UL>
203 {
204  typedef simd_int64_t Type;
205  enum { size = 8,
206  addition = 1,
207  subtraction = 1,
208  multiplication = 1,
209  division = 1,
210  absoluteValue = 0,
211  conjugate = 1 };
212 };
213 #elif BLAZE_AVX2_MODE
214 template<>
215 struct IntrinsicTraitHelper<false,8UL>
216 {
217  typedef simd_int64_t Type;
218  enum { size = 4,
219  addition = 1,
220  subtraction = 1,
221  multiplication = 0,
222  division = 0,
223  absoluteValue = 0,
224  conjugate = 1 };
225 };
226 #else
227 template<>
228 struct IntrinsicTraitHelper<false,8UL>
229 {
230  typedef simd_int64_t Type;
231  enum { size = ( BLAZE_SSE2_MODE )?( 2 ):( 1 ),
232  addition = BLAZE_SSE2_MODE,
233  subtraction = BLAZE_SSE2_MODE,
234  multiplication = 0,
235  division = 0,
236  absoluteValue = 0,
237  conjugate = 1 };
238 };
239 #endif
240 
241 //*************************************************************************************************
242 
243 
244 //*************************************************************************************************
249 #if BLAZE_AVX2_MODE
250 template<>
251 struct IntrinsicTraitHelper<true,1UL>
252 {
253  typedef simd_cint8_t Type;
254  enum { size = 16,
255  addition = 1,
256  subtraction = 1,
257  multiplication = 0,
258  division = 0,
259  absoluteValue = 0,
260  conjugate = 0 };
261 };
262 #else
263 template<>
264 struct IntrinsicTraitHelper<true,1UL>
265 {
266  typedef simd_cint8_t Type;
267  enum { size = ( BLAZE_SSE2_MODE )?( 8 ):( 1 ),
268  addition = BLAZE_SSE2_MODE,
269  subtraction = BLAZE_SSE2_MODE,
270  multiplication = 0,
271  division = 0,
272  absoluteValue = 0,
273  conjugate = 0 };
274 };
275 #endif
276 
277 //*************************************************************************************************
278 
279 
280 //*************************************************************************************************
285 #if BLAZE_AVX2_MODE
286 template<>
287 struct IntrinsicTraitHelper<true,2UL>
288 {
289  typedef simd_cint16_t Type;
290  enum { size = 8,
291  addition = 1,
292  subtraction = 1,
293  multiplication = 1,
294  division = 0,
295  absoluteValue = 0,
296  conjugate = 1 };
297 };
298 #else
299 template<>
300 struct IntrinsicTraitHelper<true,2UL>
301 {
302  typedef simd_cint16_t Type;
303  enum { size = ( BLAZE_SSE2_MODE )?( 4 ):( 1 ),
304  addition = BLAZE_SSE2_MODE,
305  subtraction = BLAZE_SSE2_MODE,
306  multiplication = BLAZE_SSE2_MODE,
307  division = 0,
308  absoluteValue = 0,
310 };
311 #endif
312 
313 //*************************************************************************************************
314 
315 
316 //*************************************************************************************************
321 #if BLAZE_MIC_MODE
322 template<>
323 struct IntrinsicTraitHelper<true,4UL>
324 {
325  typedef simd_cint32_t Type;
326  enum { size = 8,
327  addition = 1,
328  subtraction = 1,
329  multiplication = 1,
330  division = 0,
331  absoluteValue = 0,
332  conjugate = 1 };
333 };
334 #elif BLAZE_AVX2_MODE
335 template<>
336 struct IntrinsicTraitHelper<true,4UL>
337 {
338  typedef simd_cint32_t Type;
339  enum { size = 4,
340  addition = 1,
341  subtraction = 1,
342  multiplication = 1,
343  division = 0,
344  absoluteValue = 0,
345  conjugate = 1 };
346 };
347 #else
348 template<>
349 struct IntrinsicTraitHelper<true,4UL>
350 {
351  typedef simd_cint32_t Type;
352  enum { size = ( BLAZE_SSE2_MODE )?( 2 ):( 1 ),
353  addition = BLAZE_SSE2_MODE,
354  subtraction = BLAZE_SSE2_MODE,
355  multiplication = BLAZE_SSE4_MODE,
356  division = 0,
357  absoluteValue = 0,
359 };
360 #endif
361 
362 //*************************************************************************************************
363 
364 
365 //*************************************************************************************************
370 #if BLAZE_MIC_MODE
371 template<>
372 struct IntrinsicTraitHelper<true,8UL>
373 {
374  typedef simd_cint64_t Type;
375  enum { size = 4,
376  addition = 1,
377  subtraction = 1,
378  multiplication = 0,
379  division = 0,
380  absoluteValue = 0,
381  conjugate = 0 };
382 };
383 #elif BLAZE_AVX2_MODE
384 template<>
385 struct IntrinsicTraitHelper<true,8UL>
386 {
387  typedef simd_cint64_t Type;
388  enum { size = 2,
389  addition = 1,
390  subtraction = 1,
391  multiplication = 0,
392  division = 0,
393  absoluteValue = 0,
394  conjugate = 0 };
395 };
396 #else
397 template<>
398 struct IntrinsicTraitHelper<true,8UL>
399 {
400  typedef simd_cint64_t Type;
401  enum { size = 1,
402  addition = BLAZE_SSE2_MODE,
403  subtraction = BLAZE_SSE2_MODE,
404  multiplication = 0,
405  division = 0,
406  absoluteValue = 0,
407  conjugate = 0 };
408 };
409 #endif
410 
411 //*************************************************************************************************
412 
413 
414 
415 
416 //=================================================================================================
417 //
418 // CLASS INTRINSICTRAITBASE
419 //
420 //=================================================================================================
421 
422 //*************************************************************************************************
427 template< typename T >
428 struct IntrinsicTraitBase
429 {
430  typedef T Type;
431  enum { size = 1,
432  alignment = AlignmentOf<T>::value,
433  addition = 0,
434  subtraction = 0,
435  multiplication = 0,
436  division = 0,
437  absoluteValue = 0,
438  conjugate = 0 };
439 };
441 //*************************************************************************************************
442 
443 
444 //*************************************************************************************************
449 template<>
450 struct IntrinsicTraitBase<char>
451 {
452  private:
453  typedef IntrinsicTraitHelper<false,sizeof(char)> Helper;
454 
455  public:
456  typedef Helper::Type Type;
457  enum { size = Helper::size,
458  alignment = AlignmentOf<char>::value,
459  addition = Helper::addition,
460  subtraction = Helper::subtraction,
461  multiplication = Helper::multiplication,
462  division = Helper::division,
463  absoluteValue = Helper::absoluteValue,
465 };
467 //*************************************************************************************************
468 
469 
470 //*************************************************************************************************
475 template<>
476 struct IntrinsicTraitBase<signed char>
477 {
478  private:
479  typedef IntrinsicTraitHelper<false,sizeof(signed char)> Helper;
480 
481  public:
482  typedef Helper::Type Type;
483  enum { size = Helper::size,
484  alignment = AlignmentOf<signed char>::value,
485  addition = Helper::addition,
486  subtraction = Helper::subtraction,
487  multiplication = Helper::multiplication,
488  division = Helper::division,
489  absoluteValue = Helper::absoluteValue,
491 };
493 //*************************************************************************************************
494 
495 
496 //*************************************************************************************************
501 template<>
502 struct IntrinsicTraitBase<unsigned char>
503 {
504  private:
505  typedef IntrinsicTraitHelper<false,sizeof(unsigned char)> Helper;
506 
507  public:
508  typedef Helper::Type Type;
509  enum { size = Helper::size,
510  alignment = AlignmentOf<unsigned char>::value,
511  addition = Helper::addition,
512  subtraction = Helper::subtraction,
513  multiplication = Helper::multiplication,
514  division = Helper::division,
515  absoluteValue = 0,
517 };
519 //*************************************************************************************************
520 
521 
522 //*************************************************************************************************
527 template<>
528 struct IntrinsicTraitBase<wchar_t>
529 {
530  private:
531  typedef IntrinsicTraitHelper<false,sizeof(wchar_t)> Helper;
532 
533  public:
534  typedef Helper::Type Type;
535  enum { size = Helper::size,
536  alignment = AlignmentOf<wchar_t>::value,
537  addition = Helper::addition,
538  subtraction = Helper::subtraction,
539  multiplication = Helper::multiplication,
540  division = Helper::division,
541  absoluteValue = Helper::absoluteValue,
543 };
545 //*************************************************************************************************
546 
547 
548 //*************************************************************************************************
553 template<>
554 struct IntrinsicTraitBase<short>
555 {
556  private:
557  typedef IntrinsicTraitHelper<false,sizeof(short)> Helper;
558 
559  public:
560  typedef Helper::Type Type;
561  enum { size = Helper::size,
562  alignment = AlignmentOf<short>::value,
563  addition = Helper::addition,
564  subtraction = Helper::subtraction,
565  multiplication = Helper::multiplication,
566  division = Helper::division,
567  absoluteValue = Helper::absoluteValue,
569 };
571 //*************************************************************************************************
572 
573 
574 //*************************************************************************************************
579 template<>
580 struct IntrinsicTraitBase<unsigned short>
581 {
582  private:
583  typedef IntrinsicTraitHelper<false,sizeof(unsigned short)> Helper;
584 
585  public:
586  typedef Helper::Type Type;
587  enum { size = Helper::size,
588  alignment = AlignmentOf<unsigned short>::value,
589  addition = Helper::addition,
590  subtraction = Helper::subtraction,
591  multiplication = Helper::multiplication,
592  division = Helper::division,
593  absoluteValue = 0,
595 };
597 //*************************************************************************************************
598 
599 
600 //*************************************************************************************************
605 template<>
606 struct IntrinsicTraitBase<int>
607 {
608  private:
609  typedef IntrinsicTraitHelper<false,sizeof(int)> Helper;
610 
611  public:
612  typedef Helper::Type Type;
613  enum { size = Helper::size,
614  alignment = AlignmentOf<int>::value,
615  addition = Helper::addition,
616  subtraction = Helper::subtraction,
617  multiplication = Helper::multiplication,
618  division = Helper::division,
619  absoluteValue = Helper::absoluteValue,
621 };
623 //*************************************************************************************************
624 
625 
626 //*************************************************************************************************
631 template<>
632 struct IntrinsicTraitBase<unsigned int>
633 {
634  private:
635  typedef IntrinsicTraitHelper<false,sizeof(unsigned int)> Helper;
636 
637  public:
638  typedef Helper::Type Type;
639  enum { size = Helper::size,
640  alignment = AlignmentOf<unsigned int>::value,
641  addition = Helper::addition,
642  subtraction = Helper::subtraction,
643  multiplication = Helper::multiplication,
644  division = Helper::division,
645  absoluteValue = 0,
647 };
649 //*************************************************************************************************
650 
651 
652 //*************************************************************************************************
657 template<>
658 struct IntrinsicTraitBase<long>
659 {
660  private:
661  typedef IntrinsicTraitHelper<false,sizeof(long)> Helper;
662 
663  public:
664  typedef Helper::Type Type;
665  enum { size = Helper::size,
666  alignment = AlignmentOf<long>::value,
667  addition = Helper::addition,
668  subtraction = Helper::subtraction,
669  multiplication = Helper::multiplication,
670  division = Helper::division,
671  absoluteValue = Helper::absoluteValue,
673 };
675 //*************************************************************************************************
676 
677 
678 //*************************************************************************************************
683 template<>
684 struct IntrinsicTraitBase<unsigned long>
685 {
686  private:
687  typedef IntrinsicTraitHelper<false,sizeof(unsigned long)> Helper;
688 
689  public:
690  typedef Helper::Type Type;
691  enum { size = Helper::size,
692  alignment = AlignmentOf<unsigned long>::value,
693  addition = Helper::addition,
694  subtraction = Helper::subtraction,
695  multiplication = Helper::multiplication,
696  division = Helper::division,
697  absoluteValue = 0,
699 };
701 //*************************************************************************************************
702 
703 
704 //*************************************************************************************************
709 #if BLAZE_MIC_MODE
710 struct IntrinsicTraitBase<float>
711 {
712  typedef simd_float_t Type;
713  enum { size = ( 64UL / sizeof(float) ),
714  alignment = AlignmentOf<float>::value,
715  addition = 1,
716  subtraction = 1,
717  multiplication = 1,
718  division = 1,
719  absoluteValue = 0,
720  conjugate = 1 };
721 };
722 #elif BLAZE_AVX_MODE
723 template<>
724 struct IntrinsicTraitBase<float>
725 {
726  typedef simd_float_t Type;
727  enum { size = ( 32UL / sizeof(float) ),
728  alignment = AlignmentOf<float>::value,
729  addition = 1,
730  subtraction = 1,
731  multiplication = 1,
732  division = 1,
733  absoluteValue = 0,
734  conjugate = 1 };
735 };
736 #else
737 template<>
738 struct IntrinsicTraitBase<float>
739 {
740  typedef simd_float_t Type;
741  enum { size = ( BLAZE_SSE_MODE )?( 16UL / sizeof(float) ):( 1 ),
742  alignment = AlignmentOf<float>::value,
743  addition = BLAZE_SSE_MODE,
744  subtraction = BLAZE_SSE_MODE,
745  multiplication = BLAZE_SSE_MODE,
746  division = BLAZE_SSE_MODE,
747  absoluteValue = 0,
748  conjugate = 1 };
749 };
750 #endif
751 
752 //*************************************************************************************************
753 
754 
755 //*************************************************************************************************
760 #if BLAZE_MIC_MODE
761 template<>
762 struct IntrinsicTraitBase<double>
763 {
764  typedef simd_double_t Type;
765  enum { size = ( 64UL / sizeof(double) ),
766  alignment = AlignmentOf<double>::value,
767  addition = 1,
768  subtraction = 1,
769  multiplication = 1,
770  division = 1,
771  absoluteValue = 0,
772  conjugate = 1 };
773 };
774 #elif BLAZE_AVX_MODE
775 template<>
776 struct IntrinsicTraitBase<double>
777 {
778  typedef simd_double_t Type;
779  enum { size = ( 32UL / sizeof(double) ),
780  alignment = AlignmentOf<double>::value,
781  addition = 1,
782  subtraction = 1,
783  multiplication = 1,
784  division = 1,
785  absoluteValue = 0,
786  conjugate = 1 };
787 };
788 #else
789 template<>
790 struct IntrinsicTraitBase<double>
791 {
792  typedef simd_double_t Type;
793  enum { size = ( BLAZE_SSE2_MODE )?( 16UL / sizeof(double) ):( 1 ),
794  alignment = AlignmentOf<double>::value,
795  addition = BLAZE_SSE2_MODE,
796  subtraction = BLAZE_SSE2_MODE,
797  multiplication = BLAZE_SSE2_MODE,
798  division = BLAZE_SSE2_MODE,
799  absoluteValue = 0,
800  conjugate = 1 };
801 };
802 #endif
803 
804 //*************************************************************************************************
805 
806 
807 //*************************************************************************************************
812 template<>
813 struct IntrinsicTraitBase< complex<char> >
814 {
815  private:
816  typedef IntrinsicTraitHelper<true,sizeof(char)> Helper;
817 
818  public:
819  typedef Helper::Type Type;
820  enum { size = Helper::size,
821  alignment = AlignmentOf< complex<char> >::value,
822  addition = Helper::addition,
823  subtraction = Helper::subtraction,
824  multiplication = Helper::multiplication,
825  division = Helper::division,
826  absoluteValue = Helper::absoluteValue,
828 
829  BLAZE_STATIC_ASSERT( sizeof( complex<char> ) == 2UL*sizeof( char ) );
830 };
832 //*************************************************************************************************
833 
834 
835 //*************************************************************************************************
840 template<>
841 struct IntrinsicTraitBase< complex<signed char> >
842 {
843  private:
844  typedef IntrinsicTraitHelper<true,sizeof(signed char)> Helper;
845 
846  public:
847  typedef Helper::Type Type;
848  enum { size = Helper::size,
849  alignment = AlignmentOf< complex<signed char> >::value,
850  addition = Helper::addition,
851  subtraction = Helper::subtraction,
852  multiplication = Helper::multiplication,
853  division = Helper::division,
854  absoluteValue = Helper::absoluteValue,
856 
857  BLAZE_STATIC_ASSERT( sizeof( complex<signed char> ) == 2UL*sizeof( signed char ) );
858 };
860 //*************************************************************************************************
861 
862 
863 //*************************************************************************************************
868 template<>
869 struct IntrinsicTraitBase< complex<unsigned char> >
870 {
871  private:
872  typedef IntrinsicTraitHelper<true,sizeof(unsigned char)> Helper;
873 
874  public:
875  typedef Helper::Type Type;
876  enum { size = Helper::size,
877  alignment = AlignmentOf< complex<unsigned char> >::value,
878  addition = Helper::addition,
879  subtraction = Helper::subtraction,
880  multiplication = Helper::multiplication,
881  division = Helper::division,
882  absoluteValue = 0,
884 
885  BLAZE_STATIC_ASSERT( sizeof( complex<unsigned char> ) == 2UL*sizeof( unsigned char ) );
886 };
888 //*************************************************************************************************
889 
890 
891 //*************************************************************************************************
896 template<>
897 struct IntrinsicTraitBase< complex<wchar_t> >
898 {
899  private:
900  typedef IntrinsicTraitHelper<true,sizeof(wchar_t)> Helper;
901 
902  public:
903  typedef Helper::Type Type;
904  enum { size = Helper::size,
905  alignment = AlignmentOf< complex<wchar_t> >::value,
906  addition = Helper::addition,
907  subtraction = Helper::subtraction,
908  multiplication = Helper::multiplication,
909  division = Helper::division,
910  absoluteValue = Helper::absoluteValue,
912 
913  BLAZE_STATIC_ASSERT( sizeof( complex<wchar_t> ) == 2UL*sizeof( wchar_t ) );
914 };
916 //*************************************************************************************************
917 
918 
919 //*************************************************************************************************
924 template<>
925 struct IntrinsicTraitBase< complex<short> >
926 {
927  private:
928  typedef IntrinsicTraitHelper<true,sizeof(short)> Helper;
929 
930  public:
931  typedef Helper::Type Type;
932  enum { size = Helper::size,
933  alignment = AlignmentOf< complex<short> >::value,
934  addition = Helper::addition,
935  subtraction = Helper::subtraction,
936  multiplication = Helper::multiplication,
937  division = Helper::division,
938  absoluteValue = Helper::absoluteValue,
940 
941  BLAZE_STATIC_ASSERT( sizeof( complex<short> ) == 2UL*sizeof( short ) );
942 };
944 //*************************************************************************************************
945 
946 
947 //*************************************************************************************************
952 template<>
953 struct IntrinsicTraitBase< complex<unsigned short> >
954 {
955  private:
956  typedef IntrinsicTraitHelper<true,sizeof(unsigned short)> Helper;
957 
958  public:
959  typedef Helper::Type Type;
960  enum { size = Helper::size,
961  alignment = AlignmentOf< complex<unsigned short> >::value,
962  addition = Helper::addition,
963  subtraction = Helper::subtraction,
964  multiplication = Helper::multiplication,
965  division = Helper::division,
966  absoluteValue = 0,
968 
969  BLAZE_STATIC_ASSERT( sizeof( complex<unsigned short> ) == 2UL*sizeof( unsigned short ) );
970 };
972 //*************************************************************************************************
973 
974 
975 //*************************************************************************************************
980 template<>
981 struct IntrinsicTraitBase< complex<int> >
982 {
983  private:
984  typedef IntrinsicTraitHelper<true,sizeof(int)> Helper;
985 
986  public:
987  typedef Helper::Type Type;
988  enum { size = Helper::size,
989  alignment = AlignmentOf< complex<int> >::value,
990  addition = Helper::addition,
991  subtraction = Helper::subtraction,
992  multiplication = Helper::multiplication,
993  division = Helper::division,
994  absoluteValue = Helper::absoluteValue,
996 
997  BLAZE_STATIC_ASSERT( sizeof( complex<int> ) == 2UL*sizeof( int ) );
998 };
1000 //*************************************************************************************************
1001 
1002 
1003 //*************************************************************************************************
1008 template<>
1009 struct IntrinsicTraitBase< complex<unsigned int> >
1010 {
1011  private:
1012  typedef IntrinsicTraitHelper<true,sizeof(unsigned int)> Helper;
1013 
1014  public:
1015  typedef Helper::Type Type;
1016  enum { size = Helper::size,
1017  alignment = AlignmentOf< complex<unsigned int> >::value,
1018  addition = Helper::addition,
1019  subtraction = Helper::subtraction,
1020  multiplication = Helper::multiplication,
1021  division = Helper::division,
1022  absoluteValue = 0,
1024 
1025  BLAZE_STATIC_ASSERT( sizeof( complex<unsigned int> ) == 2UL*sizeof( unsigned int ) );
1026 };
1028 //*************************************************************************************************
1029 
1030 
1031 //*************************************************************************************************
1036 template<>
1037 struct IntrinsicTraitBase< complex<long> >
1038 {
1039  private:
1040  typedef IntrinsicTraitHelper<true,sizeof(long)> Helper;
1041 
1042  public:
1043  typedef Helper::Type Type;
1044  enum { size = Helper::size,
1045  alignment = AlignmentOf< complex<long> >::value,
1046  addition = Helper::addition,
1047  subtraction = Helper::subtraction,
1048  multiplication = Helper::multiplication,
1049  division = Helper::division,
1050  absoluteValue = Helper::absoluteValue,
1052 
1053  BLAZE_STATIC_ASSERT( sizeof( complex<long> ) == 2UL*sizeof( long ) );
1054 };
1056 //*************************************************************************************************
1057 
1058 
1059 //*************************************************************************************************
1064 template<>
1065 struct IntrinsicTraitBase< complex<unsigned long> >
1066 {
1067  private:
1068  typedef IntrinsicTraitHelper<true,sizeof(unsigned long)> Helper;
1069 
1070  public:
1071  typedef Helper::Type Type;
1072  enum { size = Helper::size,
1073  alignment = AlignmentOf< complex<unsigned long> >::value,
1074  addition = Helper::addition,
1075  subtraction = Helper::subtraction,
1076  multiplication = Helper::multiplication,
1077  division = Helper::division,
1078  absoluteValue = 0,
1080 
1081  BLAZE_STATIC_ASSERT( sizeof( complex<unsigned long> ) == 2UL*sizeof( unsigned long ) );
1082 };
1084 //*************************************************************************************************
1085 
1086 
1087 //*************************************************************************************************
1092 #if BLAZE_MIC_MODE
1093 template<>
1094 struct IntrinsicTraitBase< complex<float> >
1095 {
1096  typedef simd_cfloat_t Type;
1097  enum { size = ( 64UL / sizeof(complex<float>) ),
1098  alignment = AlignmentOf< complex<float> >::value,
1099  addition = 1,
1100  subtraction = 1,
1101  multiplication = 0,
1102  division = 0,
1103  absoluteValue = 0,
1104  conjugate = 1 };
1105 
1106  BLAZE_STATIC_ASSERT( sizeof( complex<float> ) == 2UL*sizeof( float ) );
1107 };
1108 #elif BLAZE_AVX_MODE
1109 template<>
1110 struct IntrinsicTraitBase< complex<float> >
1111 {
1112  typedef simd_cfloat_t Type;
1113  enum { size = ( 32UL / sizeof(complex<float>) ),
1114  alignment = AlignmentOf< complex<float> >::value,
1115  addition = 1,
1116  subtraction = 1,
1117  multiplication = 1,
1118  division = 0,
1119  absoluteValue = 0,
1120  conjugate = 1 };
1121 
1122  BLAZE_STATIC_ASSERT( sizeof( complex<float> ) == 2UL*sizeof( float ) );
1123 };
1124 #else
1125 template<>
1126 struct IntrinsicTraitBase< complex<float> >
1127 {
1128  typedef simd_cfloat_t Type;
1129  enum { size = ( BLAZE_SSE_MODE )?( 16UL / sizeof(complex<float>) ):( 1 ),
1130  alignment = AlignmentOf< complex<float> >::value,
1131  addition = BLAZE_SSE_MODE,
1132  subtraction = BLAZE_SSE_MODE,
1133  multiplication = BLAZE_SSE3_MODE,
1134  division = 0,
1135  absoluteValue = 0,
1137 
1138  BLAZE_STATIC_ASSERT( sizeof( complex<float> ) == 2UL*sizeof( float ) );
1139 };
1140 #endif
1141 
1142 //*************************************************************************************************
1143 
1144 
1145 //*************************************************************************************************
1150 #if BLAZE_MIC_MODE
1151 template<>
1152 struct IntrinsicTraitBase< complex<double> >
1153 {
1154  typedef simd_cdouble_t Type;
1155  enum { size = ( 64UL / sizeof(complex<double>) ),
1156  alignment = AlignmentOf< complex<double> >::value,
1157  addition = 1,
1158  subtraction = 1,
1159  multiplication = 0,
1160  division = 0,
1161  absoluteValue = 0,
1162  conjugate = 1 };
1163 
1164  BLAZE_STATIC_ASSERT( sizeof( complex<double> ) == 2UL*sizeof( double ) );
1165 };
1166 #elif BLAZE_AVX_MODE
1167 template<>
1168 struct IntrinsicTraitBase< complex<double> >
1169 {
1170  typedef simd_cdouble_t Type;
1171  enum { size = ( 32UL / sizeof(complex<double>) ),
1172  alignment = AlignmentOf< complex<double> >::value,
1173  addition = 1,
1174  subtraction = 1,
1175  multiplication = 1,
1176  division = 0,
1177  absoluteValue = 0,
1178  conjugate = 1 };
1179 
1180  BLAZE_STATIC_ASSERT( sizeof( complex<double> ) == 2UL*sizeof( double ) );
1181 };
1182 #else
1183 template<>
1184 struct IntrinsicTraitBase< complex<double> >
1185 {
1186  typedef simd_cdouble_t Type;
1187  enum { size = ( BLAZE_SSE2_MODE )?( 16UL / sizeof(complex<double>) ):( 1 ),
1188  alignment = AlignmentOf< complex<double> >::value,
1189  addition = BLAZE_SSE2_MODE,
1190  subtraction = BLAZE_SSE2_MODE,
1191  multiplication = BLAZE_SSE3_MODE,
1192  division = 0,
1193  absoluteValue = 0,
1195 
1196  BLAZE_STATIC_ASSERT( sizeof( complex<double> ) == 2UL*sizeof( double ) );
1197 };
1198 #endif
1199 
1200 //*************************************************************************************************
1201 
1202 
1203 
1204 
1205 //=================================================================================================
1206 //
1207 // CLASS INTRINSICTRAIT
1208 //
1209 //=================================================================================================
1210 
1211 //*************************************************************************************************
1231 template< typename T >
1232 class IntrinsicTrait : public IntrinsicTraitBase< typename RemoveCV<T>::Type >
1233 {};
1234 //*************************************************************************************************
1235 
1236 } // namespace blaze
1237 
1238 #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:252
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.
BLAZE_ALWAYS_INLINE void conjugate(T &a)
In-place conjugation of the given value/object.
Definition: Conjugate.h:120
#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:1232
#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