33#pragma GCC system_header
35#if __cplusplus > 201703L && __cpp_impl_three_way_comparison >= 201907L
40# define __cpp_lib_three_way_comparison 201907L
43namespace std _GLIBCXX_VISIBILITY(default)
49 using type =
signed char;
51 enum class _Ord : type { equivalent = 0, less = -1, greater = 1 };
53 enum class _Ncmp : type { _Unordered = 2 };
57 constexpr __unspec(__unspec*)
noexcept { }
61 class partial_ordering
64 __cmp_cat::type _M_value;
67 partial_ordering(__cmp_cat::_Ord __v) noexcept
68 : _M_value(__cmp_cat::type(__v))
72 partial_ordering(__cmp_cat::_Ncmp __v) noexcept
73 : _M_value(__cmp_cat::type(__v))
76 friend class weak_ordering;
77 friend class strong_ordering;
81 static const partial_ordering less;
82 static const partial_ordering equivalent;
83 static const partial_ordering greater;
84 static const partial_ordering unordered;
89 operator==(partial_ordering __v, __cmp_cat::__unspec)
noexcept
90 {
return __v._M_value == 0; }
94 operator==(partial_ordering, partial_ordering)
noexcept =
default;
98 operator< (partial_ordering __v, __cmp_cat::__unspec)
noexcept
99 {
return __v._M_value == -1; }
102 friend constexpr bool
103 operator> (partial_ordering __v, __cmp_cat::__unspec)
noexcept
104 {
return __v._M_value == 1; }
107 friend constexpr bool
108 operator<=(partial_ordering __v, __cmp_cat::__unspec)
noexcept
109 {
return __v._M_value <= 0; }
112 friend constexpr bool
113 operator>=(partial_ordering __v, __cmp_cat::__unspec)
noexcept
114 {
return __cmp_cat::type(__v._M_value & 1) == __v._M_value; }
117 friend constexpr bool
118 operator< (__cmp_cat::__unspec, partial_ordering __v)
noexcept
119 {
return __v._M_value == 1; }
122 friend constexpr bool
123 operator> (__cmp_cat::__unspec, partial_ordering __v)
noexcept
124 {
return __v._M_value == -1; }
127 friend constexpr bool
128 operator<=(__cmp_cat::__unspec, partial_ordering __v)
noexcept
129 {
return __cmp_cat::type(__v._M_value & 1) == __v._M_value; }
132 friend constexpr bool
133 operator>=(__cmp_cat::__unspec, partial_ordering __v)
noexcept
134 {
return 0 >= __v._M_value; }
137 friend constexpr partial_ordering
138 operator<=>(partial_ordering __v, __cmp_cat::__unspec)
noexcept
142 friend constexpr partial_ordering
143 operator<=>(__cmp_cat::__unspec, partial_ordering __v)
noexcept
145 if (__v._M_value & 1)
146 return partial_ordering(__cmp_cat::_Ord(-__v._M_value));
153 inline constexpr partial_ordering
154 partial_ordering::less(__cmp_cat::_Ord::less);
156 inline constexpr partial_ordering
157 partial_ordering::equivalent(__cmp_cat::_Ord::equivalent);
159 inline constexpr partial_ordering
160 partial_ordering::greater(__cmp_cat::_Ord::greater);
162 inline constexpr partial_ordering
163 partial_ordering::unordered(__cmp_cat::_Ncmp::_Unordered);
167 __cmp_cat::type _M_value;
170 weak_ordering(__cmp_cat::_Ord __v) noexcept : _M_value(__cmp_cat::type(__v))
173 friend class strong_ordering;
177 static const weak_ordering less;
178 static const weak_ordering equivalent;
179 static const weak_ordering greater;
182 constexpr operator partial_ordering() const noexcept
183 {
return partial_ordering(__cmp_cat::_Ord(_M_value)); }
187 friend constexpr bool
188 operator==(weak_ordering __v, __cmp_cat::__unspec)
noexcept
189 {
return __v._M_value == 0; }
192 friend constexpr bool
193 operator==(weak_ordering, weak_ordering)
noexcept =
default;
196 friend constexpr bool
197 operator< (weak_ordering __v, __cmp_cat::__unspec)
noexcept
198 {
return __v._M_value < 0; }
201 friend constexpr bool
202 operator> (weak_ordering __v, __cmp_cat::__unspec)
noexcept
203 {
return __v._M_value > 0; }
206 friend constexpr bool
207 operator<=(weak_ordering __v, __cmp_cat::__unspec)
noexcept
208 {
return __v._M_value <= 0; }
211 friend constexpr bool
212 operator>=(weak_ordering __v, __cmp_cat::__unspec)
noexcept
213 {
return __v._M_value >= 0; }
216 friend constexpr bool
217 operator< (__cmp_cat::__unspec, weak_ordering __v)
noexcept
218 {
return 0 < __v._M_value; }
221 friend constexpr bool
222 operator> (__cmp_cat::__unspec, weak_ordering __v)
noexcept
223 {
return 0 > __v._M_value; }
226 friend constexpr bool
227 operator<=(__cmp_cat::__unspec, weak_ordering __v)
noexcept
228 {
return 0 <= __v._M_value; }
231 friend constexpr bool
232 operator>=(__cmp_cat::__unspec, weak_ordering __v)
noexcept
233 {
return 0 >= __v._M_value; }
236 friend constexpr weak_ordering
237 operator<=>(weak_ordering __v, __cmp_cat::__unspec)
noexcept
241 friend constexpr weak_ordering
242 operator<=>(__cmp_cat::__unspec, weak_ordering __v)
noexcept
243 {
return weak_ordering(__cmp_cat::_Ord(-__v._M_value)); }
247 inline constexpr weak_ordering
248 weak_ordering::less(__cmp_cat::_Ord::less);
250 inline constexpr weak_ordering
251 weak_ordering::equivalent(__cmp_cat::_Ord::equivalent);
253 inline constexpr weak_ordering
254 weak_ordering::greater(__cmp_cat::_Ord::greater);
256 class strong_ordering
258 __cmp_cat::type _M_value;
261 strong_ordering(__cmp_cat::_Ord __v) noexcept
262 : _M_value(__cmp_cat::type(__v))
267 static const strong_ordering less;
268 static const strong_ordering equal;
269 static const strong_ordering equivalent;
270 static const strong_ordering greater;
273 constexpr operator partial_ordering() const noexcept
274 {
return partial_ordering(__cmp_cat::_Ord(_M_value)); }
277 constexpr operator weak_ordering() const noexcept
278 {
return weak_ordering(__cmp_cat::_Ord(_M_value)); }
282 friend constexpr bool
283 operator==(strong_ordering __v, __cmp_cat::__unspec)
noexcept
284 {
return __v._M_value == 0; }
287 friend constexpr bool
288 operator==(strong_ordering, strong_ordering)
noexcept =
default;
291 friend constexpr bool
292 operator< (strong_ordering __v, __cmp_cat::__unspec)
noexcept
293 {
return __v._M_value < 0; }
296 friend constexpr bool
297 operator> (strong_ordering __v, __cmp_cat::__unspec)
noexcept
298 {
return __v._M_value > 0; }
301 friend constexpr bool
302 operator<=(strong_ordering __v, __cmp_cat::__unspec)
noexcept
303 {
return __v._M_value <= 0; }
306 friend constexpr bool
307 operator>=(strong_ordering __v, __cmp_cat::__unspec)
noexcept
308 {
return __v._M_value >= 0; }
311 friend constexpr bool
312 operator< (__cmp_cat::__unspec, strong_ordering __v)
noexcept
313 {
return 0 < __v._M_value; }
316 friend constexpr bool
317 operator> (__cmp_cat::__unspec, strong_ordering __v)
noexcept
318 {
return 0 > __v._M_value; }
321 friend constexpr bool
322 operator<=(__cmp_cat::__unspec, strong_ordering __v)
noexcept
323 {
return 0 <= __v._M_value; }
326 friend constexpr bool
327 operator>=(__cmp_cat::__unspec, strong_ordering __v)
noexcept
328 {
return 0 >= __v._M_value; }
331 friend constexpr strong_ordering
332 operator<=>(strong_ordering __v, __cmp_cat::__unspec)
noexcept
336 friend constexpr strong_ordering
337 operator<=>(__cmp_cat::__unspec, strong_ordering __v)
noexcept
338 {
return strong_ordering(__cmp_cat::_Ord(-__v._M_value)); }
342 inline constexpr strong_ordering
343 strong_ordering::less(__cmp_cat::_Ord::less);
345 inline constexpr strong_ordering
346 strong_ordering::equal(__cmp_cat::_Ord::equivalent);
348 inline constexpr strong_ordering
349 strong_ordering::equivalent(__cmp_cat::_Ord::equivalent);
351 inline constexpr strong_ordering
352 strong_ordering::greater(__cmp_cat::_Ord::greater);
358 is_eq(partial_ordering __cmp)
noexcept
359 {
return __cmp == 0; }
363 is_neq(partial_ordering __cmp)
noexcept
364 {
return __cmp != 0; }
368 is_lt (partial_ordering __cmp)
noexcept
369 {
return __cmp < 0; }
373 is_lteq(partial_ordering __cmp)
noexcept
374 {
return __cmp <= 0; }
378 is_gt (partial_ordering __cmp)
noexcept
379 {
return __cmp > 0; }
383 is_gteq(partial_ordering __cmp)
noexcept
384 {
return __cmp >= 0; }
388 template<
typename _Tp>
389 inline constexpr unsigned __cmp_cat_id = 1;
391 inline constexpr unsigned __cmp_cat_id<partial_ordering> = 2;
393 inline constexpr unsigned __cmp_cat_id<weak_ordering> = 4;
395 inline constexpr unsigned __cmp_cat_id<strong_ordering> = 8;
397 template<
typename... _Ts>
398 constexpr auto __common_cmp_cat()
400 constexpr unsigned __cats = (__cmp_cat_id<_Ts> | ...);
402 if constexpr (__cats & 1)
406 else if constexpr (bool(__cats & __cmp_cat_id<partial_ordering>))
407 return partial_ordering::equivalent;
410 else if constexpr (bool(__cats & __cmp_cat_id<weak_ordering>))
411 return weak_ordering::equivalent;
414 return strong_ordering::equivalent;
419 template<
typename... _Ts>
420 struct common_comparison_category
422 using type =
decltype(__detail::__common_cmp_cat<_Ts...>());
427 template<
typename _Tp>
428 struct common_comparison_category<_Tp>
429 {
using type = void; };
432 struct common_comparison_category<partial_ordering>
433 {
using type = partial_ordering; };
436 struct common_comparison_category<weak_ordering>
437 {
using type = weak_ordering; };
440 struct common_comparison_category<strong_ordering>
441 {
using type = strong_ordering; };
444 struct common_comparison_category<>
445 {
using type = strong_ordering; };
447 template<
typename... _Ts>
448 using common_comparison_category_t
449 =
typename common_comparison_category<_Ts...>::type;
451#if __cpp_lib_concepts
454 template<
typename _Tp,
typename _Cat>
455 concept __compares_as
456 = same_as<common_comparison_category_t<_Tp, _Cat>, _Cat>;
460 template<
typename _Tp,
typename _Cat = partial_ordering>
461 concept three_way_comparable
462 = __detail::__weakly_eq_cmp_with<_Tp, _Tp>
463 && __detail::__partially_ordered_with<_Tp, _Tp>
464 &&
requires(
const remove_reference_t<_Tp>& __a,
465 const remove_reference_t<_Tp>& __b)
467 { __a <=> __b } -> __detail::__compares_as<_Cat>;
470 template<
typename _Tp,
typename _Up,
typename _Cat = partial_ordering>
471 concept three_way_comparable_with
472 = three_way_comparable<_Tp, _Cat>
473 && three_way_comparable<_Up, _Cat>
474 && common_reference_with<const remove_reference_t<_Tp>&,
475 const remove_reference_t<_Up>&>
476 && three_way_comparable<
477 common_reference_t<const remove_reference_t<_Tp>&,
478 const remove_reference_t<_Up>&>, _Cat>
479 && __detail::__weakly_eq_cmp_with<_Tp, _Up>
480 && __detail::__partially_ordered_with<_Tp, _Up>
481 &&
requires(
const remove_reference_t<_Tp>& __t,
482 const remove_reference_t<_Up>& __u)
484 { __t <=> __u } -> __detail::__compares_as<_Cat>;
485 { __u <=> __t } -> __detail::__compares_as<_Cat>;
490 template<
typename _Tp,
typename _Up>
491 using __cmp3way_res_t
492 =
decltype(std::declval<_Tp>() <=> std::declval<_Up>());
499 template<
typename _Tp,
typename _Up>
500 struct __cmp3way_res_impl
503 template<
typename _Tp,
typename _Up>
504 requires requires {
typename __cmp3way_res_t<__cref<_Tp>, __cref<_Up>>; }
505 struct __cmp3way_res_impl<_Tp, _Up>
507 using type = __cmp3way_res_t<__cref<_Tp>, __cref<_Up>>;
512 template<
typename _Tp,
typename _Up = _Tp>
514 : __detail::__cmp3way_res_impl<_Tp, _Up>
518 template<
typename _Tp,
typename _Up = _Tp>
520 =
typename __detail::__cmp3way_res_impl<_Tp, _Up>::type;
528 template<
typename _Tp,
typename _Up>
529 concept __3way_builtin_ptr_cmp
530 =
requires(_Tp&& __t, _Up&& __u)
531 {
static_cast<_Tp&&
>(__t) <=>
static_cast<_Up&&
>(__u); }
534 && !
requires(_Tp&& __t, _Up&& __u)
535 { operator<=>(
static_cast<_Tp&&
>(__t),
static_cast<_Up&&
>(__u)); }
536 && !
requires(_Tp&& __t, _Up&& __u)
537 {
static_cast<_Tp&&
>(__t).operator<=>(
static_cast<_Up&&
>(__u)); };
544 struct compare_three_way
546 template<
typename _Tp,
typename _Up>
547 requires three_way_comparable_with<_Tp, _Up>
549 operator() [[nodiscard]] (_Tp&& __t, _Up&& __u)
const
550 noexcept(
noexcept(std::declval<_Tp>() <=> std::declval<_Up>()))
552 if constexpr (__detail::__3way_builtin_ptr_cmp<_Tp, _Up>)
554 auto __pt =
static_cast<const volatile void*
>(__t);
555 auto __pu =
static_cast<const volatile void*
>(__u);
556 if (std::__is_constant_evaluated())
557 return __pt <=> __pu;
558 auto __it =
reinterpret_cast<__UINTPTR_TYPE__
>(__pt);
559 auto __iu =
reinterpret_cast<__UINTPTR_TYPE__
>(__pu);
560 return __it <=> __iu;
563 return static_cast<_Tp&&
>(__t) <=>
static_cast<_Up&&
>(__u);
566 using is_transparent = void;
571 template<
floating_po
int _Tp>
572 constexpr weak_ordering
573 __fp_weak_ordering(_Tp __e, _Tp __f)
577 auto __cat = [](_Tp __fp) ->
int {
578 const int __sign = __builtin_signbit(__fp) ? -1 : 1;
579 if (__builtin_isnormal(__fp))
580 return (__fp == 0 ? 1 : 3) * __sign;
581 if (__builtin_isnan(__fp))
583 if (
int __inf = __builtin_isinf_sign(__fp))
588 auto __po = __e <=> __f;
590 return weak_ordering::less;
591 else if (is_gt(__po))
592 return weak_ordering::greater;
593 else if (__po == partial_ordering::equivalent)
594 return weak_ordering::equivalent;
598 auto __isnan_sign = [](_Tp __fp) ->
int {
599 return __builtin_isnan(__fp)
600 ? __builtin_signbit(__fp) ? -1 : 1
603 auto __ord = __isnan_sign(__e) <=> __isnan_sign(__f);
605 return weak_ordering::equivalent;
606 else if (is_lt(__ord))
607 return weak_ordering::less;
609 return weak_ordering::greater;
613 template<
typename _Tp,
typename _Up>
614 concept __adl_strong =
requires(_Tp&& __t, _Up&& __u)
616 strong_ordering(strong_order(
static_cast<_Tp&&
>(__t),
617 static_cast<_Up&&
>(__u)));
620 template<
typename _Tp,
typename _Up>
621 concept __adl_weak =
requires(_Tp&& __t, _Up&& __u)
623 weak_ordering(weak_order(
static_cast<_Tp&&
>(__t),
624 static_cast<_Up&&
>(__u)));
627 template<
typename _Tp,
typename _Up>
628 concept __adl_partial =
requires(_Tp&& __t, _Up&& __u)
630 partial_ordering(partial_order(
static_cast<_Tp&&
>(__t),
631 static_cast<_Up&&
>(__u)));
634 template<
typename _Ord,
typename _Tp,
typename _Up>
635 concept __cmp3way =
requires(_Tp&& __t, _Up&& __u, compare_three_way __c)
637 _Ord(__c(
static_cast<_Tp&&
>(__t),
static_cast<_Up&&
>(__u)));
640 template<
typename _Tp,
typename _Up>
641 concept __strongly_ordered
642 = __adl_strong<_Tp, _Up>
643 || floating_point<remove_reference_t<_Tp>>
644 || __cmp3way<strong_ordering, _Tp, _Up>;
646 template<
typename _Tp,
typename _Up>
647 concept __decayed_same_as = same_as<decay_t<_Tp>, decay_t<_Up>>;
651 template<
typename _Tp,
typename _Up>
652 static constexpr bool
655 if constexpr (floating_point<decay_t<_Tp>>)
657 else if constexpr (__adl_strong<_Tp, _Up>)
658 return noexcept(strong_ordering(strong_order(std::declval<_Tp>(),
659 std::declval<_Up>())));
660 else if constexpr (__cmp3way<strong_ordering, _Tp, _Up>)
661 return noexcept(compare_three_way()(std::declval<_Tp>(),
662 std::declval<_Up>()));
665 friend class _Weak_order;
666 friend class _Strong_fallback;
671 _Binary16, _Binary32, _Binary64, _Binary128,
678#ifndef __cpp_using_enum
680 static constexpr _Fp_fmt _Binary16 = _Fp_fmt::_Binary16;
681 static constexpr _Fp_fmt _Binary32 = _Fp_fmt::_Binary32;
682 static constexpr _Fp_fmt _Binary64 = _Fp_fmt::_Binary64;
683 static constexpr _Fp_fmt _Binary128 = _Fp_fmt::_Binary128;
684 static constexpr _Fp_fmt _X86_80bit = _Fp_fmt::_X86_80bit;
685 static constexpr _Fp_fmt _M68k_80bit = _Fp_fmt::_M68k_80bit;
686 static constexpr _Fp_fmt _Dbldbl = _Fp_fmt::_Dbldbl;
690 template<
typename _Tp>
691 static consteval _Fp_fmt
694#ifdef __cpp_using_enum
701#ifdef __LONG_DOUBLE_IBM128__
702 if constexpr (__is_same(_Tp,
long double))
704#elif defined __LONG_DOUBLE_IEEE128__ && defined __SIZEOF_IBM128__
705 if constexpr (__is_same(_Tp, __ibm128))
709#if __LDBL_MANT_DIG__ == 64
710 if constexpr (__is_same(_Tp,
long double))
711 return __LDBL_MIN_EXP__ == -16381 ? _X86_80bit : _M68k_80bit;
713#ifdef __SIZEOF_FLOAT80__
714 if constexpr (__is_same(_Tp, __float80))
718 constexpr int __width =
sizeof(_Tp) * __CHAR_BIT__;
720 if constexpr (__width == 16)
722 else if constexpr (__width == 32)
724 else if constexpr (__width == 64)
726 else if constexpr (__width == 128)
731 using int64_t = __INT64_TYPE__;
732 using int32_t = __INT32_TYPE__;
733 using int16_t = __INT16_TYPE__;
734 using uint64_t = __UINT64_TYPE__;
735 using uint16_t = __UINT16_TYPE__;
738 template<
typename _Tp>
741#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
750 _Int(_Tp __hi, uint64_t __lo) noexcept : _M_hi(__hi)
754 _Int(uint64_t __lo) noexcept : _M_hi(0)
757 constexpr bool operator==(
const _Int&)
const =
default;
759#if defined __hppa__ || (defined __mips__ && !defined __mips_nan2008)
764 return _Int(
static_cast<_Tp
>(_M_lo << (__n - 64)), 0);
769 operator^=(
const _Int& __rhs)
noexcept
771 _M_hi ^= __rhs._M_hi;
772 _M_lo ^= __rhs._M_lo;
776 constexpr strong_ordering
777 operator<=>(
const _Int& __rhs)
const noexcept
779 strong_ordering __cmp = _M_hi <=> __rhs._M_hi;
780 if (__cmp != strong_ordering::equal)
782 return _M_lo <=> __rhs._M_lo;
786 template<
typename _Tp>
788 _S_compl(_Tp __t)
noexcept
790 constexpr int __width =
sizeof(_Tp) * __CHAR_BIT__;
792 make_unsigned_t<_Tp> __sign = __t >> (__width - 1);
795 return __t ^ (__sign >> 1);
799 template<
typename _Tp>
800 static constexpr _Int<_Tp>
801 _S_compl(_Int<_Tp> __t)
noexcept
803 constexpr int __width =
sizeof(_Tp) * __CHAR_BIT__;
804 make_unsigned_t<_Tp> __sign = __t._M_hi >> (__width - 1);
805 __t._M_hi ^= (__sign >> 1 );
806 uint64_t __sign64 = (_Tp)__sign;
807 __t._M_lo ^= __sign64;
812 template<
typename _Tp>
813 constexpr static auto
814 _S_fp_bits(_Tp __val)
noexcept
816 if constexpr (
sizeof(_Tp) ==
sizeof(int64_t))
817 return __builtin_bit_cast(int64_t, __val);
818 else if constexpr (
sizeof(_Tp) ==
sizeof(int32_t))
819 return __builtin_bit_cast(int32_t, __val);
820 else if constexpr (
sizeof(_Tp) ==
sizeof(int16_t))
821 return __builtin_bit_cast(int16_t, __val);
824#ifdef __cpp_using_enum
827 constexpr auto __fmt = _S_fp_fmt<_Tp>();
828 if constexpr (__fmt == _X86_80bit || __fmt == _M68k_80bit)
830 if constexpr (
sizeof(_Tp) == 3 *
sizeof(int32_t))
832 auto __ival = __builtin_bit_cast(_Int<int32_t>, __val);
833 return _Int<int16_t>(__ival._M_hi, __ival._M_lo);
837 auto __ival = __builtin_bit_cast(_Int<int64_t>, __val);
838 return _Int<int16_t>(__ival._M_hi, __ival._M_lo);
841 else if constexpr (
sizeof(_Tp) == 2 *
sizeof(int64_t))
844 return __builtin_bit_cast(__int128, __val);
846 return __builtin_bit_cast(_Int<int64_t>, __val);
850 static_assert(
sizeof(_Tp) ==
sizeof(int64_t),
851 "unsupported floating-point type");
855 template<
typename _Tp>
856 static constexpr strong_ordering
857 _S_fp_cmp(_Tp __x, _Tp __y)
noexcept
860 if (__builtin_isnan(__x) || __builtin_isnan(__y))
862 int __ix = (bool) __builtin_isnan(__x);
863 int __iy = (bool) __builtin_isnan(__y);
864 __ix *= __builtin_signbit(__x) ? -1 : 1;
865 __iy *= __builtin_signbit(__y) ? -1 : 1;
866 return __ix <=> __iy;
869 return __builtin_bit_cast(strong_ordering, __x <=> __y);
872 auto __ix = _S_fp_bits(__x);
873 auto __iy = _S_fp_bits(__y);
876 return strong_ordering::equal;
878#ifdef __cpp_using_enum
881 constexpr auto __fmt = _S_fp_fmt<_Tp>();
883 if constexpr (__fmt == _Dbldbl)
887 struct _Unpacked {
double _M_hi; int64_t _M_lo; };
888 auto __x2 = __builtin_bit_cast(_Unpacked, __x);
889 auto __y2 = __builtin_bit_cast(_Unpacked, __y);
892 auto __cmp = _S_fp_cmp(__x2._M_hi, __y2._M_hi);
893 if (__cmp != strong_ordering::equal)
898 if (__builtin_isnan(__x2._M_hi))
899 return strong_ordering::equal;
902 if (((__x2._M_lo | __y2._M_lo) & 0x7fffffffffffffffULL) == 0)
903 return strong_ordering::equal;
906 return _S_compl(__x2._M_lo) <=> _S_compl(__y2._M_lo);
910 if constexpr (__fmt == _M68k_80bit)
915 constexpr uint16_t __maxexp = 0x7fff;
916 if ((__ix._M_hi & __maxexp) == __maxexp)
917 __ix._M_lo |= 1ull << 63;
918 if ((__iy._M_hi & __maxexp) == __maxexp)
919 __iy._M_lo |= 1ull << 63;
923#if defined __hppa__ || (defined __mips__ && !defined __mips_nan2008)
926 if (__builtin_isnan(__x) && __builtin_isnan(__y))
928 using _Int =
decltype(__ix);
930 constexpr int __nantype = __fmt == _Binary32 ? 22
931 : __fmt == _Binary64 ? 51
932 : __fmt == _Binary128 ? 111
934 constexpr _Int __bit = _Int(1) << __nantype;
940 return _S_compl(__ix) <=> _S_compl(__iy);
945 template<
typename _Tp, __decayed_same_as<_Tp> _Up>
946 requires __strongly_ordered<_Tp, _Up>
947 constexpr strong_ordering
948 operator() [[nodiscard]] (_Tp&& __e, _Up&& __f)
const
949 noexcept(_S_noexcept<_Tp, _Up>())
951 if constexpr (floating_point<decay_t<_Tp>>)
952 return _S_fp_cmp(__e, __f);
953 else if constexpr (__adl_strong<_Tp, _Up>)
954 return strong_ordering(strong_order(
static_cast<_Tp&&
>(__e),
955 static_cast<_Up&&
>(__f)));
956 else if constexpr (__cmp3way<strong_ordering, _Tp, _Up>)
957 return compare_three_way()(
static_cast<_Tp&&
>(__e),
958 static_cast<_Up&&
>(__f));
962 template<
typename _Tp,
typename _Up>
963 concept __weakly_ordered
964 = floating_point<remove_reference_t<_Tp>>
965 || __adl_weak<_Tp, _Up>
966 || __cmp3way<weak_ordering, _Tp, _Up>
967 || __strongly_ordered<_Tp, _Up>;
971 template<
typename _Tp,
typename _Up>
972 static constexpr bool
975 if constexpr (floating_point<decay_t<_Tp>>)
977 else if constexpr (__adl_weak<_Tp, _Up>)
978 return noexcept(weak_ordering(weak_order(std::declval<_Tp>(),
979 std::declval<_Up>())));
980 else if constexpr (__cmp3way<weak_ordering, _Tp, _Up>)
981 return noexcept(compare_three_way()(std::declval<_Tp>(),
982 std::declval<_Up>()));
983 else if constexpr (__strongly_ordered<_Tp, _Up>)
984 return _Strong_order::_S_noexcept<_Tp, _Up>();
987 friend class _Partial_order;
988 friend class _Weak_fallback;
991 template<
typename _Tp, __decayed_same_as<_Tp> _Up>
992 requires __weakly_ordered<_Tp, _Up>
993 constexpr weak_ordering
994 operator() [[nodiscard]] (_Tp&& __e, _Up&& __f)
const
995 noexcept(_S_noexcept<_Tp, _Up>())
997 if constexpr (floating_point<decay_t<_Tp>>)
998 return __cmp_cust::__fp_weak_ordering(__e, __f);
999 else if constexpr (__adl_weak<_Tp, _Up>)
1000 return weak_ordering(weak_order(
static_cast<_Tp&&
>(__e),
1001 static_cast<_Up&&
>(__f)));
1002 else if constexpr (__cmp3way<weak_ordering, _Tp, _Up>)
1003 return compare_three_way()(
static_cast<_Tp&&
>(__e),
1004 static_cast<_Up&&
>(__f));
1005 else if constexpr (__strongly_ordered<_Tp, _Up>)
1006 return _Strong_order{}(
static_cast<_Tp&&
>(__e),
1007 static_cast<_Up&&
>(__f));
1011 template<
typename _Tp,
typename _Up>
1012 concept __partially_ordered
1013 = __adl_partial<_Tp, _Up>
1014 || __cmp3way<partial_ordering, _Tp, _Up>
1015 || __weakly_ordered<_Tp, _Up>;
1017 class _Partial_order
1019 template<
typename _Tp,
typename _Up>
1020 static constexpr bool
1023 if constexpr (__adl_partial<_Tp, _Up>)
1024 return noexcept(partial_ordering(partial_order(std::declval<_Tp>(),
1025 std::declval<_Up>())));
1026 else if constexpr (__cmp3way<partial_ordering, _Tp, _Up>)
1027 return noexcept(compare_three_way()(std::declval<_Tp>(),
1028 std::declval<_Up>()));
1029 else if constexpr (__weakly_ordered<_Tp, _Up>)
1030 return _Weak_order::_S_noexcept<_Tp, _Up>();
1033 friend class _Partial_fallback;
1036 template<
typename _Tp, __decayed_same_as<_Tp> _Up>
1037 requires __partially_ordered<_Tp, _Up>
1038 constexpr partial_ordering
1039 operator() [[nodiscard]] (_Tp&& __e, _Up&& __f)
const
1040 noexcept(_S_noexcept<_Tp, _Up>())
1042 if constexpr (__adl_partial<_Tp, _Up>)
1043 return partial_ordering(partial_order(
static_cast<_Tp&&
>(__e),
1044 static_cast<_Up&&
>(__f)));
1045 else if constexpr (__cmp3way<partial_ordering, _Tp, _Up>)
1046 return compare_three_way()(
static_cast<_Tp&&
>(__e),
1047 static_cast<_Up&&
>(__f));
1048 else if constexpr (__weakly_ordered<_Tp, _Up>)
1049 return _Weak_order{}(
static_cast<_Tp&&
>(__e),
1050 static_cast<_Up&&
>(__f));
1054 template<
typename _Tp,
typename _Up>
1055 concept __op_eq_lt =
requires(_Tp&& __t, _Up&& __u)
1057 {
static_cast<_Tp&&
>(__t) ==
static_cast<_Up&&
>(__u) }
1058 -> convertible_to<bool>;
1059 {
static_cast<_Tp&&
>(__t) <
static_cast<_Up&&
>(__u) }
1060 -> convertible_to<bool>;
1063 class _Strong_fallback
1065 template<
typename _Tp,
typename _Up>
1066 static constexpr bool
1069 if constexpr (__strongly_ordered<_Tp, _Up>)
1070 return _Strong_order::_S_noexcept<_Tp, _Up>();
1072 return noexcept(bool(std::declval<_Tp>() == std::declval<_Up>()))
1073 &&
noexcept(
bool(std::declval<_Tp>() < std::declval<_Up>()));
1077 template<
typename _Tp, __decayed_same_as<_Tp> _Up>
1078 requires __strongly_ordered<_Tp, _Up> || __op_eq_lt<_Tp, _Up>
1079 constexpr strong_ordering
1080 operator() [[nodiscard]] (_Tp&& __e, _Up&& __f)
const
1081 noexcept(_S_noexcept<_Tp, _Up>())
1083 if constexpr (__strongly_ordered<_Tp, _Up>)
1084 return _Strong_order{}(
static_cast<_Tp&&
>(__e),
1085 static_cast<_Up&&
>(__f));
1087 return static_cast<_Tp&&
>(__e) ==
static_cast<_Up&&
>(__f)
1088 ? strong_ordering::equal
1089 :
static_cast<_Tp&&
>(__e) <
static_cast<_Up&&
>(__f)
1090 ? strong_ordering::less
1091 : strong_ordering::greater;
1095 class _Weak_fallback
1097 template<
typename _Tp,
typename _Up>
1098 static constexpr bool
1101 if constexpr (__weakly_ordered<_Tp, _Up>)
1102 return _Weak_order::_S_noexcept<_Tp, _Up>();
1104 return noexcept(bool(std::declval<_Tp>() == std::declval<_Up>()))
1105 &&
noexcept(
bool(std::declval<_Tp>() < std::declval<_Up>()));
1109 template<
typename _Tp, __decayed_same_as<_Tp> _Up>
1110 requires __weakly_ordered<_Tp, _Up> || __op_eq_lt<_Tp, _Up>
1111 constexpr weak_ordering
1112 operator() [[nodiscard]] (_Tp&& __e, _Up&& __f)
const
1113 noexcept(_S_noexcept<_Tp, _Up>())
1115 if constexpr (__weakly_ordered<_Tp, _Up>)
1116 return _Weak_order{}(
static_cast<_Tp&&
>(__e),
1117 static_cast<_Up&&
>(__f));
1119 return static_cast<_Tp&&
>(__e) ==
static_cast<_Up&&
>(__f)
1120 ? weak_ordering::equivalent
1121 :
static_cast<_Tp&&
>(__e) <
static_cast<_Up&&
>(__f)
1122 ? weak_ordering::less
1123 : weak_ordering::greater;
1129 template<
typename _Tp,
typename _Up>
1130 concept __op_eq_lt_lt = __op_eq_lt<_Tp, _Up>
1131 &&
requires(_Tp&& __t, _Up&& __u)
1133 {
static_cast<_Up&&
>(__u) <
static_cast<_Tp&&
>(__t) }
1134 -> convertible_to<bool>;
1137 class _Partial_fallback
1139 template<
typename _Tp,
typename _Up>
1140 static constexpr bool
1143 if constexpr (__partially_ordered<_Tp, _Up>)
1144 return _Partial_order::_S_noexcept<_Tp, _Up>();
1146 return noexcept(bool(std::declval<_Tp>() == std::declval<_Up>()))
1147 &&
noexcept(
bool(std::declval<_Tp>() < std::declval<_Up>()));
1151 template<
typename _Tp, __decayed_same_as<_Tp> _Up>
1152 requires __partially_ordered<_Tp, _Up> || __op_eq_lt_lt<_Tp, _Up>
1153 constexpr partial_ordering
1154 operator() [[nodiscard]] (_Tp&& __e, _Up&& __f)
const
1155 noexcept(_S_noexcept<_Tp, _Up>())
1157 if constexpr (__partially_ordered<_Tp, _Up>)
1158 return _Partial_order{}(
static_cast<_Tp&&
>(__e),
1159 static_cast<_Up&&
>(__f));
1161 return static_cast<_Tp&&
>(__e) ==
static_cast<_Up&&
>(__f)
1162 ? partial_ordering::equivalent
1163 :
static_cast<_Tp&&
>(__e) <
static_cast<_Up&&
>(__f)
1164 ? partial_ordering::less
1165 :
static_cast<_Up&&
>(__f) <
static_cast<_Tp&&
>(__e)
1166 ? partial_ordering::greater
1167 : partial_ordering::unordered;
1173 inline namespace __cmp_alg
1175 inline constexpr __cmp_cust::_Strong_order strong_order{};
1177 inline constexpr __cmp_cust::_Weak_order weak_order{};
1179 inline constexpr __cmp_cust::_Partial_order partial_order{};
1181 inline constexpr __cmp_cust::_Strong_fallback
1182 compare_strong_order_fallback{};
1184 inline constexpr __cmp_cust::_Weak_fallback
1185 compare_weak_order_fallback{};
1187 inline constexpr __cmp_cust::_Partial_fallback
1188 compare_partial_order_fallback{};
1194 inline constexpr struct _Synth3way
1196 template<
typename _Tp,
typename _Up>
1197 static constexpr bool
1198 _S_noexcept(
const _Tp* __t =
nullptr,
const _Up* __u =
nullptr)
1200 if constexpr (three_way_comparable_with<_Tp, _Up>)
1201 return noexcept(*__t <=> *__u);
1203 return noexcept(*__t < *__u) &&
noexcept(*__u < *__t);
1206 template<
typename _Tp,
typename _Up>
1209 operator()(
const _Tp& __t,
const _Up& __u)
const
1210 noexcept(_S_noexcept<_Tp, _Up>())
1213 { __t < __u } -> __boolean_testable;
1214 { __u < __t } -> __boolean_testable;
1217 if constexpr (three_way_comparable_with<_Tp, _Up>)
1222 return weak_ordering::less;
1224 return weak_ordering::greater;
1226 return weak_ordering::equivalent;
1232 template<
typename _Tp,
typename _Up = _Tp>
1234 =
decltype(__detail::__synth3way(std::declval<_Tp&>(),
1235 std::declval<_Up&>()));
ISO C++ entities toplevel namespace is std.
std::basic_ostream< _CharT, _Traits > & operator<<(std::basic_ostream< _CharT, _Traits > &__os, const bitset< _Nb > &__x)
Global I/O operators for bitsets.
typename __detail::__cmp3way_res_impl< _Tp, _Up >::type compare_three_way_result_t
[cmp.result], result of three-way comparison
[cmp.result], result of three-way comparison
[concept.convertible], concept convertible_to