IBM to IEEE floating point conv

Is there any standard method in java to convert IBM 370(in the form of bytes) to IEEE format.?Any algorithm for the conversion would help..

I tried writing a java code..But i fail to understand where do i go wrong. When i give the input as -2.000000000000000E+02, i'm getting the value as -140.0 in IEEE format. and in othercase when i give the input as 3.140000000000000E+00 i'm getting the value as 3.1712502374909226 in IEEE format Any help on this would be highly appreciated

private void conversion() {
    byte[] buffer = //bytes to be read(8 bytes);
    int sign = (buffer[0] & 0x80);
    // Extract exponent.
    int exp = ((buffer[0] & 0x7f) - 64) * 4 - 1;
    //Normalize the mantissa.
    for (int i = 0; i < 4; i开发者_运维问答++) {//since 4 bits per hex digit
        if ((buffer[1] & 0x80) == 0) {
            buffer = leftShift(buffer);
            exp = exp - 1;
        }
    }

    // Put sign and mantissa back in 8-byte number
    buffer = rightShift(buffer);// make room for longer exponent
    buffer = rightShift(buffer);
    buffer = rightShift(buffer);
    exp = exp + 1023;//Excess 1023 format
    int temp = exp & 0x0f;//Low 4 bits go into B(1)
    buffer[1]= (byte)((buffer[1]&0xf) | (temp *16));
    buffer[0]= (byte)(sign | ((exp/16) & 0x7f));
    }

     private byte[] rightShift(byte[] buf) {
    int newCarry = 0;
    int oldCarry = 0;
    for(int i = 1; i<buf.length; i++) {
        newCarry = buf[i] & 1;
        buf[i] = (byte)((buf[i] & 0xFE)/2 + (oldCarry != 0 ? 0x80 : 0));
        oldCarry = newCarry;
    }
    return buf;
}

private byte[] leftShift(byte[] buf) {
    int newCarry = 0;
    int oldCarry = 0;
    for(int i = buf.length-1; i>0; i--) {
        newCarry = buf[i] & 1;
        buf[i] = (byte)((buf[i] & 0x7F)*2 + (oldCarry != 0 ? 1 : 0));
        oldCarry = newCarry;
    }   
    return buf;
}

I can see a couple different solutions to your question:

• Use the text representation as an intermediary reference
• Do a straight conversion C code

This IBM Technical Article includes algorithms for converting from IBM floating point formats to IEE floating point.

There is a bug in the leftShift() function, where you should mask with 0x80 instead of 1. Here is the corrected function.

    private byte[] leftShift(byte[] buf) {
        int newCarry = 0;
        int oldCarry = 0;
        for(int i = buf.length-1; i>0; i--) {
            newCarry = buf[i] & 0x80;
            buf[i] = (byte)((buf[i] & 0x7F)*2 + (oldCarry != 0 ? 1 : 0));
            oldCarry = newCarry;
        }
        return buf;
    }

I tested with the wiki example -118.625 If I understand correctly, the bias for IBM double is also 64, so the binary will be 11000010 01110110 10100000 00000000 00000000 00000000 00000000 00000000. After the fix, the program can produce -118.625 correctly.

I know it is an old post, but I currently ran into the same situation too.