IBM to IEEE floating point conv

Question

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;
}

Which flavour of IBM number are you talking about? There are three binary floating point representations ( http://en.wikipedia.org/wiki/IBM_Floating_Point_Architecture ) and a variety of other formats. — Stephen C, Jun 19 '11 at 03:39

score 1 · Answer 1 · edited May 23 '17 at 12:31

1

I can see a couple different solutions to your question:

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

edited May 23 '17 at 12:31

Community

1
1

answered Jun 18 '11 at 23:26

RHSeeger

16,034
7
51
41

score 1 · Answer 2 · answered Jun 19 '11 at 03:49

1

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

answered Jun 19 '11 at 03:49

Stephen C

698,415
94
811
1,216

score 0 · Answer 3 · edited Jul 01 '21 at 13:53

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.

IBM to IEEE floating point conv

3 Answers3

Linked