Porównywanie wartości podwójnych w C#

double i Double są takie same (double jest aliasem dla Double) i mogą być używane zamiennie.

Problem z porównaniem dwójki z inną wartością polega na tym, że dwójki są wartościami przybliżonymi, a nie dokładnymi. Więc kiedy ustawisz x na 0.1 może to być w rzeczywistości zapisane jako 0.100000001 lub coś w tym stylu.

Zamiast sprawdzać równość, należy sprawdzić, czy różnica jest mniejsza niż określona minimalna różnica (tolerancja). Coś w stylu:

if (Math.Abs(x - 0.1) < 0.0000001)
{
    ...
}

Potrzebujesz kombinacji Math.Abs on X-Y i value, aby porównać z.

Możesz użyć następującej metody rozszerzenia

public static class DoubleExtensions
    {
        const double _3 = 0.001;
        const double _4 = 0.0001;
        const double _5 = 0.00001;
        const double _6 = 0.000001;
        const double _7 = 0.0000001;

        public static bool Equals3DigitPrecision(this double left, double right)
        {
            return Math.Abs(left - right) < _3;
        }

        public static bool Equals4DigitPrecision(this double left, double right)
        {
            return Math.Abs(left - right) < _4;
        }

        ...

Ponieważ rzadko wywołujesz metody na double z wyjątkiem ToString uważam, że jest to całkiem bezpieczne rozszerzenie.

Następnie możesz porównać x i y Jak

if(x.Equals4DigitPrecision(y))

Porównywanie liczb zmiennoprzecinkowych nie zawsze może być wykonane dokładnie z powodu zaokrąglania. Do porównania

(x == .1)

Komputer naprawdę porównuje

(x - .1) vs 0

Wynik sybktrakcji nie zawsze może być dokładnie określony ze względu na sposób reprezentacji liczb zmiennoprzecinkowych na maszynie. Dlatego otrzymujesz wartość niezerową i warunek jest obliczany na false.

Aby przezwyciężyć to porównanie

Math.Abs(x- .1) vs some very small threshold ( like 1E-9)

Z dokumentacji:

Precyzja w porównaniach Metoda Equals powinna być stosowana ostrożnie, ponieważ dwie pozornie równoważne wartości mogą być nierówne ze względu na różną dokładność tych dwóch wartości. Poniższy przykład informuje, że Podwójna wartość .3333 i podwójne zwrócone przez podzielenie 1 przez 3 są nierówne.

...

Zamiast porównywać dla równości, jedna zalecana technika polega na zdefiniowaniu dopuszczalnego marginesu różnica między dwiema wartościami (np.01% jednej z wartości). Jeżeli wartość bezwzględna różnicy między tymi dwoma wartościami jest mniejsza lub równa temu marginesowi, różnica prawdopodobnie wynika z różnic w dokładności, a zatem wartości mogą być równe. Poniższy przykład wykorzystuje tę technikę do porównania .33333 i 1/3, dwie podwójne wartości, które poprzedni przykład kodu uznał za nierówne.

Więc jeśli naprawdę potrzebujesz sobowtóra, powinieneś użyć techique opisane w dokumentacji. Jeśli możesz, Zmień go na dziesiętny. będzie wolniej , ale nie będziesz miał tego typu problemów.

Podwójne i podwójne są identyczne.

Zobacz http://www.yoda.arachsys.com/csharp/floatingpoint.html . Krótko mówiąc: double nie jest dokładnym typem i minutowa różnica między " x " i " 0.1 " wyrzuci go.

Dokładne porównanie wartości zmiennoprzecinkowych nie zawsze działa ze względu na problem zaokrąglania i reprezentacji wewnętrznej.

Spróbuj nieprecyzyjnego porównania:

if (x >= 0.099 && x <= 0.101)
{
}

Inną alternatywą jest użycie typu danych decimal.

Użyj decimal. Nie ma tego "problemu".

1) powinienem użyć podwójnego czy podwójnego???

Double i double to to samo. double jest tylko słowem kluczowym C# działającym jako alias dla klasy System.Double Najczęściej używa się aliasów! To samo dla string (System.String), int(System.Int32)

Zobacz także Wbudowana tabela typów (C # Reference)

Double (w niektórych językach nazywany float) jest fraut z problemami z powodu problemów z zaokrągleniem, jest dobry tylko wtedy, gdy potrzebujesz przybliżonych wartości.

Typ danych dziesiętnych robi to, co chcesz.

Dla odniesienia decimal i Decimal są takie same w. Net C#, podobnie jak typy double i Double, oba odnoszą się do tego samego typu (decimal i double są bardzo różne, jak już widziałeś).

Uważaj, że typ danych dziesiętnych ma pewne koszty związane z nim, więc użyj go z uwaga, jeśli patrzysz na pętle itp.

Reprezentacje liczb zmiennoprzecinkowych są notorycznie niedokładne (ze względu na sposób, w jaki pływaki są przechowywane wewnętrznie), np. x może mieć wartość 0.09999999999 lub 0.100000001 i twój warunek się nie powiedzie. Jeśli chcesz określić, czy pływaki są równe, musisz określić, czy są równe w ramach określonej tolerancji.

Tzn.

if(x - 0.1 < tol)

Jako ogólna zasada:

Podwójna reprezentacja jest wystarczająco dobra w większości przypadków, ale w niektórych sytuacjach może się źle skończyć. Użyj wartości dziesiętnych, jeśli potrzebujesz pełnej precyzji (jak w aplikacjach finansowych).

Większość problemów z dublami nie wynika z bezpośredniego porównania, jest to wynik kumulacji kilku operacji matematycznych, które wykładniczo zakłócają wartość z powodu błędów zaokrąglania i ułamków (zwłaszcza z mnożeniem i podziałem).

Sprawdź twoja logika, jeśli kod jest:

x = 0.1

if (x == 0.1)

To nie powinno się nie udać, to proste do niepowodzenia, jeśli wartość X jest obliczana bardziej złożonymi środkami lub operacjami, jest całkiem możliwe, że metoda ToString używana przez debugger używa inteligentnego zaokrąglania, może możesz zrobić to samo (jeśli jest to zbyt ryzykowne wróć do używania dziesiętnego): {]}

if (x.ToString() == "0.1")

Fajny hack znalazłem jest użycie metody .GetHashCode(), która zwraca int, który reprezentuje podwójne, tzn.

(0.4d + 0.3d + 0.2d + 0.1d).GetHashCode() //returns -1072693248

1d.GetHashCode() //returns 1072693248

Więc jak już zauważyłeś możemy użyć czegoś takiego

public static bool AccurateEquality(double first,double second)
{
    return Math.Abs(first.GetHashCode()) == Math.Abs(second.GetHashCode());
}

Użycie : AccurateEquality((0.4d + 0.3d + 0.2d + 0.1d),1) //returns true

While: (0.4d + 0.3d + 0.2d + 0.1d) == 1d //returns false

Próbowałem go w wielu przypadkach i wydaje się, że działa dobrze.

Biorąc napiwek z bazy kodu Javy, spróbuj użyć .CompareTo i przetestuj zerowe porównanie. Zakłada to, że funkcja .CompareTo uwzględnia równość zmiennoprzecinkową w dokładny sposób. Na przykład,

System.Math.PI.CompareTo(System.Math.PI) == 0

Ten predykat powinien zwrócić true.

Większość powyżej sposobów lub po głupi sposób rozszerzenia!

public static bool EqualsTo(this double value, double value2)
{
    var bytes1 = BitConverter.GetBytes(value);
    var bytes2 = BitConverter.GetBytes(value2);

    var long1 = BitConverter.ToInt64(bytes1, 0);
    var long2 = BitConverter.ToInt64(bytes2, 0);

    return long1 == long2;
}