home | help 
std::islessgreater(3)	       C++ Standard Libary	   std::islessgreater(3)

NAME
     std::islessgreater - std::islessgreater

Synopsis
	Defined in header <cmath>
	bool islessgreater( float x, float y );
								     (since
     C++11)
	bool  islessgreater(  double  x,  double  y );			  (until
     C++23)

	bool islessgreater( long double x, long double y );
	constexpr bool islessgreater( /* floating-point-type
	*/  x,							(1)	  (since
     C++23)
				      /* floating-point-type
	*/ y );
	Additional overloads
	Defined in header <cmath>
	template<  class  Arithmetic1,	class  Arithmetic2  >	      (A) (since
     C++11)
	bool islessgreater( Arithmetic1 x, Arithmetic2 y );	      (constexpr
     since C++23)

	1)  Determines	if  the  floating point number x is less than or greater
     than the
	floating-point number y, without setting floating-point exceptions.
	The library provides overloads	for  all  cv-unqualified  floating-point
     types as the
	type of the parameters x and y.
	(since C++23)
	A)  Additional	overloads  are	provided  for  all other combinations of
     arithmetic types.

Parameters
	x, y - floating-point or integer values

Return value
	true if x < y || x > y, false otherwise.

Notes
	The built-in operator< and  operator>  for  floating-point  numbers  may
     raise FE_INVALID
	if  one or both of the arguments is NaN. This function is a "quiet" ver-
     sion of the
	expression x < y || x > y.

	The additional overloads are not required to be provided exactly as (A).
     They only
	need to be sufficient to ensure that for their first argument  num1  and
     second
	argument num2:

	  * If num1 or num2 has type long double, then
	    std::islessgreater(num1, num2) has the same effect as
	    std::islessgreater(static_cast<long double>(num1),
			       static_cast<long double>(num2)).
	  * Otherwise, if num1 and/or num2 has type double or an integer type,
	    then   std::islessgreater(num1,   num2)   has  the	same  effect  as
     (until C++23)
	    std::islessgreater(static_cast<double>(num1),
			       static_cast<double>(num2)).
	  * Otherwise, if num1 or num2 has type float, then
	    std::islessgreater(num1, num2) has the same effect as
	    std::islessgreater(static_cast<float>(num1),
			       static_cast<float>(num2)).
	If num1 and num2 have arithmetic types, then std::islessgreater(num1,
	num2) has the same effect as std::islessgreater(static_cast</*
	common-floating-point-type */>(num1),
			   static_cast</* common-floating-point-type
	*/>(num2)), where /* common-floating-point-type */ is the
	floating-point type with the greatest floating-point conversion rank
	and greatest floating-point conversion	subrank  between  the  types  of
     (since C++23)
	num1 and num2, arguments of integer type are considered to have the
	same floating-point conversion rank as double.

	If no such floating-point type with the greatest rank and subrank
	exists, then overload resolution does not result in a usable candidate
	from the overloads provided.

See also
	isless	   checks  if the first floating-point argument is less than the
     second
	(C++11)   (function)
	isgreater checks if the first floating-point argument  is  greater  than
     the second
	(C++11)   (function)
	C documentation for
	islessgreater

http://cppreference.com 	   2024.06.10		   std::islessgreater(3)
home | help