Eu tenho um valor de ponto flutuante de entrada que é 0.0f <= valor <1.0f (note menos de um).

Ao multiplicar esse valor até um intervalo maior, naturalmente a precisão do ponto flutuante é diminuída, o que significa que o valor pode acabar fora do intervalo equivalente.

Por exemplo, se eu começar com um valor como:

0,99999983534521f

Então multiplique por 100, eu recebo:

100.000000000000f

O que é bom, mas como reduzo a representação de ponto flutuante para ser o valor de ponto flutuante mais próximo que ainda é menor que 100?

Eu encontrei este pequeno truque manual:

union test
{
    int integer;
    float floating;
};

test value;

value.floating = 1.0f;

printf("%x\n", value.integer);

Então eu peguei esse valor hexadecimal e o reduzi por um dígito hexadecimal, então configurei explicitamente da seguinte forma:

unsigned int almost_one = 0x3f7fffff;

float value = 1.0f;

if (value >= 1.0f)      std::memcpy(&value, &almost_one, sizeof(float));

Isso funciona bem para esse valor específico, mas existe uma abordagem mais geral que eu possa usar?

Eu estou esperando que haja uma instrução mágica que eu não esteja ciente de que eu possa usar para conseguir isso!

Edit: Grande conjunto de respostas aqui, std :: nextafter se parece com o que eu estou depois. Infelizmente ainda não consigo usar bibliotecas matemáticas do C ++ 11, então isso não funcionará para mim. Para salvar coisas complicadas, vou marcar essa questão com o C ++ 11 e aceitar a resposta do Mike abaixo.

Eu comecei uma nova pergunta para o C ++ 03:Alternativa para o std :: nextafter do C ++ 11 e std :: nexttoward para C ++ 03?