define constante doble como hexadecimal?

Question

Me gustaría tener el número más cercano por debajo de 1.0 como punto flotante. Al leer el artículo de wikipedia en IEEE-745, he logrado averiguar que la representación binaria para 1.0 es 3FF0000000000000, por lo que el valor doble más cercano es en realidad 0x3FEFFFFFFFFFFFFF.

La única manera que conozco para inicializar un doble con estos datos binarios es la siguiente:

double a; 
*((unsigned*)(&a) + 1) = 0x3FEFFFFF; 
*((unsigned*)(&a) + 0) = 0xFFFFFFFF; 

que es bastante complicado de usar.

¿Hay alguna manera mejor de definir este número doble, si es posible como una constante?

Answer 1

#include <iostream> 
#include <iomanip> 
#include <limits> 
using namespace std; 

int main() 
{ 
    double const x = 1.0 - numeric_limits<double>::epsilon(); 

    cout 
     << setprecision(numeric_limits<double>::digits10 + 1) << fixed << x 
     << endl; 
} 

Answer 2

No es seguro, pero algo como:

double a; 
*(reinterpret_cast<uint64_t *>(&a)) = 0x3FEFFFFFFFFFFFFFL; 

Sin embargo, esto se basa en un orden de bits particular de números de punto flotante en el sistema, así que no hagas esto!

En su lugar, simplemente ponga DBL_EPSILON en <cfloat> (o como se señala en otra respuesta, std::numeric_limits<double>::epsilon()) para un buen uso.

Answer 3

Si comete un bit_cast y utilizar fixed-width integer types, se puede hacer de manera segura:

template <typename R, typename T> 
R bit_cast(const T& pValue) 
{ 
    // static assert R and T are POD types 

    // reinterpret_cast is implementation defined, 
    // but likely does what you expect 
    return reinterpret_cast<const R&>(pValue); 
} 

const uint64_t target = 0x3FEFFFFFFFFFFFFFL; 
double result = bit_cast<double>(target); 

Aunque probablemente puede subtract epsilon from it.

Answer 4

Es un poco arcaico, pero puede usar un union. Suponiendo una long long y una double son ambos longitud de 8 bytes en su sistema:

typedef union { long long a; double b } my_union; 

int main() 
{ 
    my_union c; 
    c.b = 1.0; 
    c.a--; 
    std::cout << "Double value is " << c.b << std::endl; 
    std::cout << "Long long value is " << c.a << std::endl; 
} 

Aquí no se necesita saber de antemano lo que la representación de bits de 1,0 es.

Answer 5

Flotador hexadecimal y literales dobles existen. La sintaxis es 0x1. (Mantisa) p (exponente en decimal) En su caso, la sintaxis sería

double x = 0x1.fffffffffffffp-1