Convert / quantizzare Float Range per intero Gamma

Question

Dire che ho un galleggiante nel range di [0, 1] e voglio quantizzare e conservarla in un byte senza segno. Suona come un gioco da ragazzi, ma in realtà è piuttosto complicato:

La soluzione più ovvia è simile al seguente:

unsigned char QuantizeFloat(float a)
{
  return (unsigned char)(a * 255.0f);
}

Questo funziona nella misura che ho tutti i numeri da 0 a 255, ma la distribuzione dei numeri interi non è nemmeno. La funzione restituisce solo 255 se a è esattamente 1.0f. Non è una buona soluzione.

Se faccio una corretta arrotondamento ho solo spostare il problema:

unsigned char QuantizeFloat(float a)
{
  return (unsigned char)(a * 255.0f + 0.5f);
}

Qui il 0 il risultato copre solo metà del galleggiante gamma di qualsiasi altro numero.

Come posso fare una quantizzazione con equa distribuzione della gamma in virgola mobile? Idealmente mi piacerebbe avere una equa distribuzione dei numeri interi se quantizzare equamente distribuiti carri casuale.

Tutte le idee?

---

A proposito: anche il mio codice è in C il problema è indipendente dal linguaggio. Per le persone non-C: Basta pensare che float a int conversione tronca il galleggiante

.

Modifica Dato che avevamo una certa confusione qui: ho bisogno di una mappatura che mappa il galleggiante di ingresso più piccolo (0) al più piccolo unsigned char, e il più alto galleggiante della mia fascia (1.0f) per il byte senza segno (255).

Answer 1

Come su a * 256f con un assegno per ridurre 256-255? Quindi, qualcosa di simile a:

return (unsigned char) (min(255, (int) (a * 256f)));

(Per una opportuna funzione min sulla vostra piattaforma -. Non riesco a ricordare la funzione C per esso)

In sostanza si vuole dividere la gamma in 256 parti uguali, che è ciò che dovrebbe fare. Il caso limite di 1,0 andare a 256 e da arrotondando è solo perché il dominio è compreso ad entrambe le estremità.

Answer 2

Credo che ciò che si sta cercando è questo:

unsigned char QuantizeFloat (float a)
{
  return (unsigned char) (a * 256.0f);
}

Questo mappare i valori float uniformi in [0, 1] per valori di byte uniformi in [0, 255]. Tutti i valori in [i / 256, (i + 1) / 256 [(cioè escludendo (i + 1) / 256), per i in 0..255, vengono mappati i. Ciò che può essere indesiderabile è che 1.0f è mappato 256.0f che si avvolge attorno a 0.