Convertir int 16 bits float (la moitié de précision à virgule flottante) en c++

Comment puis-je convertir un integer à un half precision float (qui doit être stocké dans un tableau unsigned char[2]). La gamme à l'entrée int sera de 1 à 65535. La précision n'est pas vraiment un souci.

Je suis en train de faire quelque chose de similaire pour la conversion à l' 16bit int dans un unsigned char[2], mais je comprends, il n'est pas half precision float C++ type de données. Exemple ci-dessous:

int16_t position16int = (int16_t)data;
memcpy(&dataArray, &position16int, 2);
Peut-être pertinentes : gamedev.stackexchange.com/a/17410/9333
Avec la pointe de Goz peut-être de les aider: 32 bits à 16 bits à virgule Flottante Conversion

OriginalL'auteur Ross | 2012-10-10

  1. 4

    C'est très simple chose, toutes les informations dont vous avez besoin dans Wikipédia.

    Exemple de mise en œuvre:

    #include <stdio.h>
unsigned int2hfloat(int x)
{
unsigned sign = x < 0;
unsigned absx = ((unsigned)x ^ -sign) + sign; //safe abs(x)
unsigned tmp = absx, manbits = 0;
int exp = 0, truncated = 0;
//calculate the number of bits needed for the mantissa
while (tmp)
{
tmp >>= 1;
manbits++;
}
//half-precision floats have 11 bits in the mantissa.
//truncate the excess or insert the lacking 0s until there are 11.
if (manbits)
{
exp = 10; //exp bias because 1.0 is at bit position 10
while (manbits > 11)
{
truncated |= absx & 1;
absx >>= 1;
manbits--;
exp++;
}
while (manbits < 11)
{
absx <<= 1;
manbits++;
exp--;
}
}
if (exp + truncated > 15)
{
//absx was too big, force it to +/- infinity
exp = 31; //special infinity value
absx = 0;
}
else if (manbits)
{
//normal case, absx > 0
exp += 15; //bias the exponent
}
return (sign << 15) | ((unsigned)exp << 10) | (absx & ((1u<<10)-1));
}
int main(void)
{
printf(" 0: 0x%04X\n", int2hfloat(0));
printf("-1: 0x%04X\n", int2hfloat(-1));
printf("+1: 0x%04X\n", int2hfloat(+1));
printf("-2: 0x%04X\n", int2hfloat(-2));
printf("+2: 0x%04X\n", int2hfloat(+2));
printf("-3: 0x%04X\n", int2hfloat(-3));
printf("+3: 0x%04X\n", int2hfloat(+3));
printf("-2047: 0x%04X\n", int2hfloat(-2047));
printf("+2047: 0x%04X\n", int2hfloat(+2047));
printf("-2048: 0x%04X\n", int2hfloat(-2048));
printf("+2048: 0x%04X\n", int2hfloat(+2048));
printf("-2049: 0x%04X\n", int2hfloat(-2049)); //first inexact integer
printf("+2049: 0x%04X\n", int2hfloat(+2049));
printf("-2050: 0x%04X\n", int2hfloat(-2050));
printf("+2050: 0x%04X\n", int2hfloat(+2050));
printf("-32752: 0x%04X\n", int2hfloat(-32752));
printf("+32752: 0x%04X\n", int2hfloat(+32752));
printf("-32768: 0x%04X\n", int2hfloat(-32768));
printf("+32768: 0x%04X\n", int2hfloat(+32768));
printf("-65504: 0x%04X\n", int2hfloat(-65504)); //legal maximum
printf("+65504: 0x%04X\n", int2hfloat(+65504));
printf("-65505: 0x%04X\n", int2hfloat(-65505)); //infinity from here on
printf("+65505: 0x%04X\n", int2hfloat(+65505));
printf("-65535: 0x%04X\n", int2hfloat(-65535));
printf("+65535: 0x%04X\n", int2hfloat(+65535));
return 0;
}

    De sortie (ideone):

     0: 0x0000
-1: 0xBC00
+1: 0x3C00
-2: 0xC000
+2: 0x4000
-3: 0xC200
+3: 0x4200
-2047: 0xE7FF
+2047: 0x67FF
-2048: 0xE800
+2048: 0x6800
-2049: 0xE800
+2049: 0x6800
-2050: 0xE801
+2050: 0x6801
-32752: 0xF7FF
+32752: 0x77FF
-32768: 0xF800
+32768: 0x7800
-65504: 0xFBFF
+65504: 0x7BFF
-65505: 0xFC00
+65505: 0x7C00
-65535: 0xFC00
+65535: 0x7C00
    simple 😀 ...
    simple si vous savez assez de mathématiques au secondaire.
    Il convient de noter que ce code a anormaux arrondissement comportement. En grande partie, il tronque plutôt que des tours à la plus proche (ce qui est plus fréquent), mais est anormale à l'extrémité supérieure. Entrées supérieur à la valeur maximale représentable finis valeur sont convertis à l'infini, plutôt que d'être tronqué à l'instar d'autres entrées, même si elles ne sont que légèrement supérieure à la valeur maximale. Par exemple 0xfff (4095) est converti à 0x6bff (4094), mais 0xfff0 (65520) ou 0xffe1 (65505) est converti à 0x7c00 (infini) plutôt que de 0x7bff (65504).
    Vous avez raison. Mais c'était mon interprétation de Precision is really not a concern.

    OriginalL'auteur Alexey Frunze

  2. 2

    J'ai posé la question de comment faire pour convertir 32-bit floating points à 16 bits à virgule flottante.

    Float32 pour Float16

    À partir de laquelle vous pouvez facilement convertir l'int d'un flotteur et d'utiliser ensuite la question ci-dessus pour créer un 16-bit à virgule flottante. Je suggère que c'est probablement beaucoup plus facile que de passer de int directement sur 16 bits à virgule flottante. Effectivement, par la conversion à virgule flottante de 32 bits que vous avez fait la plupart du labeur et puis vous avez juste besoin de passer un peu de bits.

    Edit: en Regardant Alexey excellente réponse je pense qu'il est très probable que l'utilisation d'un matériel int float conversion et le décalage de bits autour est susceptible d'être un peu juste plus rapide que sa méthode. Peut-être la peine de profilage des deux méthodes et en les comparant.

    OriginalL'auteur Goz

  3. 0

    Suivant @kbok question commentaire que j'ai utilisé la première partie de cette réponse pour obtenir la moitié de flotter et d'obtenir ensuite le tableau:

    uint16_t position16float = float_to_half_branch(data);
memcpy(&dataArray, &position16float, 2);

    OriginalL'auteur Ross