Umwandlung von Float in int (bitweise) in C

Wie kann angesichts der 32 Bits, die eine IEEE 754-Gleitkommazahl darstellen, die Zahl in eine Ganzzahl konvertiert werden, indem Ganzzahl- oder Bitoperationen für die Darstellung verwendet werden (anstatt einen Maschinenbefehl oder eine Compileroperation zum Konvertieren zu verwenden)?

Ich habe die folgende Funktion, aber sie schlägt in einigen Fällen fehl:

Eingabe: int x (enthält eine 32-Bit-Zahl mit einfacher Genauigkeit im IEEE 754-Format)

  if(x == 0) return x;

  unsigned int signBit = 0;
  unsigned int absX = (unsigned int)x;
  if (x < 0)
  {
      signBit = 0x80000000u;
      absX = (unsigned int)-x;
  }

  unsigned int exponent = 158;
  while ((absX & 0x80000000) == 0)
  {
      exponent--;
      absX <<= 1;
  }

  unsigned int mantissa = absX >> 8;

  unsigned int result = signBit | (exponent << 23) | (mantissa & 0x7fffff);
  printf("\nfor x: %x, result: %x",x,result);
  return result;

C hat die “Vereinigung”, um diese Art von Datenansicht zu handhaben:

typedef union {
  int i;
  float f;
 } u;
 u u1;
 u1.f = 45.6789;
 /* now u1.i refers to the int version of the float */
 printf("%d",u1.i);

&x gibt die Adresse von x so hat float* Typ.

(int*)&x wandeln Sie diesen Zeiger in einen Zeiger auf um int dh zu a int* Ding.

*(int*)&x Dereferenzieren Sie diesen Zeiger in ein int Wert. Es wird nicht das tun, was Sie auf Maschinen glauben, wo int und float haben verschiedene Größen.

Und es könnte Endianness-Probleme geben.

Diese Lösung wurde in der verwendet schnelle inverse Quadratwurzel Algorithmus.

(Jemand sollte diese Antwort noch einmal überprüfen, insbesondere Grenzfälle und das Runden negativer Werte. Außerdem habe ich sie für Runden auf den nächsten Wert geschrieben. Um die Konvertierung von C zu reproduzieren, sollte dies in Runden auf Null geändert werden.)

Im Wesentlichen ist der Prozess:

Trennen Sie die 32 Bits in ein Vorzeichenbit (s), acht Exponentenbits (e) und 23 signifikante Bits (f). Wir behandeln diese als ganze Zahlen im Zweierkomplement.

Wenn e 255 ist, ist das Gleitkommaobjekt entweder unendlich (if f Null ist) oder ein NaN (ansonsten). In diesem Fall kann die Konvertierung nicht durchgeführt werden und es sollte ein Fehler gemeldet werden.

Ansonsten, wenn e nicht null ist, addiere 2²⁴ zu f. (Wenn e nicht Null ist, hat die Mantisse implizit ein 1-Bit am Anfang. Hinzufügen 2²⁴ macht das etwas explizit in f.)

Subtrahiere 127 von e. (Dies wandelt den Exponenten von seiner voreingenommenen/kodierten Form in den tatsächlichen Exponenten um. Wenn wir eine allgemeine Umwandlung in einen beliebigen Wert durchführen würden, müssten wir den Sonderfall „wann“ behandeln e ist Null: Subtrahieren Sie 126 statt 127. Da wir aber nur in ein ganzzahliges Ergebnis konvertieren, können wir diesen Fall vernachlässigen, solange das ganzzahlige Ergebnis für diese winzigen Eingabezahlen Null ist.)

Wenn s 0 ist (das Vorzeichen ist positiv) und e 31 oder mehr ist, dann überläuft der Wert eine vorzeichenbehaftete 32-Bit-Ganzzahl (es ist 2³¹ oder größer). Die Konvertierung kann nicht durchgeführt werden und es sollte ein Fehler gemeldet werden.

Wenn s ist 1 (das Vorzeichen ist negativ) und e größer als 31 ist, dann überläuft der Wert eine vorzeichenbehaftete 32-Bit-Ganzzahl (er ist kleiner oder gleich -2³²). Wenn s ist ein, e ist 32, und f ist größer als 2²⁴ (eines der ursprünglichen signifikanten Bits wurde gesetzt), dann überläuft der Wert eine vorzeichenbehaftete 32-Bit-Ganzzahl (er ist kleiner als -2³¹; wenn das Original f Null wären, wäre es genau -2³¹, die nicht überläuft). In jedem dieser Fälle kann die Konvertierung nicht durchgeführt werden und es sollte ein Fehler gemeldet werden.

Jetzt haben wir eine sein eund ein f für einen Wert, der nicht überläuft, damit wir den endgültigen Wert vorbereiten können.

Wenn s ist 1, gesetzt f zu –f.

Der Exponentenwert liegt für eine Mantisse zwischen 1 (einschließlich) und 2 (ausschließlich), aber unsere Mantisse beginnt mit einem Bit bei 2²⁴. Darauf müssen wir uns also einstellen. Wenn e ist 24, unser Signifikand ist korrekt, und wir sind fertig, also kehren Sie zurück f als Ergebnis. Wenn e größer als 24 oder kleiner als 24 ist, müssen wir die Signifikand entsprechend verschieben. Auch wenn wir umziehen f Richtig, wir müssen es möglicherweise runden, um ein Ergebnis zu erhalten, das auf die nächste ganze Zahl gerundet wird.

Wenn e größer als 24 ist, Verschiebung f links e-24 Bit. Zurückkehren f als Ergebnis.

Wenn e kleiner als -1 ist, liegt die Gleitkommazahl zwischen -½ und ½ (ausschließlich). Geben Sie 0 als Ergebnis zurück.

Sonst verschieben wir uns f rechts 24-e Bits. Wir werden jedoch zuerst die Bits speichern, die wir zum Runden benötigen. Satz r zum Ergebnis der Umwandlung von f in eine vorzeichenlose 32-Bit-Ganzzahl und Verschiebung nach links um 32-(24-e) Bits (äquivalent links von 8+e Bits). Dies nimmt die Bits, aus denen herausgeschoben wird f (unten) und sie in den 32 Bits „links anpasst“, sodass wir eine feste Position haben, an der sie beginnen.

Wechsel f rechts 24-e Bits.

Wenn r ist kleiner als 2³¹, tue nichts (dies ist ein Abrunden; die Verschiebung hat abgeschnittene Bits). Wenn r ist größer als 2³¹füge eins hinzu f (das ist aufrunden). Wenn r gleich 2³¹fügen Sie das niedrige Bit von hinzu f zu f. (Wenn f ungerade ist, fügen Sie eins hinzu f. Von den beiden gleich nahen Werten wird auf den geraden Wert gerundet.) Return f.

// With the proviso that your compiler implementation uses
// the same number of bytes for an int as for a float:
// example float
float f = 1.234f;
// get address of float, cast as pointer to int, reference
int i = *((int *)&f);
// get address of int, cast as pointer to float, reference
float g = *((float *)&i);
printf("%f %f %08x\n",f,g,i);

float x = 43.133;
int y;

assert (sizeof x == sizeof y);
memcpy (&y, &x, sizeof x);
...

Sie können den Schwimmer mit einer Referenz werfen. Ein Cast wie dieser sollte niemals Code generieren.

C++

float f = 1.0f;
int i = (int &)f;
printf("Float %f is 0x%08x\n", f, i);

Ausgabe:

Float 1.000000 is 0x3f800000

Wenn Sie einen Cast im C++-Stil wünschen, verwenden Sie einen reinterpret_cast wie diesen.

int i = reinterpret_cast<int &>(f);

Es funktioniert nicht mit Ausdrücken, Sie müssen es in einer Variablen speichern.

    int i_times_two;
    float f_times_two = f * 2.0f;
    i_times_two = (int &)f_times_two;

    i_times_two = (int &)(f * 2.0f);
main.cpp:25:13: error: C-style cast from rvalue to reference type 'int &'

Sie können eine Fließkommazahl nicht (sinnvoll) in eine ‘Ganzzahl’ umwandeln (signed int oder int) auf diese Weise.

Es kann am Ende den Integer-Typ haben, aber es ist eigentlich nur ein Index in den Codierungsraum von IEEE754, kein sinnvoller Wert an sich.

Sie könnten argumentieren, dass ein unsigned int dient einem doppelten Zweck als Bitmuster und als ganzzahliger Wert, aber int nicht.

Es gibt auch Plattformprobleme mit Bit-Manipulation von signierten Ints.