¿Cómo se comparan los valores arbitrarios de coma flotante con el infinito?

Question

Básicamente quiero buscar el valor más pequeño (positivo) de un grupo de valores y necesito un valor predeterminado para compararlo con el primero. La suposición ingenua sería, ellos siempre comparan "menos que" (excepto NaN, pero no los consideremos) pero no estoy seguro.

Estoy usando el tipo float y creo que se puede suponer con seguridad que mi hardware objetivo implementa un valor de infinito.

Aquí hay un código de ejemplo:

auto leastValue = std::numeric_limits<float>::infinity(); 
for (auto i = something.begin(), e = something.end(); i != e; ++i) 
{ 
    auto value = (*i)->GetValue(); 
    if (value < leastValue) 
    { 
    leastValue = value; 
    } 
} 

Answer 1

para IEEE 754 flotadores, excepto NaN y el infinito, todo es menos que infinito. Lo más probable es que los tenga en su plataforma. Si eres paranoico, verifica con numeric_limits<float>::is_iec559. Si su plataforma no es conforme, use numeric_limits<float>::max(); si su secuencia no es vacía, no le dará un resultado incorrecto.

Answer 2

que apoyan comentario Michael Madsen: No es necesario un valor infinito para esta prueba,

tienda el primer valor de su grupo en una variable y luego comenzar su prueba con el segundo valor más del montón. (e incluso le ahorrará una prueba: P)

Answer 3

Creo que esto depende del comportamiento que espera si la secuencia está vacía. Si quiere infinito, su implementación está bien, de lo contrario debería usar el primer valor.

auto i = something.begin(); 
auto e = semething.end(); 
if (i == e) 
    throw std::exception("empty sequence"); 

auto leastValue = (*i)->GetValue(); 

for (++i; i != e; ++i) 
{ 
    auto value = (*i)->GetValue(); 
    if (value < leastValue) 
    { 
    leastValue = value; 
    } 
}