Half-precision floating-point in Java

Können Sie Float.intBitsToFloat() und Float.floatToIntBits() konvertieren Sie zu und von der primitive float-Werte. Wenn Sie Leben können mit abgeschnitten Präzision (im Gegensatz zu Runden) die Konvertierung sollte möglich sein, die Umsetzung mit nur ein paar bit-Verschiebungen.

Ich habe nun ein bisschen mehr Mühe und es stellte sich heraus, nicht ganz so einfach, wie ich erwartet hatte, zumindest am Anfang. Diese version wird nun getestet und überprüft werden, in jedem Aspekt, den ich mir vorstellen konnte und ich bin sehr zuversichtlich, dass es produziert die genauen Ergebnisse für alle möglichen Eingabewerte. Es unterstützt die exakte Rundung und subnormal Umwandlung in beide Richtungen.

//ignores the higher 16 bits
public static float toFloat( int hbits )
{
    int mant = hbits & 0x03ff;            //10 bits mantissa
    int exp =  hbits & 0x7c00;            //5 bits exponent
    if( exp == 0x7c00 )                   //NaN/Inf
        exp = 0x3fc00;                    //-> NaN/Inf
    else if( exp != 0 )                   //normalized value
    {
        exp += 0x1c000;                   //exp - 15 + 127
        if( mant == 0 && exp > 0x1c400 )  //smooth transition
            return Float.intBitsToFloat( ( hbits & 0x8000 ) << 16
                                            | exp << 13 | 0x3ff );
    }
    else if( mant != 0 )                  //&& exp==0 -> subnormal
    {
        exp = 0x1c400;                    //make it normal
        do {
            mant <<= 1;                   //mantissa * 2
            exp -= 0x400;                 //decrease exp by 1
        } while( ( mant & 0x400 ) == 0 ); //while not normal
        mant &= 0x3ff;                    //discard subnormal bit
    }                                     //else +/-0 -> +/-0
    return Float.intBitsToFloat(          //combine all parts
        ( hbits & 0x8000 ) << 16          //sign  << ( 31 - 15 )
        | ( exp | mant ) << 13 );         //value << ( 23 - 10 )
}

//returns all higher 16 bits as 0 for all results
public static int fromFloat( float fval )
{
    int fbits = Float.floatToIntBits( fval );
    int sign = fbits >>> 16 & 0x8000;          //sign only
    int val = ( fbits & 0x7fffffff ) + 0x1000; //rounded value

    if( val >= 0x47800000 )               //might be or become NaN/Inf
    {                                     //avoid Inf due to rounding
        if( ( fbits & 0x7fffffff ) >= 0x47800000 )
        {                                 //is or must become NaN/Inf
            if( val < 0x7f800000 )        //was value but too large
                return sign | 0x7c00;     //make it +/-Inf
            return sign | 0x7c00 |        //remains +/-Inf or NaN
                ( fbits & 0x007fffff ) >>> 13; //keep NaN (and Inf) bits
        }
        return sign | 0x7bff;             //unrounded not quite Inf
    }
    if( val >= 0x38800000 )               //remains normalized value
        return sign | val - 0x38000000 >>> 13; //exp - 127 + 15
    if( val < 0x33000000 )                //too small for subnormal
        return sign;                      //becomes +/-0
    val = ( fbits & 0x7fffffff ) >>> 23;  //tmp exp for subnormal calc
    return sign | ( ( fbits & 0x7fffff | 0x800000 ) //add subnormal bit
         + ( 0x800000 >>> val - 102 )     //round depending on cut off
      >>> 126 - val );   //div by 2^(1-(exp-127+15)) and >> 13 | exp=0
}

Implementiert habe ich zwei kleine Erweiterungen im Vergleich zu den Buch, weil die Allgemeine Präzision für 16-bit-floats ist eher gering, die könnten die inhärenten Anomalien von floating-point-Formate visuell wahrnehmbar sind, im Vergleich zu größeren floating-point-Typen, wo Sie sind in der Regel nicht bemerkt aufgrund der großen Präzision.

Dem ersten dieser beiden Zeilen in die toFloat() Funktion:

if( mant == 0 && exp > 0x1c400 )  //smooth transition
    return Float.intBitsToFloat( ( hbits & 0x8000 ) << 16 | exp << 13 | 0x3ff );

Floating-point-zahlen in den Normalbereich vom Typ Größe anzunehmen, der exponent und damit die Präzision, um die Größenordnung des Wertes. Aber dies ist nicht eine glatte Annahme, es geschieht in den Schritten: Wechsel auf die nächst höhere Exponenten Ergebnisse in der Hälfte der Präzision. Die Präzision bleibt nun das gleiche für alle Werte der Mantisse, bis der nächste Sprung in die nächst höhere Exponenten. Die Erweiterung code oben macht diese übergänge glatter durch Rücksendung einen Wert, der in der geografischen Mitte der enthaltenen 32-bit-float-Bereich für diese Besondere Hälfte einem float-Wert. Jeder normale Hälfte float-Wert-Karten, um genau 8192 32-bit-float-Werte. Der zurückgegebene Wert sein soll, genau in der Mitte dieser Werte. Aber am übergang von der Hälfte float exponent der unteren 4096 Werte in doppelter Genauigkeit wie die oberen 4096 Werte und decken somit eine Reihe Raum, der ist nur halb so groß wie auf der anderen Seite. All diese 8192 32-bit-float-Werte anzeigen, um die gleiche Hälfte einem float-Wert, so dass die Konvertierung eine halbe float zu 32-bit-und wieder die Ergebnisse in der gleichen Hälfte einem float-Wert unabhängig davon, welche 8192 intermediate 32-bit-Werten gewählt wurde. Die Erweiterung führt jetzt zu so etwas wie ein glatter halben Schritt um einen Faktor sqrt(2) am übergang (siehe unten rechts) Bild unten, während die linke Bild soll die Visualisierung der scharfen Schritt durch einen Faktor von zwei, ohne anti-aliasing. Sie können sicher entfernen Sie diese beiden Zeilen aus dem code, um das standard-Verhalten.

covered number space on either side of the returned value:
       6.0E-8             #######                  ##########
       4.5E-8             |                       #
       3.0E-8     #########               ########

Die zweite Erweiterung ist in der fromFloat() Funktion:

    {                                     //avoid Inf due to rounding
        if( ( fbits & 0x7fffffff ) >= 0x47800000 )
...
        return sign | 0x7bff;             //unrounded not quite Inf
    }

Dieser extension etwas erweitert, die Zahl der half-float-format durch speichern einige 32-bit-Werte bilden, immer gefördert "Unendlich". Die betroffenen Werte sind diejenigen, die gewesen wäre, die kleiner als Unendlich, ohne Rundung und würde sich die Unendlichkeit nur durch die Rundung. Sie können sicher entfernen Sie die Zeilen, die oben gezeigt, wenn Sie nicht möchten, dass diese Erweiterung.

Habe ich versucht zu optimieren, der Weg für den normalen Werten in der fromFloat() Funktion so viel wie möglich, die machte es ein wenig weniger lesbar durch die Verwendung von vorausberechneten und unshifted Konstanten. Ich habe nicht so viel in 'toFloat ()', da er nicht überschreiten würde die Leistung einer lookup-Tabelle sowieso. Also, wenn Geschwindigkeit wirklich wichtig ist könnte die toFloat() Funktion nur ausfüllen, statische lookup-Tabelle mit 0x10000 Elemente und verwenden Sie diese Tabelle für die eigentliche Konvertierung. Dies ist etwa 3 mal schneller mit einem aktuellen x64-server-VM und etwa 5-mal schneller mit dem x86-client-VM.

Ich den code hiermit in die public domain.

Vorher sah ich die Lösung hier gepostet, ich hatte bis Schlagsahne etwas einfaches:

public static float toFloat(int nHalf)
    {
    int S = (nHalf >>> 15) & 0x1;                                                             
    int E = (nHalf >>> 10) & 0x1F;                                                            
    int T = (nHalf       ) & 0x3FF;                                                           

    E = E == 0x1F                                                                            
            ? 0xFF  //it's 2^w-1; it's all 1's, so keep it all 1's for the 32-bit float       
            : E - 15 + 127;     //adjust the exponent from the 16-bit bias to the 32-bit bias

    //sign S is now bit 31                                                                    
    //exp E is from bit 30 to bit 23                                                          
    //scale T by 13 binary digits (it grew from 10 to 23 bits)                                
    return Float.intBitsToFloat(S << 31 | E << 23 | T << 13);                               
    }

Mir gefällt der Ansatz, in den anderen gepostet Lösung, obwohl. Referenz:

    //notes from the IEEE-754 specification:

    //left to right bits of a binary floating point number:
    //size        bit ids       name  description
    //----------  ------------  ----  ---------------------------
    //1 bit                       S   sign
    //w bits      E[0]..E[w-1]    E   biased exponent
    //t=p-1 bits  d[1]..d[p-1]    T   trailing significant field

    //The range of the encoding’s biased exponent E shall include:
    //― every integer between 1 and 2^w − 2, inclusive, to encode normal numbers
    //― the reserved value 0 to encode ±0 and subnormal numbers
    //― the reserved value 2w − 1 to encode +/-infinity and NaN

    //The representation r of the floating-point datum, and value v of the floating-point datum
    //represented, are inferred from the constituent fields as follows:
    //a) If E == 2^w−1 and T != 0, then r is qNaN or sNaN and v is NaN regardless of S
    //b) If E == 2^w−1 and T == 0, then r=v=(−1)^S * (+infinity)
    //c) If 1 <= E <= 2^w−2, then r is (S, (E−bias), (1 + 2^(1−p) * T))
    //   the value of the corresponding floating-point number is
    //       v = (−1)^S * 2^(E−bias) * (1 + 2^(1−p) * T)
    //   thus normal numbers have an implicit leading significand bit of 1
    //d) If E == 0 and T != 0, then r is (S, emin, (0 + 2^(1−p) * T))
    //   the value of the corresponding floating-point number is
    //       v = (−1)^S * 2^emin * (0 + 2^(1−p) * T)
    //   thus subnormal numbers have an implicit leading significand bit of 0
    //e) If E == 0 and T ==0, then r is (S, emin, 0) and v = (−1)^S * (+0)

    //parameter                                      bin16  bin32
    //--------------------------------------------   -----  -----
    //k, storage width in bits                         16     32
    //p, precision in bits                             11     24
    //emax, maxiumum exponent e                        15    127
    //bias, E-e                                        15    127
    //sign bit                                          1      1
    //w, exponent field width in bits                   5      8
    //t, trailing significant field width in bits      10     23