Jak już wiemy, błędy obliczeń numerycznych mogą wynikać z wielu przyczyn. Często są związane  m.in. z błędnymi danymi wejściowymi, niepoprawnymi zaokrągleniami, obcięciami części ułamkowej, konwersją między systemami liczbowymi oraz reprezentacją bitową.

Zacznijmy od pokazania paru mechanizmów w języku Java, które pomogą nam zrozumieć naturę błędów związanych z reprezentacją liczb zmiennoprzecinkowych. Przypomnijmy, jakimi typami prostymi dysponujemy w języku Java:

1. boolean – 1 bitowy typ true lub false,

2. char – 8‑bitowy typ znakowy,

3. byte – 8‑bitowy typ całkowity,

4. short – 16‑bitowy typ całkowity,

5. int – 32‑bitowy typ całkowity,

6. long – 64‑bitowy typ całkowity,

7. float – 32‑bitowy typ zmiennoprzecinkowy w standardzie IEEE 754,

8. double – 64‑bitowy typ zmiennoprzecinkowy w standardzie IEEE 754.

Każdy z typów prostych posiada odpowiadający mu typ referencyjnytyp referencyjnytyp referencyjny, który oznaczamy tak samo, tylko wielką literą. W nowych wersjach Javy wprowadzono mechanizm pakowania oraz rozpakowywania (ang. boxing, unboxing), który dba o to, aby arytmetyka na tych dwóch typach mogła odbywać się bez potrzeby ręcznego odczytywania wartości z obiektów w kodzie.

W klasach odpowiadających wspomnianym typom prostym występuje wiele przydatnych metod związanych z reprezentacją bitową liczb.

• W klasie Double możemy znaleźć np. metodę double doubleToLongBits(double value), która daną 64‑bitową reprezentację zmiennej value typu double zamieni na 64‑bitową reprezentację typu long.

• W klasie Long zaś występuje metoda String toBinaryString(long i), która daną zmienną i typu long zamieni na ciąg znaków, który stanowił będzie binarną reprezentację zmiennej i. Niestety, funkcja ta pominie zera wiodące. Możemy jednak to poprawić, uzupełniając otrzymany ciąg odpowiednią ilością zer z przodu.

Wykorzystując wspomniane metody, w prosty sposób napiszemy funkcję, która wypisze na ekranie binarną reprezentację zmiennej typu double.

public static void wypiszBinarnaReprezentacje(double zmiennoprzecinkowa) {
    // zamień bitowo double na long
    long zapisBitowy = Double.doubleToLongBits(zmiennoprzecinkowa);
    // zamień long binarnie na String
    String str = Long.toBinaryString(zapisBitowy);

    // wypisz poprzedzające zera
    for (int i = 0; i < 64 - str.length(); ++i) {
        System.out.print("0");
    }

    System.out.print(str);
    System.out.print("\n");
}

Sprawdźmy zatem, za pomocą poniższego kodu, jak wygląda reprezentacja bitowa liczby 1.3:

double zmiennoprzecinkowa = 1.3;
wypiszBinarnaReprezentacje(zmiennoprzecinkowa);

W wyniku uruchomienia powyższych linijek w programie, na ekranie wypisany zostanie poniższy ciąg znaków:

0011111111110100110011001100110011001100110011001100110011001101

Wiemy już, że pierwszy bit jest bitem znaku. Kolejne 11 bitów to bity wykładnika, a ostatnie 52 bity to mantysa.

W języku Java występuje też klasa BigDecimal, która może nam posłużyć w celu wypisania rzeczywistej wartości przechowywanej w zmiennej typu double. Poniższa funkcja wypisze dla nas tę wartość.

public static void wypiszDokladnaWartosc(double zmiennoprzecinkowa) {
    BigDecimal duzaDokladnosc = new BigDecimal(zmiennoprzecinkowa);
    System.out.println(duzaDokladnosc);
}

Wykorzystajmy ją, aby wypisać dokładniejszą wartość reprezentacji bitowej liczby 1.3:

double zmiennoprzecinkowa = 1.3;
wypiszDokladnaWartosc(zmiennoprzecinkowa);

Wynik uruchomienia powyższego kodu:

1.3000000000000000444089209850062616169452667236328125

Widzimy zatem, że nie jesteśmy w stanie w dokładny sposób przechowywać liczby 1.3 w postaci zgodnej z IEEE 754. W tym systemie liczba ta jest niewymierna, a jej mantysa musiałaby wyglądać następująco:

110(1001)

Liczby zapisane w nawiasie są w okresie. Na mantysę przypadają tylko 52 bity, jest zatem ograniczona dokładność takich liczb.

Niedokładność reprezentacji IEEE 754

Najważniejszą zasadą związaną z unikaniem błędów numerycznych jest zachowywanie odpowiedniej ostrożności podczas wykonywania algorytmów iteracyjnych. Przyjrzyjmy się poniższemu błędnie skonstruowanemu programowi:

double zmiennoprzecinkowa = 1.3;

int i = 0;
while (zmiennoprzecinkowa != 2.0) {
    zmiennoprzecinkowa += 0.1;
    ++i;
}

System.out.println(i);

Przedstawiony algorytm ma za zadanie dodawać do zmiennej o nazwie zmiennoprzecinkowa wartość 0.1 do momentu, gdy wartość zmiennej osiągnie 2.0. Według prostej logiki pętla powinna wykonać się 7 razy, a program wypisze 7 na ekranie. Co jednak stanie się, gdy rzeczywiście uruchomimy program? Będzie on wykonywał się w nieskończoność. Aby poznać przyczynę tego problemu, przyjrzyjmy się reprezentacji bitowej oraz dokładniejszej wartości liczb przechowywanych w programie.

Liczba 2.0 jest reprezentowana następująco:

0100000000000000000000000000000000000000000000000000000000000000
2

Zmienna zmiennoprzecinkowa po wykonaniu 7 iteracji prezentuje się następująco:

0100000000000000000000000000000000000000000000000000000000000001
2.000000000000000444089209850062616169452667236328125

Liczba 2.0 zatem posiada swoją dokładną reprezentację w standardzie IEEE 754. W przypadku wartości, którą przechowuje zmienna zmiennoprzecinkowa, tak nie jest. Wartość jest bardzo zbliżona do wartości 2. Wynika to z faktu, iż liczba 1.3 jest zapisana w pamięci komputera z pewną niedokładnością, której istnienie zostało przez nas pominięte. Z tego względu należy rozważnie dobierać warunek końca algorytmu iteracyjnego i w odpowiedni sposób zabezpieczyć program przed błędami wynikającymi z niedokładności liczb w standardzie IEEE 754. Zabronione jest stosowanie warunku stop, który będzie określony jako osiągnięcie konkretnej wartości.

Aby poradzić sobie z tym problemem, jest zalecane wprowadzenie pewnego rodzaju tolerancji do interesującego nas wyniku. Zamiast sprawdzać, czy została osiągnięta określona wartość, możemy sprawdzić, czy mieści się ona w granicach tolerancji. W przypadku naszego algorytmu może to wyglądać w następujący sposób:

double zmiennoprzecinkowa = 1.3;

int i = 0;
double epsilon = 0.01;
while (Math.abs(2.0 - zmiennoprzecinkowa) > epsilon) {
    zmiennoprzecinkowa += 0.1;
    ++i;
}

System.out.println(i);

Zauważ, że w obecnej sytuacji interesująca nas wartość zmiennej będzie mieściła się w przedziale $(2.0-$epsilon$,2.0+$epsilon$)$. Zdefiniowany tak warunek to nic innego jak określenie maksymalnej wartości, jaką może przyjąć błąd bezwzględny.

Błąd bezwzględny i względny

Aby poradzić sobie z niedokładnościami obliczeniowymi, możemy wykorzystać pojęcie błędu bezwzględnego i względnego.

Błąd bezwzględny definiujemy następująco:

gdzie:

$x$ – wartość rzeczywista,

$x_z$ – wartość zmierzona.

Błąd względny zaś możemy zdefiniować, wykorzystując błąd bezwzględny:

Oba pojęcia możemy wykorzystać w celu przerwania procedur iteracyjnych. W przypadku gdy osiągniemy pewien z góry określony poziom błędu, przerywamy wykonywanie pętli.

Pokazaliśmy już przykład przerywania pętli z wykorzystaniem błędu bezwzględnego. Aby pokazać przykład błędu względnego, wprowadźmy pewną sumę szeregu matematycznego:

Suma ta jest nieskończona, dlatego możemy co najwyżej przybliżyć jej wartość. Czy jesteśmy w stanie stwierdzić, ile elementów ciągu musimy zsumować, aby oszacować wartości powyższej sumy na poziomie błędu względnego 0.5%. Poniższy program przeprowadza sumowanie do momentu, gdy osiągniemy zadaną dokładność. Po tym procesie wypisuje wszystkie przydatne informacje.

// błąd względny
double epsilon = 0.005;
int n = 1;
double wartoscObliczona = 0.0;
double wartoscOczekiwana = Math.PI * Math.PI / 6;
while (Math.abs(wartoscOczekiwana - wartoscObliczona)/wartoscOczekiwana >  epsilon) {
    wartoscObliczona += 1.0 / (n * n);
    ++n;
}

System.out.println("Wartosc oczekiwana: " + wartoscOczekiwana);
System.out.println("Wartosc obliczona: " + wartoscObliczona);
System.out.println("Blad bezwzgledny: " + Math.abs(wartoscOczekiwana - wartoscObliczona));
System.out.println("Blad wzgledny: " + Math.abs(wartoscOczekiwana - wartoscObliczona)/wartoscOczekiwana);
System.out.println("Liczba iteracji: " + (n - 1));

Tak wykonany program wypisze na ekran:

Wartosc oczekiwana: 1.6449340668482264
Wartosc obliczona: 1.6367708468736315
Blad bezwzgledny: 0.008163219974594904
Blad wzgledny: 0.004962642660952381
Liczba iteracji: 122

Widzimy, że błąd względny osiągnął wartość mniejszą niż 0.5% dopiero po zsumowaniu 122 wyrazów.

Słownik