Prezentowane materiały są przeznaczone dla uczniów szkół ponadgimnazjalnych. Autor artykułu: mgr Jerzy Wałaszek,  wersja 1.0

©2008 mgr Jerzy Wałaszek I LO w Tarnowie

Liczby zmiennoprzecinkowe w języku C++

Zapoznaj się z artykułem o binarnym kodowaniu liczb

Typy zmiennoprzecinkowe w C++

W języku C++ mamy następujące 3 typy zmiennoprzecinkowe:

Zakres typów zmiennoprzecinkowych jest zwykle dosyć duży, zatem bardziej interesującym nas parametrem będzie precyzja. Z poprzedniej lekcji pamiętamy (czy aby na pewno?), iż liczby zmiennoprzecinkowe są liczbami przybliżonymi. Precyzja danego kodu FP określa, jak dokładnie jest pamiętana liczba. Na przykład dla typu float liczba może posiadać tylko około 8 cyfr znaczących. Oznacza to, iż pierwsze 7-8 cyfr liczby zostanie zapamiętane dokładnie, lecz pozostałe nie:

1234567890  → 1234567???float

Typ float wymyślono w czasach oszczędności pamięci - komputery nie posiadały jej wiele i była ona strasznie droga. Dzisiaj to się zmieniło. Pamięć kupujemy za grosze i jest ona liczona w gigabajtach. Z tego powodu nie ma sensu stosowanie typu float. Umówmy się, iż w znaczeniu typ zmiennoprzecinkowy będziemy zawsze rozumieli typ double, który pozwala zapamiętywać liczby z precyzją 15 cyfr.

Historia typu long double jest trochę inna. We wczesnych czasach powszechnej komputeryzacji mikroprocesory potrafiły wykonywać działania tylko na liczbach całkowitych. Operacje zmiennoprzecinkowe realizowano programowo, tzn. za pomocą specjalnie napisanych programów, które potrafiły wykonywać działania arytmetyczne na liczbach FP przy wykorzystaniu dostępnych operacji całkowitoliczbowych. Sposób ten był bardzo wolny. Dlatego bardzo szybko opracowano specjalizowane układy, które realizowały operacje FP sprzętowo, czyli szybko. Układy te nazywano koprocesorami arytmetycznymi, ponieważ współpracowały ściśle z podstawowym procesorem w komputerze, niejako uzupełniając jego listę rozkazów o operacje na danych FP.

W następnym etapie rozwoju koprocesor arytmetyczny został zintegrowany z mikroprocesorem w jednym układzie scalonym - stało się tak już od modelu i486, poprzednika współczesnego Pentium. Wewnętrznie koprocesor arytmetyczny przechowuje liczby FP w postaci kodu 80-bitowego. Typ long double to właśnie wewnętrzna reprezentacja liczb FP w koprocesorze arytmetycznym. Powodem takiego rozwiązania jest minimalizacja błędów zaokrągleń, które powstają w trakcie obliczeń. Wyniki są przekształcane na typy double lub float i są dokładniejsze, niż byłyby przy obliczeniach przeprowadzanych bezpośrednio w tych formatach.

Jednakże typ long double jest specyficzny dla procesorów Intel i nie jest dostępny na innych komputerach - VAX, CRAY itp. Dlatego pisząc oprogramowanie przenośne, nie używaj niestandardowych typów danych.

Zmienne FP w C++

Jeśli w programie chcemy używać zmiennych przechowujących liczby FP, to musimy je najpierw zadeklarować, jak wszystkie inne zmienne w programie.

Przykłady:

float       a,b,c; // trzy zmienne a, b i c pojedynczej precyzji
double      x,y;   // dwie zmienne x i y podwójnej precyzji
long double z;     // zmienna z o rozszerzonej precyzji

Gdy zmienna jest zadeklarowana możemy nadawać jej wartość instrukcją przypisania. W przeciwieństwie do zmiennych całkowitych, zmienne FP mogą przechowywać liczby ułamkowe:

Przykłady:

x = 15.765;
y = 165.44;

Zmienne FP można stosować w wyrażeniach:

Przykłady:

x = 12.67 * y;
x = sqrt(x);

Porównywanie liczb zmiennoprzecinkowych

Rozważmy prosty program:

#include <iostream>

using namespace std;

main()
{
  double x;
  
  x = 0;
  
  while(x != 1)
  {
    x += 0.1;
    cout << x << endl;
  }
  cout << endl << endl;
  system("PAUSE");
}

W programie jest pętla, która wykonuje się dopóki x jest różne od 1. Przed wejściem do pętli zmiennej x nadajemy wartość 0. W pętli x zwiększamy o ¹/₁₀ i wyświetlamy . Zatem w każdym kolejnym obiegu x jest większe. Wnioskujemy tak:

obieg nr   1:  x :    0 → 0.1
obieg nr   2:  x:  0.1 → 0.2
obieg nr   3:  x:  0.2 → 0.3
...
obieg nr   9:  x:  0.8 → 0.9
obieg nr 10:  x:  0.9 → 1.0 - koniec obiegów, ponieważ warunek kontynuacji pętli x != 1 staje się fałszywy

Uruchamiamy program i co się okazuje. Pętla, zamiast zatrzymać się w obiegu 10 na wartości x = 1, idzie dalej w nieskończoność. Dlaczego tak się dzieje? Przypomnij sobie poprzednią elekcję. Wyliczaliśmy na niej wartość ułamka dziesiętnego ¹/₁₀ w systemie dwójkowym:

0.1₍₁₀₎ = 0.000110011001100...

Otrzymujemy nieskończony ułamek okresowy. Tymczasem mantysa w typie zmiennoprzecinkowym double zawiera skończoną liczbę bitów. Oznacza to, iż ułamka 0.1 nie da się dokładnie zapamiętać, tylko z pewnym przybliżeniem. Zatem do x faktycznie dodajemy nie 1/10, ale przybliżenie 1/10. W wyniku po 10 dodawaniach nie otrzymamy dokładnie wartości 1, tylko wartość bliską 1. Różnica jest bardzo mała, ale jest! Dla komputera x oraz 1 to zupełnie inne liczby, ponieważ ich kody FP są różne! Stąd warunek kontynuacji pętli x != 1 jest zawsze prawdziwy, bo x nigdy nie będzie równe 1. Pętla kontynuuje się w nieskończoność.

Tego rodzaju błędy pojawiają się bardzo często w programach pisanych przez początkujących programistów, którzy nie mają zielonego pojęcia o podstawowych własnościach liczb zmiennoprzecinkowych i wynikających z tych własności konsekwencjach. Dlatego w naszym liceum nauka programowania z wykorzystaniem liczb zmiennoprzecinkowych jest poprzedzona wprowadzeniem do tego typu danych.

Problem rozwiązujemy stosując otoczenia. Wyobraźmy sobie, iż chcemy sprawdzić, czy pewna wartość zmiennoprzecinkowa W_FP jest równa wartości dokładnej W_D. Zamiast porównywać te dwie wartości ze sobą, sprawdzimy, czy na osi liczbowej leżą wystarczająco blisko siebie. Pojęcie "wystarczająco blisko" określa dokładność porównania.

Otoczmy punkt W_D promieniem ε. Powiemy, że wartość W_FP wpada w otoczenie o promieniu ε liczby W_D, jeśli liczby te różnią się od siebie nie więcej niż ε. Zapisujemy to następująco:

| W_D - W_FP | ≤ ε

W_D - wartość dokładna
W_FP - zmiennoprzecinkowa wartość przybliżona
ε - akceptowalne przybliżenie, czyli otoczenie wartości W_D, w którym wszystkie wartości traktujemy jako równe W_D.

Wartość otoczenia ε przyjmuje się zwykle bardzo małą, np. 0.000001. Jednakże nie jest to wcale takie proste, jak wygląda na pierwszy rzut oka. W profesjonalnych programach informatycy szacują wartość błędów obliczeniowych (na studiach informatycznych jest taki dział w ramach metod numerycznych) i na tej podstawie dobierają właściwą wartość ε. Ponieważ wymaga to zwykle znajomości matematyki na poziomie znacznie przewyższającym możliwości pojmowania ucznia w liceum, my będziemy przyjmowali za ε wartości empiryczne.

Wniosek:

Zamiast  W_FP == W_D   stosujemy w C++  fabs(W_D - W_FP) <= EPS

Zamiast  W_FP != W_D    stosujemy w C++  fabs(W_D - W_FP) > EPS

fabs(x) jest funkcją zwracającą wartość bezwzględną ze zmiennoprzecinkowego wyrażenia x. Aby mieć do niej dostęp, w programach musimy dołączyć plik nagłówkowy:

#include <cmath>

Program z początku rozdziału zmieniamy następująco:

#include <iostream>
#include <cmath>

using namespace std;

main()
{
  const double EPS = 0.000001; // otoczenie epsilon
  
  double x;
  
  x = 0;
  
  while(fabs(1 - x) > EPS )
  {
    x += 0.1;
    cout << x << endl;
  }
  cout << endl << endl;
  system("PAUSE");
}

Wyświetlanie liczb zmiennoprzecinkowych poprzez strumień cout

Liczby zmiennoprzecinkowe są standardowo wyświetlane w strumieniu konsoli cout z dokładnością do 6 cyfr po przecinku.

double x = 3.12345678;
cout << x << endl;

Wynik:

3.123456

Jeśli wartość liczby zwiększy się (lub zmniejszy), to strumień cout zacznie stosować notację naukową:

double x = 312345678;
cout << x << endl;

Wynik:

3.12346e+008

double x = 0.00000312345678;
cout << x << endl;

Wynik:

3.12346e-006

Zapis naukowy jest niczym innym jak zmiennoprzecinkowym zapisem w systemie dziesiętnym. W zapisie tym podaje się wartość dziesiętną mantysy oraz wartość dziesiętną cechy:

3.123456e+008
mantysa m = 3.123456
cecha c = 8

W = m × 10^c = 3.123456 × 10⁸

3.123456e-006
mantysa m = 3.123456
cecha c = -6

W = m × 10^c = 3.123456 × 10^-6

Zachowaniem się strumienia cout możemy sterować stosując tzw. manipulatory, czyli funkcje przesyłane do strumienia. Aby uzyskać dostęp do manipulatorów strumieni, w programie należy dołączyć nowy plik nagłówkowy:

#include <iomanip>

Po tej operacji możemy przesyłać do strumienia następujące manipulatory:

---

I Liceum Ogólnokształcące    im. Kazimierza Brodzińskiego w Tarnowie ©2024 mgr Jerzy Wałaszek

Dokument ten rozpowszechniany jest zgodnie z zasadami licencji
GNU Free Documentation License.

Pytania proszę przesyłać na adres email: i-lo@eduinf.waw.pl

W artykułach serwisu są używane cookies. Jeśli nie chcesz ich otrzymywać,
zablokuj je w swojej przeglądarce.
Informacje dodatkowe