isgreater, isgreaterequal, isless, islessequal, islessgreater, isunordered

Determina a relação de ordenação entre dois valores de vírgula flutuante.

Sintaxe

int isgreater(
   /* floating-point */ x,
   /* floating-point */ y
); /* C-only macro */

int isgreaterequal(
   /* floating-point */ x,
   /* floating-point */ y
); /* C-only macro */

int isless(
   /* floating-point */ x,
   /* floating-point */ y
); /* C-only macro */

int islessequal(
   /* floating-point */ x,
   /* floating-point */ y
); /* C-only macro */

int islessgreater(
   /* floating-point */ x,
   /* floating-point */ y
); /* C-only macro */

int isunordered(
   /* floating-point */ x,
   /* floating-point */ y
); /* C-only macro */

template <class FloatingType1, class FloatingType2>
inline bool isgreater(
   FloatingType1 x,
   FloatingType2 y
) throw(); /* C++-only template function */

template <class FloatingType1, class FloatingType2>
inline bool isgreaterequal(
   FloatingType1 x,
   FloatingType2 y
) throw(); /* C++-only template function */

template <class FloatingType1, class FloatingType2>
inline bool isless(
   FloatingType1 x,
   FloatingType2 y
) throw(); /* C++-only template function */

template <class FloatingType1, class FloatingType2>
inline bool islessequal(
   FloatingType1 x,
   FloatingType2 y
) throw(); /* C++-only template function */

template <class FloatingType1, class FloatingType2>
inline bool islessgreater(
   FloatingType1 x,
   FloatingType2 y
) throw(); /* C++-only template function */

template <class FloatingType1, class FloatingType2>
inline bool isunordered(
   FloatingType1 x,
   FloatingType2 y
) throw(); /* C++-only template function */

Parâmetros

x, y
Os valores de vírgula flutuante a comparar.

Valor de retorno

Em todas as comparações, as infinidades do mesmo sinal comparam-se como iguais. O infinito negativo é menor do que qualquer valor finito ou infinito positivo. O infinito positivo é maior do que qualquer valor finito ou infinito negativo. Os zeros são iguais independentemente do sinal. NaNs não são menores, iguais ou maiores do que qualquer valor, incluindo outro NaN.

Quando nenhum dos argumentos é um NaN, as macros de ordenação isgreater, isgreaterequal, islesse islessequal retornam um valor diferente de zero se a relação de ordenação especificada entre x e y for verdadeira. Essas macros retornam 0 se um ou ambos os argumentos forem NaNs ou se a relação de ordenação for falsa. As formas de função se comportam da mesma maneira, mas retornam true ou false.

A macro islessgreater retorna um valor diferente de zero se x e y não forem NaNs e x for menor ou maior que y. Ele retorna 0 se um ou ambos os argumentos forem NaNs, ou se os valores forem iguais. A forma de função se comporta da mesma maneira, mas retorna true ou false.

A macro isunordered retorna um valor diferente de zero se x, you ambos forem NaNs. Caso contrário, ele retorna 0. A forma de função se comporta da mesma maneira, mas retorna true ou false.

Comentários

Essas operações de comparação são implementadas como macros quando compiladas como C e como funções de modelo embutido quando compiladas como C++.

Requerimentos

Para obter mais informações sobre compatibilidade, consulte de compatibilidade .

Ver também

Suporte matemático e de ponto flutuante
isfinite, _finite, _finitef
isinf
isnan, _isnan, _isnanf
_fpclass, _fpclassf