Conversione da virgola mobile a doppia: la migliore affermazione in un test di unità?

Question

Considerate le dichiarazioni

float f = 7.1f; 
double d = f; 

Quello che possiamo affermare in una prova di unità su d?

---

Per esempio, questo non funziona:

Console.WriteLine(d == 7.1d); // false 
Console.WriteLine(d < 7.1d + float.Epsilon); // true by luck 
Console.WriteLine(d > 7.1d - float.Epsilon); // false (less luck) 

Il modo migliore che ho trovato finora è quello di convertire il valore indietro:

float f2 = (float)d; 
Console.WriteLine(f2 == f); // true 

Quale sarebbe lo stesso come il bruto modo per dire

Console.WriteLine(d == 7.1f); // 7.1f implicitly converted to double as above 

Questa domanda NON riguarda la precisione del doppio e del float in generale, ma SOLO la questione pragmatica su come un test unitario possa descrivere al meglio i confini di d. Nel mio caso, d è il risultato di una conversione che si verifica nel codice generato dalla generazione di codice leggero. Mentre collaudo questa generazione di codice, devo fare delle asserzioni sul risultato di questa funzione e questo si riduce alla semplice domanda precedente.

Answer 1

Il "modo migliore" è affermare che il codice generato restituisce qualcosa che è, entro il margine di errore float, 7.1. Questo può essere ciò che vuoi controllare, nel qual caso continuare.

D'altra parte, si potrebbe desiderare di affermare che il codice generato ritorna specificamente il risultato della fusione 7.1f ad un double, nel qual caso si potrebbe fare:

Console.WriteLine(d == (double)f); 

Questo è più stringente - il tuo test asserisce che d si trova entro un intervallo ristretto, mentre il test precedente afferma che d è un valore specifico.

Dipende molto da cosa si utilizzerà d per. Se si tratta di un caso in cui le cose andranno storte se non è il valore esatto, testare il valore esatto, ma se è OK essere all'interno di un valore float, controllare lo float.

Answer 2

per confrontare i valori di due punti galleggiante ibm sugests testare abs(a/b - 1) < epsilon

un msnd afferma che Epsilon proprietà riflette il più piccolo valore positivo che è rilevante in operazioni numeriche o confronti quando il valore dell'istanza è zero.

quindi in realtà si dovrebbe verificare

Math.Abs(d/(double)f) - 1) < float.Epsilon) 

Answer 3

(float) d == f.

Un'altra risposta suggerita d == (double) f, ma questo è un test inutile perché (double) f esegue la stessa conversione che esegue d = f implicitamente. Quindi l'unica cosa che questa asserzione potrebbe essere testata è se alcuni aspetti dell'implementazione siano infranti (ad es., il compilatore ha implementato una delle conversioni in modo errato e diverso dall'altra), alcuni meccanismi esterni sono stati modificati d o f tra l'assegnazione e l'asserzione, oppure il codice sorgente è stato interrotto in modo che d non era né double né float né alcun tipo che può contenere esattamente il valore di f o che l'assegnazione d = f non è stata eseguita.

Generalmente, non ci aspettiamo errori in virgola mobile, perché, in ogni normale implementazione di virgola mobile, la conversione da una precisione più stretta a una più ampia precisione della stessa radice non ha errori, poiché la precisione più ampia può rappresentare ogni valore la precisione più stretta possibile. In situazioni non comuni, un formato a virgola mobile più ampio potrebbe avere un intervallo di esponenti più piccolo. Solo in questo caso, o in formati a virgola mobile definiti perversamente, la conversione in un formato più ampio può causare una variazione di valore. In questi casi, l'esecuzione della stessa conversione non rileva la modifica.

Invece, convertiamo dal formato più ampio nuovamente nel formato più stretto. Se d differisce da f, questa conversione ha la possibilità di rilevare l'errore. Ad esempio, supponiamo che f contenga 0x1p-1000, ma, per qualche ragione, non è rappresentabile nel formato di d, quindi è stato arrotondato a zero. Quindi (float) d == f restituisce (float) 0 == 0x1p-1000, quindi 0 == 0x1p-1000, quindi false. Inoltre, questo test può rilevare gli stessi errori dell'altro suggerimento: un'implementazione non funzionante, l'alterazione di d o f, un tipo errato di d e un'assegnazione mancante di d = f.

A parte questo, quali errori vorresti rilevare con un'asserzione qui?