把一个IEEE754浮点数转换为IBM370浮点数的C#代码

把一个IEEE754浮点数转换为IBM370浮点数的C#代码。

在这个网页上有古老的IBM370浮点格式的说明。

        // http://en.wikipedia.org/wiki/IBM_Floating_Point_Architecture
        // float2ibm(-118.625F) == 0xC276A000
        // 1 100 0010    0111 0110 1010 0000 0000 0000
        // IBM/370 single precision, 4 bytes
        // xxxx.xxxx xxxx.xxxx xxxx.xxxx xxxx.xxxx
        // s|-exp--| |--------fraction-----------|
        //    (7)          (24)
        // value = (-1)**s * 16**(e - 64) * .f   range = 5E-79 ... 7E+75
        static int float2ibm(float from)
        {
            byte[] bytes = BitConverter.GetBytes(from);
            int fconv = (bytes[3] << 24) | (bytes[2] << 16) | (bytes[1] << 8)| bytes[0];

            if (fconv == 0) return 0;
            int fmant = (0x007fffff & fconv) | 0x00800000;
            int t = (int)((0x7f800000 & fconv) >> 23) - 126;
            while (0 != (t & 0x3)) { ++t; fmant >>= 1; }
            fconv = (int)(0x80000000 & fconv) | (((t >> 2) + 64) << 24) | fmant;
            return fconv; // big endian order
        }

在这段C代码的基础上修改的

/* Assumes sizeof(int) == 4 */
static void float_to_ibm(int from[], int to[], int n, int endian)
/**********************************************************************
 float_to_ibm - convert between 32 bit IBM and IEEE floating numbers
***********************************************************************
Input:
from       input vector
n          number of floats in vectors
endian     =0 for little endian machine, =1 for big endian machines

Output:
to         output vector, can be same as input vector

***********************************************************************
Notes:
Up to 3 bits lost on IEEE -> IBM

IBM -> IEEE may overflow or underflow, taken care of by
substituting large number or zero

Only integer shifting and masking are used.
***********************************************************************
Credits:     CWP: Brian Sumner
***********************************************************************/
{
    register int fconv, fmant, i, t;

    for (i=0;i<n;++i) {
        fconv = from[i];
        if (fconv) {
            fmant = (0x007fffff & fconv) | 0x00800000;
            t = (int) ((0x7f800000 & fconv) >> 23) - 126;
            while (t & 0x3) { ++t; fmant >>= 1; }
            fconv = (0x80000000 & fconv) | (((t>>2) + 64) << 24) | fmant;
        }
        if(endian==0)
                fconv = (fconv<<24) | ((fconv>>24)&0xff) |
                        ((fconv&0xff00)<<8) | ((fconv&0xff0000)>>8);

        to[i] = fconv;
    }
    return; 

}

另外找到的一些C代码放在这里以后备用

#include "ibmieee.h" 

/*---------------------------------------------------------------------
 *
 *   FILE: ./ibmieee.c
 *
 *----------------------------------------------------------------------
*
*   DESCRIPTION:
*     Conversion from IBM to IEEE format
*     Byte order is detected and accounted for using
*     define constant 'L_ENDIAN'
*
*----------------------------------------------------------------------
*   ROUTINES DEFINED IN THIS MODULE:
*----------------------------------------------------------------------
*
*
*  Convert IBM to IEEE integer:
*
*   ibm_ieee_i( n, ibm, ieee)
*   int n;
*   int *ibm;
*   int *ieee;
*
*  Convert IEEE to IBM integer:
*
*   ieee_ibm_i( n, ieee, ibm)
*   int n;
*   int *ieee;
*   int *ibm;
*
*  Convert IBM to IEEE short floating point:
*
*   ibm_ieee_f( n, ibm, ieee)
*   int n;
*   char *ibm;
*   float *ieee;
*
*  Convert IEEE to IBM floating point:
*
*   ieee_ibm_f( n, ieee, ibm)
*   int n;
*   float *ieee;
*   char *ibm;
*
*---------------------------------------------------------------------*/ 

void ibm_ieee_i( int n, char *ibm, char *ieee )
/*
        Convert from IBM to IEEE integer, possibly in-place
*/
#ifdef L_ENDIAN
{
  int j;
  char temp; 

  /* Reverse byte order on little endian machines */
  for (j=0; j<4*n; j+=4) {
    temp=ibm[j];
    ieee[j]=ibm[j+3];
    ieee[j+3]=temp;
    temp=ibm[j+1];
    ieee[j+1]=ibm[j+2];
    ieee[j+2]=temp;
  } 

#else 

  {
    int j; 

    /* Move words if not same location */ 

    if (ibm != ieee)
      for (j=0; j<n; j++)
    ieee[j] = ibm[j]; 

#endif /* L_ENDIAN */ 

    return ; 

  } 

  /*********************************************************************/ 

 void ieee_ibm_i( int n, char *ibm, char *ieee )
 /*
        Convert from IEEE to IBM integer, possibly in-place
*/ 

#ifdef L_ENDIAN
  {
    int j;
    char temp; 

    /* Reverse byte order on little endian machines */
    for (j=0; j<4*n; j+=4) {
      temp=ieee[j];
      ibm[j]=ieee[j+3];
      ibm[j+3]=temp;
      temp=ieee[j+1];
      ibm[j+1]=ieee[j+2];
      ibm[j+2]=temp;
    } 

#else
    {
      int j; 

      /* Move words if not same location */ 

      if (ibm != ieee)
    for (j=0; j<n; j++)
      ibm[j] = ieee[j]; 

#endif /* L_ENDIAN */
      return ; 

    } 

    /*---------------------------------------------------------------------
*
*  Convert from IBM short real to IEEE short real
*
*
*  Bit formats for Big Endian processors (i.e. 68020, SPARC, RS6000):
*
*              0         1        2        3         Byte Offset
*          --------------------------------------
*  IBM     !S! EXP   !   MH   !   MM   !   ML   !
*          --------------------------------------
*           0 1     7 8     15 16    23 24    31     bit number
*
*              0         1        2        3         Byte Offset
*          --------------------------------------
*  IEEE    !S! EXP    !  MH   !   MM   !   ML   !
*          --------------------------------------
*           0 1      8 9    15 16    23 24    31     bit number
*
*
*  Bit formats for Little Endian processors (i.e. Intel 80x86):
*
*              3         2        1        0         byte offset
*          --------------------------------------
*  IBM     !   ML   !   MH   !   MH   !S!  EXP  !
*          --------------------------------------
*           31    24 23    16 15     8 7 6     0     bit number
*
*              3         2        1        0         byte offset
*          --------------------------------------
*  IEEE    !S!  EXP  !!  MH   !   MM   !   ML   !
*          --------------------------------------
*          31 30    23 22   16 15     8 7      0     bit number
*
*
*  ML, MM, and MH refer to the low, middle, and high order mantissa
*  bytes.  S is the sign bit, EXP is the exponent.  Bits and bytes
*  are numbered in order of increasing address in memory.  The fields
*  are shown in the order that a Hex constant in C would be used as
*  a mask for accessing bits.
*
*
* A floating point number in the IBM format is defined to be:
*
*      (sign) 0.(significand) * 16**(exponent-64)
*
* In the IEEE format, a floating point number is:
*
*      (sign) 1.(significand) * 2**(exponent-127)
*
* The differences are:
*
*       1. IBM assumes a 0 to left of decimal point,
*          IEEE assumes a 1 to left of decimal point.
*          Since the IBM format has 1 more bit for the significand,
*          they both have the same precision: 24 binary digits.
*
*       2. The base for the exponent is 16 for IBM, 2 for IEEE
*
*       3. The bias for the exponent is 64 for IBM, 127 for IEEE
*
*       4. The exponent is 7 bits for IBM, 8 for IEEE. The exponent
*          range is then -64 to +63 for IBM, -127 to +128 for IEEE.
*
*       5. Since the IBM format has base 16, the decimal exponent
*          range for IBM is about twice that for IEEE:
*          IBM:  0.1H * 16**(-64)  to  0.FFFFFFH * 16**(+63)
*            =   5.4 * 10**(-79)   to   7.2 * 10**(+75)
*          IEEE: 1.0H * 2**(-127)  to  1.FFFFFFH * 2**(+128)
*            =   5.9 * 10**(-39)   to   6.8 * 10**(+38)
*
* To convert IBM to IEEE:
*
*       1. Multiply IBM exponent by 4 to convert base from 16 to 2,
*          subtract 129 to adjust for difference in bias (16*4-127).
*
*       2. Shift the IBM significand left 1 bit and subtract 1 from
*          the exponent. If the significand MSB is still 0, repeat.
*
*       3. If the exponent overflows, set result to +-infinity. If
*          it underflows, set to +-zero.
*
*       4. Move the converted sign, significand, and exponent into
*          the appropriate fields for the IEEE format.
*
*
* To convert IEEE to IBM:
*
*       1. Get IEEE mantissa (bits 0-22). OR in a 1 in bit 23 to
*          account for assumed leading '1'.
*
*       2. Get IEEE exponent.  Add 1 to exponent to place the decimal
*          point before the '1' in the mantissa.  Subtract IEEE bias
*          of 127 to yield true base 2 exponent.
*
*       3. Divide IEEE exponent by 4 to convert to base 16 exponent:
*            0.X * 2**Y = 0.X * 16**(Y/4)
*          Save remainder from division.  If remainder is not zero:
*            0.X * 16**(I+1/4) = 2*(0.X) * 16**I = (1/8)0.X * 16**(I+1)
*            0.X * 16**(I+2/4) = 4*(0.X) * 16**I = (1/4)0.X * 16**(I+1)
*            0.X * 16**(I+3/4) = 8*(0.X) * 16**I = (1/2)0.X * 16**(I+1)
*          I.E., add 1 to exponent, shift mantissa right by
*          (4 - remainder).  Add IBM bias of 64 to exponent.
*
*       4. Move the converted sign, significand, and exponent into
*          the appropriate fields for the IBM format.
*
*
*---------------------------------------------------------------------*/ 

  void  ibm_ieee_f( int n, VAL *ibm, VAL *ieee ) 

    {
      int i,iret;
      VAL tmp1,tmp2,temp;
      int exp; 

      iret = 0; 

      for (i=0; i<n; i++) { 

    /* Move IBM word to properly aligned temp location */
    temp.c[0] = ibm[i].c[0];
    temp.c[1] = ibm[i].c[1];
    temp.c[2] = ibm[i].c[2];
    temp.c[3] = ibm[i].c[3]; 

    /* check for true zero */
    if (temp.u == 0) {
      ieee[i].c[0] = ieee[i].c[1] = ieee[i].c[2] =
        ieee[i].c[3] = '\0';
      continue;
    }
    /* extract mantissa */
#ifdef L_ENDIAN
    tmp1.c[0] = temp.c[3];
    tmp1.c[1] = temp.c[2];
    tmp1.c[2] = temp.c[1];
    tmp1.c[3] = '\0';
#else
    tmp1.u = temp.u;
    tmp1.c[0] = '\0';
#endif 

    /* Extract exponent */
    /* remove sign bit, multiply by 4, subtract bias difference */
    exp = ((temp.c[0] & 0x7F) << 2 ) - 129; 

    /* Shift mantissa up 1 bit until there is a 1 in the MSB */
    while ( (tmp1.u & 0x800000) == 0 ) {
      exp--;
      tmp1.u = tmp1.u << 1;
    };
    /* Discard MSB and decrement exponent 1 more */
    tmp1.u = tmp1.u & 0x007FFFFF;
    exp--; 

    /* Check for exponent overflow or underflow */
    if (exp & 0xFF00) {
      if (exp < 0)
        /* Underflow */
        ieee[i].c[0] = ieee[i].c[1] = ieee[i].c[2] =
          ieee[i].c[3] = '\0';
      else {
        /* Overflow */
#ifdef L_ENDIAN
        ieee[i].c[3] = 0x7F;
        ieee[i].c[2] = 0x80;
        ieee[i].c[1] = 0x00;
        ieee[i].c[0] = 0x00;
#else
        ieee[i].c[0] = 0x7F;
        ieee[i].c[1] = 0x80;
        ieee[i].c[2] = 0x00;
        ieee[i].c[3] = 0x00;
#endif
      }
      iret = 1;
      continue;
    } 

    /* Move exponent into proper field and set sign bit */
    tmp2.u = 0;
#ifdef L_ENDIAN
    tmp2.c[3] = (char)exp;
    tmp2.u = tmp2.u >> 1;
    if (temp.u & 0x00000080)
      tmp2.u = tmp2.u | 0x80000000;
    else
      tmp2.u = tmp2.u & 0x7fffffff;
#else
    tmp2.c[0] = (char)exp;
    tmp2.u = tmp2.u >> 1;
    tmp2.u = tmp2.u | (temp.u & 0x80000000);
#endif
    /* Set output value */
    temp.u = tmp1.u | tmp2.u;
    ieee[i].c[0] = temp.c[0];
    ieee[i].c[1] = temp.c[1];
    ieee[i].c[2] = temp.c[2];
    ieee[i].c[3] = temp.c[3];
      }
      return ;
    } 

    /*********************************************************************/ 

void    ieee_ibm_f( int n, VAL *ieee, VAL *ibm ) 

    {
      int i;
      VAL temp,tmp1,tmp2;
      int exp,rem; 

      for (i=0; i<n; i++) { 

    /* Move to properly aligned location */
    temp.c[0] = ieee[i].c[0];
    temp.c[1] = ieee[i].c[1];
    temp.c[2] = ieee[i].c[2];
    temp.c[3] = ieee[i].c[3];
    /* check for true zero */
    if (temp.u == 0) {
      ibm[i].c[0] = ibm[i].c[1] = ibm[i].c[2] =
        ibm[i].c[3] = '\0';
      continue;
    }
    /* extract mantissa, OR in leading '1' */
    tmp1.u = (temp.u & 0x007FFFFF) | 0x00800000; 

    /* Extract exponent */
    /* remove sign bit, shift up one bit */
    tmp2.u = (temp.u & 0x7F800000) << 1;
    /* Add 1 for mantissa shift, subtract 127 for IEEE bias */
#ifdef L_ENDIAN
    exp = (unsigned)tmp2.c[3] - 126;
#else
    exp = (unsigned)tmp2.c[0] - 126;
#endif 

    /* Divide exponent by 4, save remainder, add IBM bias of 64 */
    rem = exp & 0x03;
    exp = (exp >> 2) + 64;
    /* Normalize mantissa by shifting by (4-remainder) */
    if (rem) {
      tmp1.u = tmp1.u >> (4-rem);
      exp = exp + 1;
    } 

    /* Move exponent and mantissa bytes into IBM locations */
#ifdef L_ENDIAN
    tmp2.u = 0;
    tmp2.c[0] = (char)exp;
    tmp2.c[1] = tmp1.c[2];
    tmp2.c[2] = tmp1.c[1];
    tmp2.c[3] = tmp1.c[0];
    /* Set sign bit */
    if (temp.u & 0x80000000) tmp2.u = tmp2.u | 0x00000080;
#else
    tmp2.u = tmp1.u;
    tmp2.c[0] = (char)exp;
    /* Set sign bit */
    if (temp.u & 0x80000000) tmp2.u = tmp2.u | 0x80000000;
#endif 

    /* Set output value */
    ibm[i].c[0] = tmp2.c[0];
    ibm[i].c[1] = tmp2.c[1];
    ibm[i].c[2] = tmp2.c[2];
    ibm[i].c[3] = tmp2.c[3];
      }
      return ;
    }