So erhalten Sie das Vorzeichen, die Mantisse und den Exponenten einer Gleitkommazahl

Ich habe ein Programm, das auf zwei Prozessoren läuft, von denen einer keine Fließkommaunterstützung hat. Also muss ich Gleitkommaberechnungen mit Festkomma in diesem Prozessor durchführen. Zu diesem Zweck werde ich eine Fließkomma-Emulationsbibliothek verwenden.

Ich muss zuerst die Zeichen, Mantissen und Exponenten von Gleitkommazahlen auf dem Prozessor extrahieren, die Gleitkommazahlen unterstützen. Meine Frage ist also, wie ich das Vorzeichen, die Mantisse und den Exponenten einer Gleitkommazahl mit einfacher Genauigkeit erhalten kann.

Dem Format dieser Abbildung folgend,

Das habe ich bisher getan, aber außer Vorzeichen sind weder Mantisse noch Exponent korrekt. Ich glaube, mir fehlt etwas.

void getSME( int& s, int& m, int& e, float number )
{
    unsigned int* ptr = (unsigned int*)&number;

    s = *ptr >> 31;
    e = *ptr & 0x7f800000;
    e >>= 23;
    m = *ptr & 0x007fffff;
}

Ich denke, es ist besser, Gewerkschaften zu verwenden, um die Besetzungen durchzuführen, es ist klarer.

#include <stdio.h>

typedef union {
  float f;
  struct {
    unsigned int mantisa : 23;
    unsigned int exponent : 8;
    unsigned int sign : 1;
  } parts;
} float_cast;

int main(void) {
  float_cast d1 = { .f = 0.15625 };
  printf("sign = %x\n", d1.parts.sign);
  printf("exponent = %x\n", d1.parts.exponent);
  printf("mantisa = %x\n", d1.parts.mantisa);
}

Beispiel basierend auf http://en.wikipedia.org/wiki/Single_precision

Mein Rat ist, sich an Regel 0 zu halten und nicht zu wiederholen, was Standardbibliotheken bereits tun, wenn dies ausreicht. Sehen Sie sich math.h (cmath in Standard-C++) und die Funktionen frexp, frexpf, frexpl an, die einen Gleitkommawert (Double, Float oder Long Double) in seinen Signifikanten- und Exponententeil zerlegen. Um das Vorzeichen aus dem Signifikanten zu extrahieren, können Sie signbit, auch in math.h / cmath, oder copysign (nur C++11) verwenden. Einige Alternativen mit etwas unterschiedlicher Semantik sind modf und ilogb/scalbn, verfügbar in C++11; http://en.cppreference.com/w/cpp/numeric/math/logb vergleicht sie, aber ich habe in der Dokumentation nicht gefunden, wie sich all diese Funktionen mit +/-inf und NaNs verhalten. Schließlich, wenn Sie wirklich Bitmasken verwenden wollen (z. B. wenn Sie unbedingt die genauen Bits kennen müssen und Ihr Programm möglicherweise verschiedene NaNs mit unterschiedlichen Darstellungen hat und Sie den obigen Funktionen nicht vertrauen), machen Sie zumindest alles plattformunabhängig indem Sie die Makros in float.h/cfloat verwenden.

Finden Sie das Format der Fließkommazahlen heraus, die auf der CPU verwendet werden, die Fließkomma direkt unterstützt, und zerlegen Sie es in diese Teile. Das gebräuchlichste Format ist IEEE-754.

Alternativ könnten Sie diese Teile mit einigen speziellen Funktionen erhalten (double frexp(double value, int *exp); und double ldexp(double x, int exp);) wie in dieser Antwort gezeigt.

Eine weitere Option ist die Verwendung %a mit printf().

Du bist &ing die falschen Bits. Ich denke du willst:

s = *ptr >> 31;
e = *ptr & 0x7f800000;
e >>= 23;
m = *ptr & 0x007fffff;

Denken Sie daran, wenn Sie &, nullen Sie Bits, die Sie nicht setzen. In diesem Fall möchten Sie also das Vorzeichenbit auf Null setzen, wenn Sie den Exponenten erhalten, und Sie möchten das Vorzeichenbit und den Exponenten auf Null setzen, wenn Sie die Mantisse erhalten.

Beachten Sie, dass die Masken direkt von Ihrem Bild stammen. Die Exponentenmaske sieht also so aus:

0 11111111 0000000000000000000000

und die Mantissenmaske sieht so aus:

0 00000000 11111111111111111111111

Unter Linux stellt das Paket glibc-headers einen Header bereit #include <ieee754.h> mit Definitionen von Fließkommatypen, zB:

union ieee754_double
  {
    double d;

    /* This is the IEEE 754 double-precision format.  */
    struct
      {
#if __BYTE_ORDER == __BIG_ENDIAN
    unsigned int negative:1;
    unsigned int exponent:11;
    /* Together these comprise the mantissa.  */
    unsigned int mantissa0:20;
    unsigned int mantissa1:32;
#endif              /* Big endian.  */
#if __BYTE_ORDER == __LITTLE_ENDIAN
# if    __FLOAT_WORD_ORDER == __BIG_ENDIAN
    unsigned int mantissa0:20;
    unsigned int exponent:11;
    unsigned int negative:1;
    unsigned int mantissa1:32;
# else
    /* Together these comprise the mantissa.  */
    unsigned int mantissa1:32;
    unsigned int mantissa0:20;
    unsigned int exponent:11;
    unsigned int negative:1;
# endif
#endif              /* Little endian.  */
      } ieee;

    /* This format makes it easier to see if a NaN is a signalling NaN.  */
    struct
      {
#if __BYTE_ORDER == __BIG_ENDIAN
    unsigned int negative:1;
    unsigned int exponent:11;
    unsigned int quiet_nan:1;
    /* Together these comprise the mantissa.  */
    unsigned int mantissa0:19;
    unsigned int mantissa1:32;
#else
# if    __FLOAT_WORD_ORDER == __BIG_ENDIAN
    unsigned int mantissa0:19;
    unsigned int quiet_nan:1;
    unsigned int exponent:11;
    unsigned int negative:1;
    unsigned int mantissa1:32;
# else
    /* Together these comprise the mantissa.  */
    unsigned int mantissa1:32;
    unsigned int mantissa0:19;
    unsigned int quiet_nan:1;
    unsigned int exponent:11;
    unsigned int negative:1;
# endif
#endif
      } ieee_nan;
  };

#define IEEE754_DOUBLE_BIAS 0x3ff /* Added to exponent.  */

1. Erstellen Sie keine Funktionen, die mehrere Dinge tun.
2. Nicht maskieren, dann verschieben; verschieben, dann maskieren.
3. Verändern Sie Werte nicht unnötigerweise, da dies langsam, Cache-zerstörend und fehleranfällig ist.
4. Verwenden Sie keine magischen Zahlen.

/* NaNs, infinities, denormals unhandled */
/* assumes sizeof(float) == 4 and uses ieee754 binary32 format */
/* assumes two's-complement machine */
/* C99 */
#include <stdint.h>

#define SIGN(f) (((f) <= -0.0) ? 1 : 0)

#define AS_U32(f) (*(const uint32_t*)&(f))
#define FLOAT_EXPONENT_WIDTH 8
#define FLOAT_MANTISSA_WIDTH 23
#define FLOAT_BIAS ((1<<(FLOAT_EXPONENT_WIDTH-1))-1) /* 2^(e-1)-1 */
#define MASK(width)  ((1<<(width))-1) /* 2^w - 1 */
#define FLOAT_IMPLICIT_MANTISSA_BIT (1<<FLOAT_MANTISSA_WIDTH)

/* correct exponent with bias removed */
int float_exponent(float f) {
  return (int)((AS_U32(f) >> FLOAT_MANTISSA_WIDTH) & MASK(FLOAT_EXPONENT_WIDTH)) - FLOAT_BIAS;
}

/* of non-zero, normal floats only */
int float_mantissa(float f) {
  return (int)(AS_U32(f) & MASK(FLOAT_MANTISSA_BITS)) | FLOAT_IMPLICIT_MANTISSA_BIT;
}

/* Hacker's Delight book is your friend. */

Sieh dir das an IEEE_754_types.h Header für die zu extrahierenden Union-Typen: float, double und long double, (Endianness gehandhabt). Hier ein Auszug:

/*
** - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
**  Single Precision (float)  --  Standard IEEE 754 Floating-point Specification
*/

# define IEEE_754_FLOAT_MANTISSA_BITS (23)
# define IEEE_754_FLOAT_EXPONENT_BITS (8)
# define IEEE_754_FLOAT_SIGN_BITS     (1)

.
.
.

# if (IS_BIG_ENDIAN == 1)
    typedef union {
        float value;
        struct {
            __int8_t   sign     : IEEE_754_FLOAT_SIGN_BITS;
            __int8_t   exponent : IEEE_754_FLOAT_EXPONENT_BITS;
            __uint32_t mantissa : IEEE_754_FLOAT_MANTISSA_BITS;
        };
    } IEEE_754_float;
# else
    typedef union {
        float value;
        struct {
            __uint32_t mantissa : IEEE_754_FLOAT_MANTISSA_BITS;
            __int8_t   exponent : IEEE_754_FLOAT_EXPONENT_BITS;
            __int8_t   sign     : IEEE_754_FLOAT_SIGN_BITS;
        };
    } IEEE_754_float;
# endif

Und sehen dtoa_base.c für eine Demonstration, wie man a konvertiert double Wert in Zeichenfolgenform.

Sehen Sie sich außerdem den Abschnitt an 1.2.1.1.4.2 – Gleitkommaspeicher-Layout des C/CPP-Referenzbuches erklärt super gut und in einfachen Worten die Speicherdarstellung / das Layout aller Gleitkommatypen und wie man sie (mit Illustrationen) gemäß der tatsächlichen IEEE 754-Gleitkommaspezifikation dekodiert.

Es hat auch Links zu wirklich sehr guten Ressourcen, die noch tiefer erklären.