Qual é o dobro mais próximo de 1.0, que não é 1.0?

Existe uma maneira de obter programaticamente o dobro que está mais próximo de 1.0, mas não é realmente 1.0?

Uma maneira rápida de fazer isso seria memorizar o dobro em um número inteiro do mesmo tamanho e, em seguida, subtrair um. Da forma como os formatos de ponto flutuante IEEE754 funcionam, isso acabaria diminuindo o expoente em um enquanto mudava a parte fracionária de todos os zeros (1.000000000000) para todos os uns (1.111111111111). No entanto, existem máquinas onde inteiros são armazenados little-endian, enquanto o ponto flutuante é armazenado big-endian, então isso nem sempre funciona.

Em C e C ++, o seguinte fornece o valor mais próximo de 1,0:

#include <limits.h>

double closest_to_1 = 1.0 - DBL_EPSILON/FLT_RADIX;

Observe, entretanto, que nas versões posteriores do C ++, limits.hfoi substituído por climits. Mas então, se você estiver usando código específico C ++ de qualquer maneira, você pode usar

#include <limits>

typedef std::numeric_limits<double> lim_dbl;
double closest_to_1 = 1.0 - lim_dbl::epsilon()/lim_dbl::radix;

E como Jarod42 escreveu em sua resposta, desde C99 ou C ++ 11 você também pode usar nextafter:

#include <math.h>

double closest_to_1 = nextafter(1.0, 0.0);

É claro que em C ++ você pode (e para versões posteriores de C ++ deve) incluir cmathe usar std::nextafter.

Desde C ++ 11, você pode usar nextafterpara obter o próximo valor representável em determinada direção:

std::nextafter(1., 0.); // 0.99999999999999989
std::nextafter(1., 2.); // 1.0000000000000002

Demo

Em C, você pode usar isto:

#include <float.h>
...
double value = 1.0+DBL_EPSILON;

DBL_EPSILON é a diferença entre 1 e o menor valor maior que 1 que é representável.

Você precisará imprimi-lo com vários dígitos para ver o valor real.

Na minha plataforma, printf("%.16lf",1.0+DBL_EPSILON)dá 1.0000000000000002.

Em C ++, você também pode usar este

1 + std::numeric_limits<double>::epsilon()