Blaze  3.6
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>
46 #include <blaze/system/Compiler.h>
47 #include <blaze/system/Inline.h>
49 
50 
51 namespace blaze {
52 
53 //=================================================================================================
54 //
55 // 8-BIT INTEGRAL SIMD TYPES
56 //
57 //=================================================================================================
58 
59 //*************************************************************************************************
70 template< bool RF // Relaxation flag
71  , typename T > // Type of both operands
72 BLAZE_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
88 
89 //*************************************************************************************************
90 
91 
92 //*************************************************************************************************
103 template< bool RF // Relaxation flag
104  , typename T > // Type of both operands
105 BLAZE_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
121 
122 //*************************************************************************************************
123 
124 //*************************************************************************************************
134 template< typename T > // Type of both operands
135 BLAZE_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 //*************************************************************************************************
152 template< typename T > // Type of both operands
153 BLAZE_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 //*************************************************************************************************
179 template< bool RF // Relaxation flag
180  , typename T > // Type of both operands
181 BLAZE_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
197 
198 //*************************************************************************************************
199 
200 
201 //*************************************************************************************************
212 template< bool RF // Relaxation flag
213  , typename T > // Type of both operands
214 BLAZE_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
230 
231 //*************************************************************************************************
232 
233 
234 //*************************************************************************************************
244 template< typename T > // Type of both operands
245 BLAZE_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 //*************************************************************************************************
262 template< typename T > // Type of both operands
263 BLAZE_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 //*************************************************************************************************
289 template< bool RF // Relaxation flag
290  , typename T > // Type of both operands
291 BLAZE_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
307 
308 //*************************************************************************************************
309 
310 
311 //*************************************************************************************************
322 template< bool RF // Relaxation flag
323  , typename T > // Type of both operands
324 BLAZE_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
340 
341 //*************************************************************************************************
342 
343 
344 //*************************************************************************************************
354 template< typename T > // Type of both operands
355 BLAZE_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 //*************************************************************************************************
372 template< typename T > // Type of both operands
373 BLAZE_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 //*************************************************************************************************
400 template< bool RF // Relaxation flag
401  , typename T > // Type of both operands
402 BLAZE_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
418 
419 //*************************************************************************************************
420 
421 
422 //*************************************************************************************************
433 template< bool RF // Relaxation flag
434  , typename T > // Type of both operands
435 BLAZE_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
451 
452 //*************************************************************************************************
453 
454 
455 //*************************************************************************************************
465 template< typename T > // Type of both operands
466 BLAZE_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 //*************************************************************************************************
483 template< typename T > // Type of both operands
484 BLAZE_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 //*************************************************************************************************
515 template< bool RF > // Relaxation flag
516 BLAZE_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
563 
564 //*************************************************************************************************
565 
566 
567 //*************************************************************************************************
583 template< bool RF > // Relaxation flag
584 BLAZE_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
631 
632 //*************************************************************************************************
633 
634 
635 //*************************************************************************************************
645 template< typename T1 // Type of the left-hand side operand
646  , typename T2 > // Type of the right-hand side operand
647 BLAZE_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 //*************************************************************************************************
678 BLAZE_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 //*************************************************************************************************
723 template< bool RF > // Relaxation flag
724 BLAZE_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
772 
773 //*************************************************************************************************
774 
775 
776 //*************************************************************************************************
792 template< bool RF > // Relaxation flag
793 BLAZE_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
841 
842 //*************************************************************************************************
843 
844 
845 //*************************************************************************************************
855 template< typename T1 // Type of the left-hand side operand
856  , typename T2 > // Type of the right-hand side operand
857 BLAZE_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 //*************************************************************************************************
888 BLAZE_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 //*************************************************************************************************
925 template< typename T > // Type of both operands
926 BLAZE_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.
Namespace of the Blaze C++ math library.
Definition: Blaze.h:58
#define BLAZE_ALWAYS_INLINE
Platform dependent setup of an enforced inline keyword.
Definition: Inline.h:85
constexpr bool operator==(const NegativeAccuracy< A > &lhs, const T &rhs)
Equality comparison between a NegativeAccuracy object and a floating point value.
Definition: Accuracy.h:253
Compiler-specific system settings.
Base class for all SIMD data types.The SIMDPack class template is a base class for all SIMD data type...
Definition: SIMDPack.h:63
decltype(auto) eval(const DenseMatrix< MT, SO > &dm)
Forces the evaluation of the given dense matrix expression dm.
Definition: DMatEvalExpr.h:786
constexpr bool operator!=(const NegativeAccuracy< A > &lhs, const T &rhs)
Inequality comparison between a NegativeAccuracy object and a floating point value.
Definition: Accuracy.h:293
Header file for the basic SIMD types.
Header file for the relaxation flag types.
constexpr bool relaxed
Relaxation flag for relaxed semantics.
Definition: RelaxationFlag.h:85
System settings for the SSE mode.
constexpr Accuracy accuracy
Global Accuracy instance.The blaze::accuracy instance can be used wherever a floating point data type...
Definition: Accuracy.h:907
System settings for the inline keywords.
bool equal(const SharedValue< T1 > &lhs, const SharedValue< T2 > &rhs)
Equality check for a two shared values.
Definition: SharedValue.h:342