Qual è il doppio più vicino a 1.0, che non è 1.0?

C'è un modo per ottenere programmaticamente il double più vicino a 1.0, ma in realtà non lo è 1.0?

Un modo hacky per farlo sarebbe memorizzare il double in un numero intero della stessa dimensione e poi sottrarne uno. Il modo in cui funzionano i formati a virgola mobile IEEE754, questo finirebbe per diminuire l'esponente di uno mentre si modifica la parte frazionaria da tutti zeri (1.000000000000) a tutti uno (1.111111111111). Tuttavia esistono macchine in cui gli interi sono memorizzati in little-endian mentre in virgola mobile è memorizzato in big-endian, quindi non sempre funzionerà.

In C e C ++, quanto segue fornisce il valore più vicino a 1.0:

#include <limits.h>

double closest_to_1 = 1.0 - DBL_EPSILON/FLT_RADIX;

Si noti tuttavia che nelle versioni successive di C ++, limits.hè deprecato a favore di climits. Ma poi, se stai usando comunque codice specifico C ++, puoi usare

#include <limits>

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

E come scrive Jarod42 nella sua risposta, poiché C99 o C ++ 11 puoi anche usare nextafter:

#include <math.h>

double closest_to_1 = nextafter(1.0, 0.0);

Ovviamente in C ++ puoi (e per le versioni successive di C ++ dovresti) includere cmathe usare std::nextafterinvece.

A partire da C ++ 11, puoi usare nextafterper ottenere il prossimo valore rappresentabile nella direzione data:

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

Demo

In C, puoi usare questo:

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

DBL_EPSILON è la differenza tra 1 e il valore minimo maggiore di 1 rappresentabile.

Dovrai stamparlo su più cifre per vedere il valore effettivo.

Sulla mia piattaforma, printf("%.16lf",1.0+DBL_EPSILON)dà 1.0000000000000002.

In C ++ puoi anche usare questo

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