Infinito negativo

Question

Estoy tratando de descubrir cómo asignar el valor de infinito negativo a una variable flotante o doble.Parece que incluyendo los límites de la biblioteca estándar, puedo obtener la representación infinita, y sé (con bastante seguridad) que agregar un signo menos delante de eso (-infinito) podría dar como resultado el valor que estoy buscando en el punto flotante IEEE754. estándar (ya que 0x7FFFFFFF podría resultar en 0xFFFFFFFF), pero ni siquiera estoy seguro de eso, sin mencionar otros estándares que podrían existir (si los hay).Lo encuentro realmente poco profesional y dependiente de la implementación.

¿Existe una buena manera de obtener el valor de la plataforma infinita negativa y la implementación de forma independiente? Por supuesto, de lo contrario, también podría usar #define, a todos les gusta el preprocesamiento.

Answer 1

al menos si std :: numeric_limits :: is_iec559 (IEEE 754) es cierto (lo que garantiza, que std :: numeric_limits :: has_infinity También es cierto), puede expresar valores infinitos positivos y negativos de la forma en que ya declaró.

Breve explicación de los valores infinitos de IEEE 754-1985 de wikipedia :

...... snip ......

El campo exponente sesgado se llena con todos los 1 bits para indicar cualquiera de los dos infinito o un resultado no válido de un cálculo.

infinito positivo y negativo

El infinito positivo y negativo se representa así:

 sign = 0 for positive infinity, 1 for negative infinity.
 biased exponent = all 1 bits.
 fraction = all 0 bits.

...... snip ......

Afirmaciones

El siguiente ejemplo funcionará como se esperaba, o causará un error de tiempo de compilación en caso de que la plataforma de destino no sea compatible con los flotadores IEEE 754.

#include <cstdlib>
#include <cmath>
#include <cassert>
#include <limits>

int main(void)
{
    //Asserts floating point compatibility at compile time
    static_assert(std::numeric_limits<float>::is_iec559, "IEEE 754 required");

    //C99
    float negative_infinity1 = -INFINITY;
    float negative_infinity2 = -1 * INFINITY;

    float negative_infinity3 = -std::numeric_limits<float>::infinity();
    float negative_infinity4 = -1 * std::numeric_limits<float>::infinity();

    assert(std::isinf(negative_infinity1) && negative_infinity1 < std::numeric_limits<float>::lowest());
    assert(std::isinf(negative_infinity2) && negative_infinity2 < std::numeric_limits<float>::lowest());
    assert(std::isinf(negative_infinity3) && negative_infinity3 < std::numeric_limits<float>::lowest());
    assert(std::isinf(negative_infinity4) && negative_infinity4 < std::numeric_limits<float>::lowest());

    return EXIT_SUCCESS;
}

Answer 2

Si std::numeric_limits<double>::is_iec559 es true entonces debería ser seguro de usar.

double negative_infinity = - std::numeric_limits<double>::infinity();

(IEC559 es el equivalente ISO de IEEE754)

Si es false entonces hay mucho más trabajo por hacer ya que no creo que el estándar C++ le brinde ninguna ayuda.

Answer 3

No sé qué compilador estás usando, pero puedes usar -std::numeric_limits<double>::infinity() en gcc y MinGw ver Infinito y NaN.También ejecuté el siguiente código en MSVC y devolvió verdadero:

double infinity(std::numeric_limits<double>::infinity());
double neg_infinity(-std::numeric_limits<double>::infinity());
double lowest(std::numeric_limits<double>::lowest());

bool lower_than_lowest(neg_infinity < lowest);
std::cout << "lower_than_lowest: " << lower_than_lowest << std::endl;

Sin embargo, tal vez valga la pena considerar usar el valor más bajo en su aplicación en lugar de infinito negativo, ya que probablemente dará como resultado una solución más portátil.