Blaze 3.9
Equal.h
Go to the documentation of this file.
1//=================================================================================================
33//=================================================================================================
34
35#ifndef _BLAZE_MATH_SIMD_EQUAL_H_
36#define _BLAZE_MATH_SIMD_EQUAL_H_
37
38
39//*************************************************************************************************
40// Includes
41//*************************************************************************************************
42
43#include <blaze/math/Accuracy.h>
47#include <blaze/system/Inline.h>
49
50
51namespace blaze {
52
53//=================================================================================================
54//
55// 8-BIT INTEGRAL SIMD TYPES
56//
57//=================================================================================================
58
59//*************************************************************************************************
70template< RelaxationFlag RF // Relaxation flag
71 , typename T > // Type of both operands
72BLAZE_ALWAYS_INLINE bool equal( const SIMDi8<T>& a, const SIMDi8<T>& b ) noexcept
73#if BLAZE_AVX512BW_MODE
74{
75 return _mm512_cmpeq_epi8_mask( (*a).value, (*b).value ) == 0xffffffffffffffff;
76}
77#elif BLAZE_AVX2_MODE
78{
79 return _mm256_movemask_epi8( _mm256_cmpeq_epi8( (*a).value, (*b).value ) ) == int(0xffffffff);
80}
81#elif BLAZE_SSE2_MODE
82{
83 return _mm_movemask_epi8( _mm_cmpeq_epi8( (*a).value, (*b).value ) ) == int(0xffff);
84}
85#else
86= delete;
87#endif
89//*************************************************************************************************
90
91
92//*************************************************************************************************
103template< RelaxationFlag RF // Relaxation flag
104 , typename T > // Type of both operands
105BLAZE_ALWAYS_INLINE bool equal( const SIMDci8<T>& a, const SIMDci8<T>& b ) noexcept
106#if BLAZE_AVX512BW_MODE
107{
108 return _mm512_cmpeq_epi8_mask( (*a).value, (*b).value ) == 0xffffffffffffffff;
109}
110#elif BLAZE_AVX2_MODE
111{
112 return _mm256_movemask_epi8( _mm256_cmpeq_epi8( (*a).value, (*b).value ) ) == int(0xffffffff);
113}
114#elif BLAZE_SSE2_MODE
115{
116 return _mm_movemask_epi8( _mm_cmpeq_epi8( (*a).value, (*b).value ) ) == int(0xffff);
117}
118#else
119= delete;
120#endif
122//*************************************************************************************************
123
124//*************************************************************************************************
134template< typename T > // Type of both operands
135BLAZE_ALWAYS_INLINE bool operator==( const SIMDi8<T>& a, const SIMDi8<T>& b ) noexcept
136{
137 return equal<strict>( *a, *b );
138}
139//*************************************************************************************************
140
141
142//*************************************************************************************************
152template< typename T > // Type of both operands
153BLAZE_ALWAYS_INLINE bool operator==( const SIMDci8<T>& a, const SIMDci8<T>& b ) noexcept
154{
155 return equal<strict>( *a, *b );
156}
157//*************************************************************************************************
158
159
160
161
162//=================================================================================================
163//
164// 16-BIT INTEGRAL SIMD TYPES
165//
166//=================================================================================================
167
168//*************************************************************************************************
179template< RelaxationFlag RF // Relaxation flag
180 , typename T > // Type of both operands
181BLAZE_ALWAYS_INLINE bool equal( const SIMDi16<T>& a, const SIMDi16<T>& b ) noexcept
182#if BLAZE_AVX512BW_MODE
183{
184 return _mm512_cmpeq_epi16_mask( (*a).value, (*b).value ) == 0xffffffff;
185}
186#elif BLAZE_AVX2_MODE
187{
188 return _mm256_movemask_epi8( _mm256_cmpeq_epi16( (*a).value, (*b).value ) ) == int(0xffffffff);
189}
190#elif BLAZE_SSE2_MODE
191{
192 return _mm_movemask_epi8( _mm_cmpeq_epi16( (*a).value, (*b).value ) ) == int(0xffff);
193}
194#else
195= delete;
196#endif
198//*************************************************************************************************
199
200
201//*************************************************************************************************
212template< RelaxationFlag RF // Relaxation flag
213 , typename T > // Type of both operands
214BLAZE_ALWAYS_INLINE bool equal( const SIMDci16<T>& a, const SIMDci16<T>& b ) noexcept
215#if BLAZE_AVX512BW_MODE
216{
217 return _mm512_cmpeq_epi16_mask( (*a).value, (*b).value ) == 0xffffffff;
218}
219#elif BLAZE_AVX2_MODE
220{
221 return _mm256_movemask_epi8( _mm256_cmpeq_epi16( (*a).value, (*b).value ) ) == int(0xffffffff);
222}
223#elif BLAZE_SSE2_MODE
224{
225 return _mm_movemask_epi8( _mm_cmpeq_epi16( (*a).value, (*b).value ) ) == int(0xffff);
226}
227#else
228= delete;
229#endif
231//*************************************************************************************************
232
233
234//*************************************************************************************************
244template< typename T > // Type of both operands
245BLAZE_ALWAYS_INLINE bool operator==( const SIMDi16<T>& a, const SIMDi16<T>& b ) noexcept
246{
247 return equal<strict>( *a, *b );
248}
249//*************************************************************************************************
250
251
252//*************************************************************************************************
262template< typename T > // Type of both operands
263BLAZE_ALWAYS_INLINE bool operator==( const SIMDci16<T>& a, const SIMDci16<T>& b ) noexcept
264{
265 return equal<strict>( *a, *b );
266}
267//*************************************************************************************************
268
269
270
271
272//=================================================================================================
273//
274// 32-BIT INTEGRAL SIMD TYPES
275//
276//=================================================================================================
277
278//*************************************************************************************************
289template< RelaxationFlag RF // Relaxation flag
290 , typename T > // Type of both operands
291BLAZE_ALWAYS_INLINE bool equal( const SIMDi32<T>& a, const SIMDi32<T>& b ) noexcept
292#if BLAZE_AVX512F_MODE || BLAZE_MIC_MODE
293{
294 return _mm512_cmpeq_epi32_mask( (*a).value, (*b).value ) == 0xffff;
295}
296#elif BLAZE_AVX2_MODE
297{
298 return _mm256_movemask_epi8( _mm256_cmpeq_epi32( (*a).value, (*b).value ) ) == int(0xffffffff);
299}
300#elif BLAZE_SSE2_MODE
301{
302 return _mm_movemask_epi8( _mm_cmpeq_epi32( (*a).value, (*b).value ) ) == int(0xffff);
303}
304#else
305= delete;
306#endif
308//*************************************************************************************************
309
310
311//*************************************************************************************************
322template< RelaxationFlag RF // Relaxation flag
323 , typename T > // Type of both operands
324BLAZE_ALWAYS_INLINE bool equal( const SIMDci32<T>& a, const SIMDci32<T>& b ) noexcept
325#if BLAZE_AVX512F_MODE || BLAZE_MIC_MODE
326{
327 return _mm512_cmpeq_epi32_mask( (*a).value, (*b).value ) == 0xffff;
328}
329#elif BLAZE_AVX2_MODE
330{
331 return _mm256_movemask_epi8( _mm256_cmpeq_epi32( (*a).value, (*b).value ) ) == int(0xffffffff);
332}
333#elif BLAZE_SSE2_MODE
334{
335 return _mm_movemask_epi8( _mm_cmpeq_epi32( (*a).value, (*b).value ) ) == int(0xffff);
336}
337#else
338= delete;
339#endif
341//*************************************************************************************************
342
343
344//*************************************************************************************************
354template< typename T > // Type of both operands
355BLAZE_ALWAYS_INLINE bool operator==( const SIMDi32<T>& a, const SIMDi32<T>& b ) noexcept
356{
357 return equal<strict>( *a, *b );
358}
359//*************************************************************************************************
360
361
362//*************************************************************************************************
372template< typename T > // Type of both operands
373BLAZE_ALWAYS_INLINE bool operator==( const SIMDci32<T>& a, const SIMDci32<T>& b ) noexcept
374{
375 return equal<strict>( *a, *b );
376}
377//*************************************************************************************************
378
379
380
381
382
383//=================================================================================================
384//
385// 64-BIT INTEGRAL SIMD TYPES
386//
387//=================================================================================================
388
389//*************************************************************************************************
400template< RelaxationFlag RF // Relaxation flag
401 , typename T > // Type of both operands
402BLAZE_ALWAYS_INLINE bool equal( const SIMDi64<T>& a, const SIMDi64<T>& b ) noexcept
403#if BLAZE_AVX512F_MODE
404{
405 return _mm512_cmpeq_epi64_mask( (*a).value, (*b).value ) == 0xff;
406}
407#elif BLAZE_AVX2_MODE
408{
409 return _mm256_movemask_epi8( _mm256_cmpeq_epi64( (*a).value, (*b).value ) ) == int(0xffffffff);
410}
411#elif BLAZE_SSE4_MODE
412{
413 return _mm_movemask_epi8( _mm_cmpeq_epi64( (*a).value, (*b).value ) ) == int(0xffff);
414}
415#else
416= delete;
417#endif
419//*************************************************************************************************
420
421
422//*************************************************************************************************
433template< RelaxationFlag RF // Relaxation flag
434 , typename T > // Type of both operands
435BLAZE_ALWAYS_INLINE bool equal( const SIMDci64<T>& a, const SIMDci64<T>& b ) noexcept
436#if BLAZE_AVX512F_MODE
437{
438 return _mm512_cmpeq_epi64_mask( (*a).value, (*b).value ) == 0xff;
439}
440#elif BLAZE_AVX2_MODE
441{
442 return _mm256_movemask_epi8( _mm256_cmpeq_epi64( (*a).value, (*b).value ) ) == int(0xffffffff);
443}
444#elif BLAZE_SSE4_MODE
445{
446 return _mm_movemask_epi8( _mm_cmpeq_epi64( (*a).value, (*b).value ) ) == int(0xffff);
447}
448#else
449= delete;
450#endif
452//*************************************************************************************************
453
454
455//*************************************************************************************************
465template< typename T > // Type of both operands
466BLAZE_ALWAYS_INLINE bool operator==( const SIMDi64<T>& a, const SIMDi64<T>& b ) noexcept
467{
468 return equal<strict>( *a, *b );
469}
470//*************************************************************************************************
471
472
473//*************************************************************************************************
483template< typename T > // Type of both operands
484BLAZE_ALWAYS_INLINE bool operator==( const SIMDci64<T>& a, const SIMDci64<T>& b ) noexcept
485{
486 return equal<strict>( *a, *b );
487}
488//*************************************************************************************************
489
490
491
492
493//=================================================================================================
494//
495// 32-BIT FLOATING POINT SIMD TYPES
496//
497//=================================================================================================
498
499//*************************************************************************************************
515template< RelaxationFlag RF > // Relaxation flag
516BLAZE_ALWAYS_INLINE bool equal( const SIMDfloat& a, const SIMDfloat& b ) noexcept
517#if ( BLAZE_AVX512F_MODE || BLAZE_MIC_MODE ) && BLAZE_GNU_COMPILER
518= delete;
519#elif BLAZE_AVX512F_MODE || BLAZE_MIC_MODE
520{
521 if( RF == relaxed ) {
522 const __m512 accu( _mm512_set1_ps( static_cast<float>( accuracy ) ) );
523
524 const __m512 xmm1( _mm512_abs_ps( _mm512_sub_ps( a.value, b.value ) ) );
525 const __m512 xmm2( _mm512_max_ps( accu, _mm512_mul_ps( accu, _mm512_abs_ps( a.value ) ) ) );
526 return _mm512_cmple_ps_mask( xmm1, xmm2 ) == 0xffff;
527 }
528 else {
529 return _mm512_cmpeq_ps_mask( a.value, b.value ) == 0xffff;
530 }
531}
532#elif BLAZE_AVX_MODE
533{
534 if( RF == relaxed ) {
535 const __m256 accu( _mm256_set1_ps( static_cast<float>( accuracy ) ) );
536 const __m256 mask( _mm256_castsi256_ps( _mm256_set1_epi32( 0x80000000 ) ) );
537
538 const __m256 xmm1( _mm256_andnot_ps( mask, _mm256_sub_ps( a.value, b.value ) ) );
539 const __m256 xmm2( _mm256_max_ps( accu, _mm256_mul_ps( accu, _mm256_andnot_ps( mask, a.value ) ) ) );
540 return _mm256_movemask_ps( _mm256_cmp_ps( xmm1, xmm2, _CMP_LE_OQ ) ) == 0xff;
541 }
542 else {
543 return _mm256_movemask_ps( _mm256_cmp_ps( a.value, b.value, _CMP_EQ_OQ ) ) == 0xff;
544 }
545}
546#elif BLAZE_SSE_MODE
547{
548 if( RF == relaxed ) {
549 const __m128 accu( _mm_set1_ps( static_cast<float>( accuracy ) ) );
550 const __m128 mask( _mm_castsi128_ps( _mm_set1_epi32( 0x80000000 ) ) );
551
552 const __m128 xmm1( _mm_andnot_ps( mask, _mm_sub_ps( a.value, b.value ) ) );
553 const __m128 xmm2( _mm_max_ps( accu, _mm_mul_ps( accu, _mm_andnot_ps( mask, a.value ) ) ) );
554 return _mm_movemask_ps( _mm_cmple_ps( xmm1, xmm2 ) ) == 0xf;
555 }
556 else {
557 return _mm_movemask_ps( _mm_cmpeq_ps( a.value, b.value ) ) == 0xf;
558 }
559}
560#else
561= delete;
562#endif
564//*************************************************************************************************
565
566
567//*************************************************************************************************
583template< RelaxationFlag RF > // Relaxation flag
584BLAZE_ALWAYS_INLINE bool equal( const SIMDcfloat& a, const SIMDcfloat& b ) noexcept
585#if ( BLAZE_AVX512F_MODE || BLAZE_MIC_MODE ) && BLAZE_GNU_COMPILER
586= delete;
587#elif BLAZE_AVX512F_MODE || BLAZE_MIC_MODE
588{
589 if( RF == relaxed ) {
590 const __m512 accu( _mm512_set1_ps( static_cast<float>( accuracy ) ) );
591
592 const __m512 xmm1( _mm512_abs_ps( _mm512_sub_ps( a.value, b.value ) ) );
593 const __m512 xmm2( _mm512_max_ps( accu, _mm512_mul_ps( accu, _mm512_abs_ps( a.value ) ) ) );
594 return _mm512_cmple_ps_mask( xmm1, xmm2 ) == 0xffff;
595 }
596 else {
597 return _mm512_cmpeq_ps_mask( a.value, b.value ) == 0xffff;
598 }
599}
600#elif BLAZE_AVX_MODE
601{
602 if( RF == relaxed ) {
603 const __m256 accu( _mm256_set1_ps( static_cast<float>( accuracy ) ) );
604 const __m256 mask( _mm256_castsi256_ps( _mm256_set1_epi32( 0x80000000 ) ) );
605
606 const __m256 xmm1( _mm256_andnot_ps( mask, _mm256_sub_ps( a.value, b.value ) ) );
607 const __m256 xmm2( _mm256_max_ps( accu, _mm256_mul_ps( accu, _mm256_andnot_ps( mask, a.value ) ) ) );
608 return _mm256_movemask_ps( _mm256_cmp_ps( xmm1, xmm2, _CMP_LE_OQ ) ) == 0xff;
609 }
610 else {
611 return _mm256_movemask_ps( _mm256_cmp_ps( a.value, b.value, _CMP_EQ_OQ ) ) == 0xff;
612 }
613}
614#elif BLAZE_SSE_MODE
615{
616 if( RF == relaxed ) {
617 const __m128 accu( _mm_set1_ps( static_cast<float>( accuracy ) ) );
618 const __m128 mask( _mm_castsi128_ps( _mm_set1_epi32( 0x80000000 ) ) );
619
620 const __m128 xmm1( _mm_andnot_ps( mask, _mm_sub_ps( a.value, b.value ) ) );
621 const __m128 xmm2( _mm_max_ps( accu, _mm_mul_ps( accu, _mm_andnot_ps( mask, a.value ) ) ) );
622 return _mm_movemask_ps( _mm_cmple_ps( xmm1, xmm2 ) ) == 0xf;
623 }
624 else {
625 return _mm_movemask_ps( _mm_cmpeq_ps( a.value, b.value ) ) == 0xf;
626 }
627}
628#else
629= delete;
630#endif
632//*************************************************************************************************
633
634
635//*************************************************************************************************
645template< typename T1 // Type of the left-hand side operand
646 , typename T2 > // Type of the right-hand side operand
647BLAZE_ALWAYS_INLINE bool operator==( const SIMDf32<T1>& a, const SIMDf32<T2>& b ) noexcept
648#if ( BLAZE_AVX512F_MODE || BLAZE_MIC_MODE ) && BLAZE_GNU_COMPILER
649= delete;
650#elif BLAZE_AVX512F_MODE || BLAZE_MIC_MODE
651{
652 return _mm512_cmpeq_ps_mask( (*a).eval().value, (*b).eval().value ) == 0xffff;
653}
654#elif BLAZE_AVX_MODE
655{
656 return _mm256_movemask_ps( _mm256_cmp_ps( (*a).eval().value, (*b).eval().value, _CMP_EQ_OQ ) ) == 0xff;
657}
658#elif BLAZE_SSE_MODE
659{
660 return _mm_movemask_ps( _mm_cmpeq_ps( (*a).eval().value, (*b).eval().value ) ) == 0xf;
661}
662#else
663= delete;
664#endif
665//*************************************************************************************************
666
667
668//*************************************************************************************************
678BLAZE_ALWAYS_INLINE bool operator==( const SIMDcfloat& a, const SIMDcfloat& b ) noexcept
679#if ( BLAZE_AVX512F_MODE || BLAZE_MIC_MODE ) && BLAZE_GNU_COMPILER
680= delete;
681#elif BLAZE_AVX512F_MODE || BLAZE_MIC_MODE
682{
683 return _mm512_cmpeq_ps_mask( a.value, b.value ) == 0xffff;
684}
685#elif BLAZE_AVX_MODE
686{
687 return _mm256_movemask_ps( _mm256_cmp_ps( a.value, b.value, _CMP_EQ_OQ ) ) == 0xff;
688}
689#elif BLAZE_SSE_MODE
690{
691 return _mm_movemask_ps( _mm_cmpeq_ps( a.value, b.value ) ) == 0xf;
692}
693#else
694= delete;
695#endif
696//*************************************************************************************************
697
698
699
700
701//=================================================================================================
702//
703// 64-BIT FLOATING POINT SIMD TYPES
704//
705//=================================================================================================
706
707//*************************************************************************************************
723template< RelaxationFlag RF > // Relaxation flag
724BLAZE_ALWAYS_INLINE bool equal( const SIMDdouble& a, const SIMDdouble& b ) noexcept
725#if ( BLAZE_AVX512F_MODE || BLAZE_MIC_MODE ) && BLAZE_GNU_COMPILER
726= delete;
727#elif BLAZE_AVX512F_MODE || BLAZE_MIC_MODE
728{
729 if( RF == relaxed ) {
730 const __m512 accu( _mm512_set1_pd( static_cast<double>( accuracy ) ) );
731
732 const __m512 xmm1( _mm512_abs_pd( _mm512_sub_pd( a.value, b.value ) ) );
733 const __m512 xmm2( _mm512_max_pd( accu, _mm512_mul_pd( accu, _mm512_abs_pd( a.value ) ) ) );
734 return _mm512_cmple_pd_mask( xmm1, xmm2 ) == 0xff;
735 }
736 else {
737 return _mm512_cmpeq_pd_mask( a.value, b.value ) == 0xff;
738 }
739}
740#elif BLAZE_AVX_MODE
741{
742 if( RF == relaxed ) {
743 const __m256d accu( _mm256_set1_pd( static_cast<double>( accuracy ) ) );
744 const __m256d mask( _mm256_castsi256_pd(
745 _mm256_set_epi32( 0x80000000, 0x0, 0x80000000, 0x0, 0x80000000, 0x0, 0x80000000, 0x0 ) ) );
746
747 const __m256d xmm1( _mm256_andnot_pd( mask, _mm256_sub_pd( a.value, b.value ) ) );
748 const __m256d xmm2( _mm256_max_pd( accu, _mm256_mul_pd( accu, _mm256_andnot_pd( mask, a.value ) ) ) );
749 return _mm256_movemask_pd( _mm256_cmp_pd( xmm1, xmm2, _CMP_LE_OQ ) ) == 0xf;
750 }
751 else {
752 return _mm256_movemask_pd( _mm256_cmp_pd( a.value, b.value, _CMP_EQ_OQ ) ) == 0xf;
753 }
754}
755#elif BLAZE_SSE2_MODE
756{
757 if( RF == relaxed ) {
758 const __m128d accu( _mm_set1_pd( static_cast<double>( accuracy ) ) );
759 const __m128d mask( _mm_castsi128_pd( _mm_set_epi32( 0x80000000, 0x0, 0x80000000, 0x0 ) ) );
760
761 const __m128d xmm1( _mm_andnot_pd( mask, _mm_sub_pd( a.value, b.value ) ) );
762 const __m128d xmm2( _mm_max_pd( accu, _mm_mul_pd( accu, _mm_andnot_pd( mask, a.value ) ) ) );
763 return _mm_movemask_pd( _mm_cmple_pd( xmm1, xmm2 ) ) == 0x3;
764 }
765 else {
766 return _mm_movemask_pd( _mm_cmpeq_pd( a.value, b.value ) ) == 0x3;
767 }
768}
769#else
770= delete;
771#endif
773//*************************************************************************************************
774
775
776//*************************************************************************************************
792template< RelaxationFlag RF > // Relaxation flag
793BLAZE_ALWAYS_INLINE bool equal( const SIMDcdouble& a, const SIMDcdouble& b ) noexcept
794#if ( BLAZE_AVX512F_MODE || BLAZE_MIC_MODE ) && BLAZE_GNU_COMPILER
795= delete;
796#elif BLAZE_AVX512F_MODE || BLAZE_MIC_MODE
797{
798 if( RF == relaxed ) {
799 const __m512 accu( _mm512_set1_pd( static_cast<double>( accuracy ) ) );
800
801 const __m512 xmm1( _mm512_abs_pd( _mm512_sub_pd( a.value, b.value ) ) );
802 const __m512 xmm2( _mm512_max_pd( accu, _mm512_mul_pd( accu, _mm512_abs_pd( a.value ) ) ) );
803 return _mm512_cmple_pd_mask( xmm1, xmm2 ) == 0xff;
804 }
805 else {
806 return _mm512_cmpeq_pd_mask( a.value, b.value ) == 0xff;
807 }
808}
809#elif BLAZE_AVX_MODE
810{
811 if( RF == relaxed ) {
812 const __m256d accu( _mm256_set1_pd( static_cast<double>( accuracy ) ) );
813 const __m256d mask( _mm256_castsi256_pd(
814 _mm256_set_epi32( 0x80000000, 0x0, 0x80000000, 0x0, 0x80000000, 0x0, 0x80000000, 0x0 ) ) );
815
816 const __m256d xmm1( _mm256_andnot_pd( mask, _mm256_sub_pd( a.value, b.value ) ) );
817 const __m256d xmm2( _mm256_max_pd( accu, _mm256_mul_pd( accu, _mm256_andnot_pd( mask, a.value ) ) ) );
818 return _mm256_movemask_pd( _mm256_cmp_pd( xmm1, xmm2, _CMP_LE_OQ ) ) == 0xf;
819 }
820 else {
821 return _mm256_movemask_pd( _mm256_cmp_pd( a.value, b.value, _CMP_EQ_OQ ) ) == 0xf;
822 }
823}
824#elif BLAZE_SSE2_MODE
825{
826 if( RF == relaxed ) {
827 const __m128d accu( _mm_set1_pd( static_cast<double>( accuracy ) ) );
828 const __m128d mask( _mm_castsi128_pd( _mm_set_epi32( 0x80000000, 0x0, 0x80000000, 0x0 ) ) );
829
830 const __m128d xmm1( _mm_andnot_pd( mask, _mm_sub_pd( a.value, b.value ) ) );
831 const __m128d xmm2( _mm_max_pd( accu, _mm_mul_pd( accu, _mm_andnot_pd( mask, a.value ) ) ) );
832 return _mm_movemask_pd( _mm_cmple_pd( xmm1, xmm2 ) ) == 0x3;
833 }
834 else {
835 return _mm_movemask_pd( _mm_cmpeq_pd( a.value, b.value ) ) == 0x3;
836 }
837}
838#else
839= delete;
840#endif
842//*************************************************************************************************
843
844
845//*************************************************************************************************
855template< typename T1 // Type of the left-hand side operand
856 , typename T2 > // Type of the right-hand side operand
857BLAZE_ALWAYS_INLINE bool operator==( const SIMDf64<T1>& a, const SIMDf64<T2>& b ) noexcept
858#if ( BLAZE_AVX512F_MODE || BLAZE_MIC_MODE ) && BLAZE_GNU_COMPILER
859= delete;
860#elif BLAZE_AVX512F_MODE || BLAZE_MIC_MODE
861{
862 return _mm512_cmpeq_pd_mask( (*a).eval().value, (*b).eval().value ) == 0xff;
863}
864#elif BLAZE_AVX_MODE
865{
866 return _mm256_movemask_pd( _mm256_cmp_pd( (*a).eval().value, (*b).eval().value, _CMP_EQ_OQ ) ) == 0xf;
867}
868#elif BLAZE_SSE2_MODE
869{
870 return _mm_movemask_pd( _mm_cmpeq_pd( (*a).eval().value, (*b).eval().value ) ) == 0x3;
871}
872#else
873= delete;
874#endif
875//*************************************************************************************************
876
877
878//*************************************************************************************************
888BLAZE_ALWAYS_INLINE bool operator==( const SIMDcdouble& a, const SIMDcdouble& b ) noexcept
889#if ( BLAZE_AVX512F_MODE || BLAZE_MIC_MODE ) && BLAZE_GNU_COMPILER
890= delete;
891#elif BLAZE_AVX512F_MODE || BLAZE_MIC_MODE
892{
893 return _mm512_cmpeq_pd_mask( a.value, b.value ) == 0xff;
894}
895#elif BLAZE_AVX_MODE
896{
897 return _mm256_movemask_pd( _mm256_cmp_pd( a.value, b.value, _CMP_EQ_OQ ) ) == 0xf;
898}
899#elif BLAZE_SSE2_MODE
900{
901 return _mm_movemask_pd( _mm_cmpeq_pd( a.value, b.value ) ) == 0x3;
902}
903#else
904= delete;
905#endif
906//*************************************************************************************************
907
908
909
910
911//=================================================================================================
912//
913// INEQUALITY COMPARISON
914//
915//=================================================================================================
916
917//*************************************************************************************************
925template< typename T > // Type of both operands
926BLAZE_ALWAYS_INLINE bool operator!=( const SIMDPack<T>& a, const SIMDPack<T>& b ) noexcept
927{
928 return !( (*a) == (*b) );
929}
930//*************************************************************************************************
931
932} // namespace blaze
933
934#endif
Computation accuracy for floating point data types.
Header file for the basic SIMD types.
Compiler-specific system settings.
Header file for the relaxation flag enumeration.
Base class for all SIMD data types.
Definition: SIMDPack.h:64
SIMD type for 64-bit double precision complex values.
SIMD type for 32-bit single precision complex values.
SIMD type for 64-bit double precision floating point data values.
SIMD type for 32-bit single precision floating point data values.
constexpr bool equal(const T1 &a, const T2 &b)
Generic equality check.
Definition: Equal.h:430
RelaxationFlag
Relaxation flag for strict or relaxed semantics.
Definition: RelaxationFlag.h:66
constexpr Accuracy accuracy
Global Accuracy instance.
Definition: Accuracy.h:907
@ relaxed
Flag for relaxed semantics.
Definition: RelaxationFlag.h:68
BLAZE_ALWAYS_INLINE bool operator!=(const SIMDPack< T > &a, const SIMDPack< T > &b) noexcept
Inequality comparison of two SIMD vectors of the same type.
Definition: Equal.h:926
BLAZE_ALWAYS_INLINE bool operator==(const SIMDcdouble &a, const SIMDcdouble &b) noexcept=delete
Equality comparison of two vectors of double precision complex SIMD values.
#define BLAZE_ALWAYS_INLINE
Platform dependent setup of an enforced inline keyword.
Definition: Inline.h:85
System settings for the inline keywords.
System settings for the SSE mode.