C: a float from 2 bytes of a 4-byte array

carcassonne · 01-15-2007, 09:09 PM

Hi,

I'd like to obtain a float that I multiply by 0.5 eg. like this:

int value;
float result;
value = 0x3039;
result = value * 0.5;

... except that the value comes from the first two bytes of a 4-byte array instead:

float result;
char array[]= {0x39, 0x30, 0x40, 0x49};

How can I take, in C, the first two bytes and either put them in an integer to do the above math or directly them to perform the calculation ? I tried the following, typecasting the beginning of the array so that the compiler might think it's an integer, but it does not work:

result = (int) array * 0.5;

Any suggestion greatly appreciated, thanks !
Al

theNbomr · 01-15-2007, 09:34 PM

You must first convert the array to an integer:

Code:

value = array[0] + 256 * array[1];

If you contrive your array order correctly, you may be able to do it with a union, but this would be dependent upon byte order for the particular architecture.

Code:

union arrayToInt {
char array[4];
int  value;
} convertor;

convertor.array[0] = 39;
convertor.array[1] = 30;
result = 0.5 * convertor.value;

--- rod.

arabindav · 01-15-2007, 11:04 PM

Hello carcassonne,

You can do as follows:

char array[] = {0x39, 0x30, 0x40, 0x49};
unsigned int* value;
/* or int* value; */

value = &array;
printf("%x\n", *value);

The above will give you the something like "49403039". However, as suggested by theNbomr, the value of "value" depends upon byte order. You can AND (&) and shift (right/left) to meet your requirement.

Have fun.

grumpf · 01-16-2007, 03:16 AM

hi carcassonne,
please note that you will have different results on big/little endian boxes.
If our are interessted in obtaining the mantisse/exponent part of the fp-number you may
prefer: frexp()

see: man frexp() for details

Vasek · 01-16-2007, 06:22 AM

But for converting only the first two bytes, unsigned short would be more reliable on x86:

char array[] = {0x39, 0x30, 0x40, 0x49};
int value;
value = *(unsigned short*)array;

This results in 0x3039.

KenJennings · 01-16-2007, 01:06 PM

You should not try to exploit the order of values as they are stored in the array, since this will be completely non-portable. Simply get the components of your desired integer value and merge them together:

int highbyte = 0x30;
int lowbyte = 0x39;

For int value, either method below works and is reliably portable (assuming only that bytes are 8-bits wide and an int is large enough to store two bytes)

value = ( highbyte * 256 ) + lowbyte ;

OR

value = ( highbyte << 8 ) | lowbyte ;

Then you can work with the integer result of "value" however you like.

gzickert · 01-16-2007, 06:31 PM

char array[] = {0x39, 0x30, 0x40, 0x49}; // These are all numeric characters '0'..'9'
int value = 0;

for (int i = 0; i < 4; ++i)
{
value = value * 10 + (array[i] - '0'); // process each digit from most significant to least.
}

KenJennings · 01-16-2007, 09:29 PM

Quote:

Originally Posted by gzickert

Code:

char array[] = {0x39, 0x30, 0x40, 0x49}; // These are all numeric characters '0'..'9'
...

You lost me. What numeric character(s) are 0x40 or 0x49 ?

Here the command:

Code:

echo "0123456789" | hex

reports:

Code:

0000  30 31 32 33 34 35 36 37 38 39 0a                 01234567 89.

gzickert · 01-17-2007, 06:23 PM

Sorry for the confusion. The example was for an array of 4 numeric chars and I copied the example array w/o ensuring that all of the chars were numeric. That said, if you are only interested in the first 2 chars then change the loop control test to i < 2 so only the first 2 characters are processed.