Namespaces
Variants
Views
Actions

Difference between revisions of "cpp/numeric/math/isgreaterequal"

From cppreference.com
< cpp‎ | numeric‎ | math
m (typo)
(Applied P1467R9.)
 
(One intermediate revision by one user not shown)
Line 1: Line 1:
−
{{cpp/title|isgreaterequal}}
+
{{cpp/numeric/math/binary_is|isgreaterequal
−
{{cpp/numeric/math/navbar}}
+
|description= Determines if the floating point number {{c|x}} is greater than or equal to the floating-point number {{c|y}}, without setting floating-point exceptions.
−
{{dcl begin}}
+
|condition={{c|1=x >= y}}
−
{{dcl header | cmath}}
+
|note=
−
{{dcl | since=c++11 | num=1|
+
The built-in {{c/core|1=operator>=}} for floating-point numbers may raise {{lc|FE_INVALID}} if one or both of the arguments is NaN. This function is a "quiet" version of {{c/core|1=operator>=}}.
−
bool isgreaterequal( float x, float y );
+
 
}}
 
}}
−
{{dcl | since=c++11 | num=2|
 
−
bool isgreaterequal( double x, double y );
 
−
}}
 
−
{{dcl | since=c++11 | num=3|
 
−
bool isgreaterequal( long double x, long double y );
 
−
}}
 
−
{{dcl | since=c++11 | num=4|
 
−
bool isgreaterequal( Arithmetic x, Arithmetic y );
 
−
}}
 
−
{{dcl end}}
 
−
 
−
@1-3@ Determines if the floating point number {{tt|x}} is greater than or equal to the floating-point number {{tt|y}}, without setting floating-point exceptions.
 
−
@4@ A set of overloads or a function template for all combinations of arguments of arithmetic type not covered by {{v|1-3}}. If any argument has [[cpp/types/is_integral|integral type]], it is cast to {{c|double}}.
 
−
 
−
===Parameters===
 
−
{{par begin}}
 
−
{{par | x | floating point value}}
 
−
{{par | y | floating point value}}
 
−
{{par end}}
 
−
 
−
===Return value===
 
−
 
−
{{c|true}} if {{c|1=x >= y}}, {{c|false}} otherwise
 
−
 
−
===Notes===
 
−
The built-in {{c|1=operator>=}} for floating-point numbers may raise {{lc|FE_INVALID}} if one or both of the arguments is NaN. This function is a "quiet" version of {{c|1=operator>=}}.
 
  
 
===See also===
 
===See also===
−
 
 
{{dsc begin}}
 
{{dsc begin}}
−
{{dsc inc | cpp/utility/functional/dsc greater_equal}}
+
{{dsc inc|cpp/utility/functional/dsc greater_equal}}
−
{{dsc inc | cpp/numeric/math/dsc islessequal}}
+
{{dsc inc|cpp/numeric/math/dsc islessequal}}
−
{{dsc see c | c/numeric/math/isgreaterequal}}
+
{{dsc see c|c/numeric/math/isgreaterequal}}
 
{{dsc end}}
 
{{dsc end}}
  
−
[[de:cpp/numeric/math/isgreaterequal]]
+
{{langlinks|de|es|fr|it|ja|pt|ru|zh}}
−
[[es:cpp/numeric/math/isgreaterequal]]
+
−
[[fr:cpp/numeric/math/isgreaterequal]]
+
−
[[it:cpp/numeric/math/isgreaterequal]]
+
−
[[ja:cpp/numeric/math/isgreaterequal]]
+
−
[[pt:cpp/numeric/math/isgreaterequal]]
+
−
[[ru:cpp/numeric/math/isgreaterequal]]
+
−
[[zh:cpp/numeric/math/isgreaterequal]]
+

Latest revision as of 18:31, 20 March 2023

 
C++
 
Numerics library
Common mathematical functions
Mathematical special functions (C++17)
Mathematical constants (C++20)
Basic linear algebra algorithms (C++26)
Floating-point environment (C++11)
Complex numbers
Numeric array (valarray)
Pseudo-random number generation
Factor operations
(C++17)
(C++17)
Interpolations
(C++20)
(C++20)
Saturation arithmetic
(C++26)
(C++26)
(C++26)
(C++26)
(C++26)

Generic numeric operations
Bit operations
(C++20)    
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++20)
(C++23)
(C++20)
 
Common mathematical functions
Functions
Basic operations
(C++11)  
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)(C++11)(C++11)
Exponential functions
(C++11)
(C++11)

(C++11)
(C++11)
Power functions
(C++11)
(C++11)
Trigonometric and
hyperbolic functions
(C++11)
(C++11)
(C++11)

Error and gamma functions
(C++11)
(C++11)
(C++11)
(C++11)
Nearest integer floating point operations
(C++11)(C++11)(C++11)
(C++11)
(C++11)
(C++11)(C++11)(C++11)
Floating point manipulation functions
(C++11)(C++11)
(C++11)
(C++11)
(C++11)(C++11)
(C++11)
Classification and comparison
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
isgreaterequal
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Types
(C++11)
(C++11)
(C++11)
Macro constants
 
Defined in header <cmath>
(1)
bool isgreaterequal( float x, float y );

bool isgreaterequal( double x, double y );

bool isgreaterequal( long double x, long double y );
 (since C++11)
(until C++23)
constexpr bool isgreaterequal( /* floating-point-type */ x,
                               /* floating-point-type */ y );
 (since C++23)
Defined in header <cmath>
template< class Arithmetic1, class Arithmetic2 >
bool isgreaterequal( Arithmetic1 x, Arithmetic2 y );
 (A) (since C++11)
(constexpr since C++23)
1) Determines if the floating point number x is greater than or equal to 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.

Contents

[edit] Parameters

x, y - floating-point or integer values

[edit] Return value

true if x >= y, false otherwise.

[edit] Notes

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

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::isgreaterequal(num1, num2) has the same effect as std::isgreaterequal(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::isgreaterequal(num1, num2) has the same effect as std::isgreaterequal(static_cast<double>(num1),
                        static_cast<double>(num2))    .
  • Otherwise, if num1 or num2 has type float, then std::isgreaterequal(num1, num2) has the same effect as std::isgreaterequal(static_cast<float>(num1),
                        static_cast<float>(num2))    .
(until C++23)

If num1 and num2 have arithmetic types, then std::isgreaterequal(num1, num2) has the same effect as std::isgreaterequal(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, 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.

(since C++23)

[edit] See also

 function object implementing x >= y
(class template) [edit]
(C++11)
 checks if the first floating-point argument is less or equal than the second
(function) [edit]
C documentation for isgreaterequal
Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/numeric/math/isgreaterequal&oldid=149463"