Converting Byte [] into float []

Question

Hi, I read the contents of a file into a byte array and am now trying to convert it into a float array.
here is the code I am using
public static float [] bytetofloat(byte [] convert){
    float [] data = new float [convert.length/2];
    for(int i = 0;i<convert.length;i+=2){
        for(int j = 0; j <data.length;j++){
        short valueAsShort = (short)( (convert[i] << 8)  | (convert[i+1] & 0xff));
        float valueAsFloat = (float)valueAsShort;
        System.out.println(valueAsFloat);
        valueAsFloat = data[j];
        System.out.println(data[j]);
    }can anyone see anythign wrong with the way I am doing this? I cant see anythign wrong but need to make sure its fine before I can continue.
any advice on this or a better way to do it would be much appreciated.

Answer 1

ultiron wrote:
I'm pretty sure they do. The way im doing it is by taking 2 byte values and changing them to a 16 bit float.
the way the bytes are shift they should only take up 16 bits.It's not that simple.
First, a float in Java is always 4 bytes. The fact that it has an integer value that can fit into two bytes is irrelevant
Second, floating point representation is not the same 2s complement that's used for byte, short, int, and long, so you're not just shifting the bits.
For eample:
1,  int: 00000000 00000000 00000000 00000001
1, float: 00111111 10000000 00000000 00000000
-1,  int: 11111111 11111111 11111111 11111111
-1, float: 10111111 10000000 00000000 00000000Having said that, you're casting, so your step of going from short to float is correct. It doesn't just shift; it does conversions like the above. The caveats are:
1) Is your conversion from bytes to short correct? That depends on what those bytes are supposed to be. If they're big-endian representations of 2-byte, 2s-complement numbers, then your code looks correct. You'll still have to test it of course. You'll want to focus on corner cases.
00 00 --> 0
00 01 --> 1
10 00 --> 4096
7f ff --> 32767
80 00 --> -32768
ff ff --> -1
2) Can float hold all of short's values? I think it can. It obviously can't hold all of int's values, but I think it's precision is sufficient to cover short.
By the way, is there a reason you're using float instead of double? Unless you're in an extremely memory-constrained environment, there's no reason to use double.