C++ convert float to hex using only whole number math - c++

Question

I need to convert a whole number that should be considered a float into its hexadecimal equivalent.
For example:
Float To Hex
1 = 0x3f800000
2 = 0x40000000
12345 = 0x4640e400
It will always be whole numbers, never fractions such as 0.5.
This could be done with memory assignment or a formatting function, but the situation its being used it, it has no memory access and no API calls at all.
I tried this idea, but it doesn't work at all
http://bytes.com/topic/c/answers/219928-how-convert-float-hex#post886069

Answer 1

Function floatAsUint_s() below re-interprets a 32-bit IEEE-754 float as an unsigned int for any input x for which |x| is in [1, 2128), or zero. The information is extracted from the float one bit at a time and the resulting unsigned int is built from those bits one bit at at time. Provided both the input and output reside in processor registers rather than memory, no additional memory is required during the re-interpretation process.
/* re-interpret IEEE-754 float x, |x| in [1, 2**128) or 0, as unsigned int */
unsigned int floatAsUint_s (float x)
{
unsigned int i;
/* extract sign bit, proceed with absolute value */
i = (((x == 0.0f) ? (1.0f / x) : x) < 0.0f) ? 0x80000000 : 0x00000000;
x = (((x == 0.0f) ? (1.0f / x) : x) < 0.0f) ? -x : x;
/* extract exponent, which is positive per specification */
if (x >= 1.84467441e19f) { x /= 1.84467441e19f; i |= 1 << 29; }
if (x >= 4.29496730e9f) { x /= 4.29496730e9f; i |= 1 << 28; }
if (x >= 65536.0f) { x /= 65536.0f; i |= 1 << 27; }
if (x >= 256.0f) { x /= 256.0f; i |= 1 << 26; }
if (x >= 16.0f) { x /= 16.0f; i |= 1 << 25; }
if (x >= 4.0f) { x /= 4.0f; i |= 1 << 24; }
if (x >= 2.0f) { x /= 2.0f; i |= 1 << 23; }
i += (x == 0.0f) ? 0 : (127 << 23); // add IEEE-754 specified exponent bias
/* extract mantissa */
x = x - 1.0f; // remove hidden bit
x = x + x; if (x >= 1.0f) { x -= 1.0f; i |= 1 << 22; }
x = x + x; if (x >= 1.0f) { x -= 1.0f; i |= 1 << 21; }
x = x + x; if (x >= 1.0f) { x -= 1.0f; i |= 1 << 20; }
x = x + x; if (x >= 1.0f) { x -= 1.0f; i |= 1 << 19; }
x = x + x; if (x >= 1.0f) { x -= 1.0f; i |= 1 << 18; }
x = x + x; if (x >= 1.0f) { x -= 1.0f; i |= 1 << 17; }
x = x + x; if (x >= 1.0f) { x -= 1.0f; i |= 1 << 16; }
x = x + x; if (x >= 1.0f) { x -= 1.0f; i |= 1 << 15; }
x = x + x; if (x >= 1.0f) { x -= 1.0f; i |= 1 << 14; }
x = x + x; if (x >= 1.0f) { x -= 1.0f; i |= 1 << 13; }
x = x + x; if (x >= 1.0f) { x -= 1.0f; i |= 1 << 12; }
x = x + x; if (x >= 1.0f) { x -= 1.0f; i |= 1 << 11; }
x = x + x; if (x >= 1.0f) { x -= 1.0f; i |= 1 << 10; }
x = x + x; if (x >= 1.0f) { x -= 1.0f; i |= 1 << 9; }
x = x + x; if (x >= 1.0f) { x -= 1.0f; i |= 1 << 8; }
x = x + x; if (x >= 1.0f) { x -= 1.0f; i |= 1 << 7; }
x = x + x; if (x >= 1.0f) { x -= 1.0f; i |= 1 << 6; }
x = x + x; if (x >= 1.0f) { x -= 1.0f; i |= 1 << 5; }
x = x + x; if (x >= 1.0f) { x -= 1.0f; i |= 1 << 4; }
x = x + x; if (x >= 1.0f) { x -= 1.0f; i |= 1 << 3; }
x = x + x; if (x >= 1.0f) { x -= 1.0f; i |= 1 << 2; }
x = x + x; if (x >= 1.0f) { x -= 1.0f; i |= 1 << 1; }
x = x + x; if (x >= 1.0f) { x -= 1.0f; i |= 1 << 0; }
return i;
}
/* reference implementation */
unsigned int floatAsUint (float a)
{
unsigned int i;
unsigned char *ap = (unsigned char *)&a, *ip = (unsigned char*)&i;
for (unsigned int c = 0; c < sizeof (i); c++) {
*ip++ = *ap++;
}
return i;
}
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
int main (void)
{
unsigned int res, ref;
float s = -1.0f;
while (s < 2.0f) {
float x = 0.0f;
while (x < 3.40282346e38f) {
ref = floatAsUint (s * x);
res = floatAsUint_s (s * x);
if (ref != res) {
printf ("error # % 15.8e: res= %08x ref=%08x\n", x, res, ref);
exit (EXIT_FAILURE);
}
x = (x == 0.0f) ? 1.0f : nextafterf (x, 3.40282346e38f);
}
s += 2.0f;
}
return EXIT_SUCCESS;
}
An alternative interpretation of the specification in the question is as follows: Given an int x, |x| in [0, 224], produce the IEEE-754 single-precision encoding of the value of x, stored in a uint32_t. Use only integer operations for the transformation.
The bit pattern of a positive non-zero integer <= 224 is identical to the bit pattern of the mantissa (with hidden bit restored) of the IEEE-754 float it is converted to, only appropriately shifted. We therefore need to normalize by left shifting the integer until its most significant 1-bit is in the position of the hidden mantissa bit, which is bit 23. The number of shifts needed to normalize tells us the magnitude of the integer in powers of two, and thus determines the exponent of the floating-point number. We need to remember to add the exponent bias prescribed by IEEE-754, then combine the sign, exponent, and mantissa portions for the final result.
The function make_float_s() in the code below implements the algorithm described above.
#include <stdint.h>
/* For |a| in [0,2**24], generate IEEE-754 float encoding with same value */
uint32_t make_float_s (int a)
{
uint32_t i;
int e = 0;
i = (a < 0) ? 0x80000000 : 0x00000000; // sign bit
if (a) {
a = (a < 0) ? -a : a;
while (a < 0x00800000) { // normalize mantissa
e++;
a = a + a;
}
e = 127 + (22 - e); // determine biased exponent
i += (e << 23) + a; // combine sign, exponent, mantissa
}
return i;
}
#include <stdio.h>
#include <stdlib.h>
#include <memory.h>
uint32_t float_as_uint (float a)
{
uint32_t i;
memcpy (&i, &a, sizeof(i));
return i;
}
/* reference function */
uint32_t make_float (int a)
{
return float_as_uint ((float)a);
}
int main (void)
{
uint32_t res, ref;
int a, s;
a=1; printf("%d encoded as IEEE-754 float: %08x\n", a, make_float_s(a));
a=2; printf("%d encoded as IEEE-754 float: %08x\n", a, make_float_s(a));
a=12345; printf("%d encoded as IEEE-754 float: %08x\n", a, make_float_s(a));
s = -1;
while (s < 2) {
a = 0;
while (a <= 16777216) {
res = make_float_s (s * a);
ref = make_float (s * a);
if (res != ref) {
printf ("error # % 7d: res=%08x ref=%08x\n", s * a, res, ref);
exit (EXIT_FAILURE);
}
a++;
}
s += 2;
}
return EXIT_SUCCESS;
}

Answer 2

You can use union for this.
Something like:
union data {
float f_data;
char c_data[4];
};
And usage:
data d1;
d1.f_data = 12345;
After that d1.c_data contain hex values you need.