Conversión int a flotación de 16 bits (coma flotante de precisión media) en C++

Question

¿Cómo puedo convertir un integer en un half precision float (que se almacenará en una matriz unsigned char[2]). El rango a la entrada int será desde 1-65535. La precisión realmente no es una preocupación.

Estoy haciendo algo similar para convertir a 16bit int en un unsigned char[2], pero entiendo que no hay half precision float tipo de datos C++. Ejemplo de esto a continuación:

int16_t position16int = (int16_t)data; 
memcpy(&dataArray, &position16int, 2); 

Answer 1

Es una cosa muy sencilla, toda la información que necesita está en Wikipedia . aplicación

muestra:

#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; 
} 

salida (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 

Answer 2

me hizo la pregunta de cómo convertir números en coma flotante de 32 bits de coma flotante de 16 bits.

Float32 to Float16

Así que desde que se podía convertir fácilmente el int a un flotador y luego usar la pregunta anterior para crear un flotador de 16 bits. Sugeriría que esto es probablemente mucho más fácil que pasar de int directamente al float de 16 bits. Efectivamente al convertir a flotación de 32 bits ha hecho la mayor parte del trabajo duro y luego solo necesita cambiar algunas partes.

Editar: Viendo la excelente respuesta de Alexey, creo que es muy probable que usar un hardware int para la conversión flotante y luego cambiarlo sea probablemente un poco más rápido que su método. Puede valer la pena perfilar ambos métodos y compararlos.

Answer 3

comentario siguiente pregunta @kbok He utilizado la primera parte de this answer para obtener el medio de flotación y después de obtener la matriz:

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

Answer 4

Si usted está apuntando al hardware soportado, puede utilizar las características intrínsecas:

https://software.intel.com/en-us/articles/performance-benefits-of-half-precision-floats https://software.intel.com/sites/products/documentation/doclib/iss/2013/compiler/cpp-lin/GUID-7679FF37-257B-4F90-8668-5B3AA62587AD.htm