Manueller Typ-Cast (C/C++)

[Zisko (Gast)]

Hallo zusammen,

ich suche nach einer Erklärung oder einem Beispiel wie der Typecast 
double -> float vollzogen wird. Leider war meine google-Suche da nicht 
sehr ergiebig. Wahrscheinlich suche ich nach den falschen 
Schlüsselwörtern.

Hintergrund meiner Frage: Ich möchte dieses Cast-Verfahren als Vorlage 
für einen Typecast von float auf ein 16 Bit Floatingpoint-Format (1 Bit 
Vorzeichen, 5 Bit Exponent, 10 Bit Mantisse) anwenden und das Rad nicht 
neu erfinden.

Viele Grüße
Zisko

[Karl H. (kbuchegg)]

Zisko schrieb:
> Hallo zusammen,
>
> ich suche nach einer Erklärung oder einem Beispiel wie der Typecast
> double -> float vollzogen wird. Leider war meine google-Suche da nicht
> sehr ergiebig. Wahrscheinlich suche ich nach den falschen
> Schlüsselwörtern.

Nicht nur das. Das wird dir auch nicht viel helfen.
Denn im Grunde besteht der cast bei den üblichen Floating Point Formaten 
nur darin, solange in der Mantisse (beginnend mit den niederwertigsten 
Bits), Bits wegzuwerfen, bis die geforderte Anzahl an Bits übrig bleibt.
Beim Exponenten wird im Prinzip auch nicht anders verfahren, nur das 
diesmal am MOst signifikant Bit Ende angefangen wird, wenn float und 
double eine unterschiedliche Anzahl an Exponentenbits benutzen.
D.h. man könnte die Operation auch so beschreiben: Das ist nichts 
anderes als ein Umkopieren von einem Speicherbereich in einen anderen, 
wobei nur ausgewählte Teile des Original mitgenommen werden.

> Hintergrund meiner Frage: Ich möchte dieses Cast-Verfahren als Vorlage
> für einen Typecast von float auf ein 16 Bit Floatingpoint-Format (1 Bit
> Vorzeichen, 5 Bit Exponent, 10 Bit Mantisse) anwenden und das Rad nicht
> neu erfinden.

[Zisko (Gast)]

Ergo nehme ich beim cast double -> float die ersten 23 Bit der Mantisse 
und die ersten 8 bit des Exponenten, pack das Vorzeichen hinzu und lege 
alles auf 32 Bit Speicher ab, wenn ich das richtig verstanden habe.

[Karl H. (kbuchegg)]

Zisko schrieb:
> Ergo nehme ich beim cast double -> float ...
> die ersten 8 bit des Exponenten

die letzten 8 Bit
Ein "2 hoch 12" ist auch als float "2 hoch 12"

[Yalu X. (yalu) (Moderator)]

Ich habe mal Konvertierungroutinen von double nach half und half nach
double geschrieben (natürlich ohne Garantie für Korrektheit):

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <math.h>

// Datentyp für 16-Bit-Floats
typedef uint16_t half;

// Bitzahl für Exponent und Mantisse
#define DE_BITS 11
#define DM_BITS 52

#define HE_BITS  5
#define HM_BITS 10

// Exponenten-Bias (s. IEEE-754)
#define DE_BIAS ((1 << (DE_BITS-1)) - 1)
#define HE_BIAS ((1 << (HE_BITS-1)) - 1)

// Konvertierung von double nach half
half d2h(double d) {
  uint64_t id = *(uint64_t *)&d, m;
  int s, e;
  half h;

  // Vorzeichen, Exponent und Mantisse extrahieren
  s = id >> (DE_BITS + DM_BITS);
  e = id >> DM_BITS & ((1 << DE_BITS) - 1);
  m = id & (((uint64_t)1 << DM_BITS) - 1);


  // Exponent (mit Bereichsabfrage) und Mantisse (mit Runden) neu skalieren
  if (e) {
    e += HE_BIAS - DE_BIAS;
    m = (m + ((uint64_t)1 << (DM_BITS - HM_BITS - 1))) >> (DM_BITS - HM_BITS);
    if (m >= 1 << HM_BITS) {
      m = 0;
      e++;
    }
    if (e <= 0)
      m = e = 0;
    else if (e >= 1<<HE_BITS)
      printf("Exponent zu klein oder zu groß\n");
  }
  else
    m = 0;

  // Vorzeichen, Exponent und Mantisse zu einer 16-Bit-Zahl zusammensetzen
  h = (s << HE_BITS | e) << HM_BITS | m;

  return h;
}

// Konvertierung von half nach double
double h2d(half h) {
  uint64_t id, m;
  int s, e;

  // Vorzeichen, Exponent und Mantisse extrahieren
  s = h >> (HE_BITS + HM_BITS);
  e = h >> HM_BITS & ((1 << HE_BITS) - 1);
  m = h & ((1 << HM_BITS) - 1);

  // Exponent und Mantisse neu skalieren
  if (e) {
    e += DE_BIAS - HE_BIAS;
    m <<= DM_BITS - HM_BITS;
  }
  else
    m = 0;

  // Vorzeichen, Exponent und Mantisse zu einer 64-Bit-Zahl zusammensetzen
  id = ((uint64_t)s << DE_BITS | e) << DM_BITS | m;

  return *(double *)&id;
}

int main(int argc, char *argv[]) {
  double d = strtod(argv[1], NULL);
  half h;

  // double nach half konvertieren ...
  h = d2h(d);

  // ... und wieder zurück
  d = h2d(h);

  printf("%g\n", d);

  return 0;
}

Dabei folgt die Anordnung und Darstellung der Zahlenbestandteile
(Vorzeichen, Exponent und Mantisse) dem Standard IEEE-754:

  http://de.wikipedia.org/wiki/IEEE_754

Denormalisierte Zahlen, Unendlich und NaN sind nicht implementiert.
Dafür ist das Bitmuster 11111 für den Exponenten erlaubt, was den
Wertebereich für große Zahlen etwas erweitert. Er reicht von
±6.10352e-05 bis ±1.31008Ee+05. Zusätzlich gibt es noch die Werte ±0.
Die Darstellungsgenauigkeit beträgt 3 bis 4 Stellen.

Bei der Konvertierung von double nach half kann es passieren, dass der
Exponent nicht darstellbar ist. Ist er zu klein, wird auf ±0 gerundet.
Ist er zu groß, wird eine Fehlermeldung ausgegeben. Man könnte an dieser
Stelle auch eine Exception auslösen oder Unendlich liefern, wenn dieses
implementiert wäre.

Wenn es auf Laufzeiteffizienz ankommt, kann der Code sicher noch etwas
optimiert werden. So können bspw. die Shifts für die Extraktion der
Zahlenbestandteile mit denen beim Wiederzusammensetzen der Zahl
zusammengefasst werden.

Edit: Hab gerade noch einen Bug gefixt :)

[Mark B. (markbrandis)]

Yalu X. schrieb:
> Ich habe mal Konvertierungroutinen von double nach half und half nach
> double geschrieben

Ich liebe ja einbuchstabige Variablennamen total ;-)

[Yalu X. (yalu) (Moderator)]

Mark Brandis schrieb:
> Ich liebe ja einbuchstabige Variablennamen total ;-)

Ich bin etwas schreibfaul und dachte, wenigstens diese Kürzel sollten 
klar sein:

s = sign
e = exponent
m = mantissa
h = half
d = double

Aber wohl doch nicht ;-)

[Mark B. (markbrandis)]

Yalu X. schrieb:
> Ich bin etwas schreibfaul und dachte, wenigstens diese Kürzel sollten
> klar sein:
>
> s = sign
> e = exponent
> m = mantissa
> h = half
> d = double
>
> Aber wohl doch nicht ;-)

Nun ja, die Kommentare sind auf deutsch, die Variablennamen kürzen die 
englischen Begriffe ab... find ich jetzt nicht unbedingt ideal. Auch 
wenn es hier nur beim Vorzeichen einen Unterschied macht.

Ich seh halt so einen Deutsch/Englisch Mischmasch im Code auf der Arbeit 
jeden Tag, und wesentlich schlimmer als hier... wahrscheinlich hängt's 
mir deshalb schon zum Hals raus. ;-)

[Yalu X. (yalu) (Moderator)]

Mark Brandis schrieb:
> Nun ja, die Kommentare sind auf deutsch, die Variablennamen kürzen die
> englischen Begriffe ab... find ich jetzt nicht unbedingt ideal. Auch
> wenn es hier nur beim Vorzeichen einen Unterschied macht.

Oh Mann, ich habe die Bezeichnungen einfach aus dem (deutschsprachigen)
Wikipedia-Artikel übernommen, zu dem ich schon oben den Bezug
hergestellt habe:

  http://de.wikipedia.org/wiki/IEEE_754

Du kannst die Diskussion über lange/kurze und deutsche/englische
Variablennamen gerne dort fortführen. Wenn ich dann sehe, dass sie dort
im gegenseitigen Einvernehmen geändert worden sind, werde ich diese
Änderungen auch in meinen obigen Code einfließen lassen ;-)