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

NAME
     std::isgreater - std::isgreater

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

	bool isgreater( long double x, long double y );
	constexpr bool isgreater( /* 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 isgreater( Arithmetic1 x, Arithmetic2 y ); 	      (constexpr
     since C++23)

	1)  Determines if the floating point number x is greater than the float-
     ing-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, false otherwise.

Notes
	The built-in operator> for floating-point numbers may set FE_INVALID  if
     one or both
	of  the  arguments  is NaN. This function is a "quiet" version of opera-
     tor>.

	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::isgreater(num1,
	    num2) has the same effect as std::isgreater(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::isgreater(num1,   num2)   has	the   same   effect   as
     (until C++23)
	    std::isgreater(static_cast<double>(num1),
			   static_cast<double>(num2)).
	  * Otherwise, if num1 or num2 has type float, then
	    std::isgreater(num1, num2) has the same effect as
	    std::isgreater(static_cast<float>(num1),
			   static_cast<float>(num2)).
	If num1 and num2 have arithmetic types, then std::isgreater(num1,
	num2) has the same effect as std::isgreater(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	num1  and  num2,
     (since C++23)
	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
	greater function object implementing x > y
		(class template)
	isless	 checks  if  the  first floating-point argument is less than the
     second
	(C++11) (function)
	C documentation for
	isgreater

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