Valutare se due doppi sono uguali in base a una determinata precisione, non entro una certa tolleranza fissa

Question

Sono in esecuzione test NUnit per valutare alcuni dati di test noti e risultati calcolati. I numeri sono in virgola mobile a virgola mobile quindi non mi aspetto che siano esattamente uguali, ma non sono sicuro di come trattarli come uguali per una determinata precisione.

In NUnit possiamo confrontare con una tolleranza fissa:

double expected = 0.389842845321551d; 
double actual = 0.38984284532155145d; // really comes from a data import 
Expect(actual, EqualTo(expected).Within(0.000000000000001)); 

e che funziona bene per i numeri sotto lo zero, ma, come i numeri crescono la tolleranza ha davvero bisogno di essere cambiato così abbiamo sempre a cuore lo stesso numero di cifre di precisione.

In particolare, questo test fallisce:

double expected = 1.95346834136148d; 
double actual = 1.9534683413614817d; // really comes from a data import 
Expect(actual, EqualTo(expected).Within(0.000000000000001)); 

e, naturalmente, i numeri più grandi non riescono con la tolleranza ..

double expected = 1632.4587642911599d; 
double actual = 1632.4587642911633d; // really comes from a data import 
Expect(actual, EqualTo(expected).Within(0.000000000000001)); 

Qual è il modo corretto di valutare due numeri in virgola mobile sono uguali con una data precisione ? C'è un modo integrato per farlo in NUnit?

Answer 1

da MSDN:

Per default, un valore doppio contiene 15 cifre decimali di precisione, anche se viene mantenuto un massimo di 17 cifre internamente.

Supponiamo 15, quindi.

Quindi, potremmo dire che vogliamo che la tolleranza sia nella stessa misura.

Quante cifre precise abbiamo dopo il punto decimale? Abbiamo bisogno di conoscere la distanza della cifra più significativa dal punto decimale, giusto?La grandezza. Possiamo ottenere questo con un Log10.

Quindi dobbiamo dividere 1 per 10^precisione per ottenere un valore attorno alla precisione che vogliamo.

Ora, è necessario fare di più casi di test di me, ma questo sembra funzionare:

double expected = 1632.4587642911599d; 
    double actual = 1632.4587642911633d; // really comes from a data import 

    // Log10(100) = 2, so to get the manitude we add 1. 
    int magnitude = 1 + (expected == 0.0 ? -1 : Convert.ToInt32(Math.Floor(Math.Log10(expected)))); 
    int precision = 15 - magnitude ; 

    double tolerance = 1.0/Math.Pow(10, precision); 

    Assert.That(expected, Is.EqualTo(actual).Within(tolerance)); 

È tardi - ci potrebbe essere un Gotcha qui. L'ho provato contro i tuoi tre set di dati di test e passati tutti. La modifica di in 16 - magnitude ha causato il fallimento del test. Impostandolo su 14 - magnitude, ovviamente, si è verificato un errore mentre la tolleranza era maggiore.

Answer 2

Come convertire gli articoli in stringa e confrontare le stringhe?

string test1 = String.Format("{0:0.0##}", expected); 
string test2 = String.Format("{0:0.0##}", actual); 
Assert.AreEqual(test1, test2); 

Answer 3

Non so se c'è un modo integrato di farlo con NUnit, ma vorrei suggerire moltiplicando ciascun galleggiante dal 10x la precisione che stai cercando, memorizzare i risultati come anela, e il confronto i due si allungano l'un l'altro.
Per esempio:

double expected = 1632.4587642911599d; 
double actual = 1632.4587642911633d; 
//for a precision of 4 
long lActual = (long) 10000 * actual; 
long lExpected = (long) 10000 * expected; 

if(lActual == lExpected) { // Do comparison 
    // Perform desired actions 
} 

Answer 4

Questa è una rapida idea, ma come su di loro spostando verso il basso fino a quando non sono sotto lo zero? Dovrebbe essere qualcosa come num/(10^ceil(log10(num))). . . non sono sicuro di come funzionerebbe, ma è un'idea.

1632.4587642911599/(10^ceil(log10(1632.4587642911599))) = 0.16324587642911599 

Answer 5

Questo è quello che mi è venuta per The Floating-Point Guide (codice Java, ma dovrebbe tradursi facilmente, e viene fornito con una suite di test, che si ha realmente realmente bisogno):

public static boolean nearlyEqual(float a, float b, float epsilon) 
{ 
    final float absA = Math.abs(a); 
    final float absB = Math.abs(b); 
    final float diff = Math.abs(a - b); 

    if (a * b == 0) { // a or b or both are zero 
     // relative error is not meaningful here 
     return diff < (epsilon * epsilon); 
    } else { // use relative error 
     return diff/(absA + absB) < epsilon; 
    } 
} 

La domanda davvero difficile è cosa fare quando uno dei numeri da confrontare è zero. La migliore risposta potrebbe essere che tale confronto dovrebbe sempre considerare il significato del dominio dei numeri confrontati piuttosto che cercare di essere universale.

Answer 6

stai:

const double significantFigures = 10; 
Assert.AreEqual(Actual/Expected, 1.0, 1.0/Math.Pow(10, significantFigures));