C++ - Fixed Point number

[MItaly]

Riscriverei

unsigned int PSize = static_cast<unsigned int>(pow(2,Size));

evitando i double e pow, semplicemente come

unsigned int PSize = 1u<<Size;

(poi probabilmente il compilatore lo fa lo stesso, ma non si sa mai)

Poi, il masking sul secondo byte è sbagliato - il numero totale di bit da considerare è Size, ma su quel byte saranno PSize-8 (e se PSize è <8 devi prevedere un caso particolare per fare masking sul primo byte e prendere da lì il bit del segno, o dare un qualche genere di errore). Quindi direi:

if(Size<8)
    throw std::invalid_argument("Size must be >=8."); // o quel che ti pare
tempPtr[1]=ptr[1] & (((1<<(Size-8)) - 1);

(alcune parentesi potrebbero non essere necessarie, ma le regole di precedenza sugli operatori bitwise in C sono bizzarre, per cui nel dubbio abbondo )

Stessa questione per l'estrazione del segno: anche lì devi considerare la maschera per il secondo byte, non la maschera "globale"; tutto sommato, io quindi riscriverei il tutto così:

static inline float readF(const unsigned char * ptr, const int Size)
{
	if(Size<8 || Size>15)
		throw std::range_error("Size must be >=8 and <=15.");
	unsigned char signMask = 1u<<(Size-8);
	unsigned short temp;
	float out=(ptr[1] & signMask) ? -1.f : 0.f;
	unsigned char * tempPtr=(unsigned char *) & temp;
	tempPtr[0]=ptr[0];
	tempPtr[1]=ptr[1] & (signMask-1);
	out += float(temp) / float(1u<<Size);
	return out;
}

... ma, di nuovo, vedi se trovi documentazione più accurata su come vengono rappresentati i numeri negativi, che questa cosa non mi convince molto...

[shodan]

Mi limito a segnalare questo se foste interessati.
http://docs.oracle.com/cd/E19957-01/..._goldberg.html

[MItaly]

Originariamente inviato da shodan
Mi limito a segnalare questo se foste interessati.
http://docs.oracle.com/cd/E19957-01/..._goldberg.html

Ah ma questo è un classicone (e dopo che l'hai letto ti viene paura di fare qualcosa di sbagliato ogni volta che fai un'operazione con i double ), ma qui non credo che sia rilevante, dato che si tratta di numeri in virgola fissa.

[shodan]

Originariamente inviato da MItaly
Ah ma questo è un classicone (e dopo che l'hai letto ti viene paura di fare qualcosa di sbagliato ogni volta che fai un'operazione con i double ), ma qui non credo che sia rilevante, dato che si tratta di numeri in virgola fissa.

A dire il vero l'avevo messo tra le cose da studiare e mo ci rimarrà per un altro po'

[MItaly]

Originariamente inviato da shodan
A dire il vero l'avevo messo tra le cose da studiare e mo ci rimarrà per un altro po'

Ammetto di aver letto solo le parti che mi interessavano di più dopo aver sentito una lezione sommaria sui "caveat" principali di float e double... in ogni caso, sapere anche solo in linea di massima come funzionano i numeri in FP e i problemi ti dà un certo "timore reverenziale" nell'usarli

(tra l'altro, c'è anche una cospicua parte del secondo volume del Knuth che ne parla con abbondanza di dimostrazioni matematiche, quando arriverò lì ci sarà da ridere )

[XWolverineX]

Rileggerò il tuo post con il documento in mano domain poichè alcune cose del tuo ragionamento non mi sono chiare.
Preparati.

[MItaly]

[XWolverineX]

Il tuo codice è quello giusto (non c'erano dubbi).
Ora ottengo un bel numero float da 0 a 1, molto bene.

Le uniche altre info che ho trovato, frattanto, è che tal numero rappresenta un misurando campionato a 2,4 volte il valore originale. Non chiedermi il perchè di questa cosa (limitare gli overflow?).

Ordunque dato il mio numero F, prima cosa divido per 2.4 e poi devo scalarlo per ottenere il VERO valore.

[XWolverineX]

Ho delle novità per questi maledetti F13.
Inoltre ricapitolerò un pò tutto.

Devo leggere un tipo di dato particolare incapsulato in un intero a 16 bit:



il cui Fi (con I = 13) è definito in questo modo.



Questo valore rappresenta una misura che un particolare dispositivo mi sta inviando.
A tal proposito la formula per riconvertire il numero ottenuto nel numero originale è la seguente



Come devo trattare questo maledetto tipo? Una maschera sui primi 3 bit, valutare il segno e poi leggerne il modulo?

Non sono ancora riuscito a venirne a capo con il codice.
Nel frattempo mi sono segnato delle coppie valore reale - intero 16 bit letto così da poter eventualemente fare un minimo di confronto.

In particolare (con Primary = 100)
Valore reale: 9.8 -> 1360
Valore reale: 19.8 -> 2696
Valore reale: 29.8 -> 4056

Valore reale: 87 -> 13712
Valore reale: 75 -> 11824
Valore reale: 90 -> 14184

[MItaly]

Mh sai cosa mi convince? Che nell'esempio che fa usa come valore di riferimento 1234, ovvero un intero, mentre quello che ricevi nell'F13 è un numero decimale, e minore di 1 per definizione. Sei sicuro che nei vari documenti si stia parlando della stessa roba?