Kody binarne

Do obliczeń naukowych potrzebne są liczby rzeczywiste, a opisane wcześniej kody pozwalają zapisywać tylko liczby całkowite. Liczby ułamkowe w kodzie dwójkowym można wprowadzać przez rozszerzenie zapisu w prawą stronę. Umówmy się, że pozycje o numerach 0, 1, 2,... oznaczają wagi całkowite o wartości 2^{numer_pozycji}. Tak właśnie są zdefiniowane kody NBC i U2 (w U2 najstarszy bit ma zawsze wagę ujemną). Numerowanie pozycji nie musimy zakończyć na pozycji 0. Możemy pójść dalej w prawo, nadając pozycjom numery ujemne.

Na przykład umówmy się, że wagi pozycji są dalej potęgami liczby 2 o wykładniku równym numerowi pozycji:

Jeśli wyliczymy wagi pozycji, otrzymamy:

Zwróć uwagę, że wagi pozycji ujemnych są ułamkowe. Wartość liczby obliczamy tak samo jak przy poznanych wcześniej kodach NBC i U2: sumujemy wagi pozycji, na których występują bity o stanie 1.

Zobaczmy jak to działa na prostym przykładzie. Załóżmy, że mamy kod 8-bitowy. Ustalamy położenie przecinka w środku słowa kodowego. Jest to położenie umowne, ponieważ w kodzie możemy umieszczać tylko bity 0 lub 1. Mamy słowo kodowe 1110101. Jaką ma ono wartość w tym kodzie? Skoro przecinek jest w środku słowa, to mamy 4 bity całkowite oraz 4 bity ułamkowe:

Bity całkowite mają wartość:

Bity ułamkowe mają wartość (sumujemy wagi pozycji z bitem 1):

Łączymy wyniki i otrzymujemy wartość liczby przedstawionej tym kodem:

Jak widzisz, liczba nie jest całkowita.

Jak policzyć zakres wartości liczb w takim kodzie? Bardzo prosto. Część całkowita jest zwykłą liczbą NBC (część ułamkowa też, lecz z uwagi na wagi ułamkowe, potraktujmy ją osobno). Zakres części całkowitej: od 0 (0000₂) do 15 (1111₂). Zakres części ułamkowej: od 0 (,0000₂) do ¹⁵/₁₆ (,1111₂). Sumujemy odpowiednio oba zakresy i otrzymujemy, że kod ten może przedstawiać liczby od 0 do 15¹⁵/₁₆ z rozdzielczością ¹/₁₆.

Postaraj się udowodnić, że w kodzie n-bitowym z m bitami ułamkowymi (n > m) zakres liczb wynosi od 0 do 2^{n - m} - 1 = (2^m - 1) / 2^m.

Tego typu kody noszą nazwę kodów stałoprzecinkowych (ang. fixed-point codes). W obliczeniach wykorzystuje się inny rodzaj kodów, zwanych kodami zmiennoprzecinkowymi (floating-point codes). Z zapisem zmiennoprzecinkowym mogłeś się już spotkać na różnych przedmiotach ścisłych, gdzie występowała potrzeba zapisu bardzo dużych lub bardzo małych liczb:

Zaletą takiego zapisu jest tutaj większa czytelność. Jednak przyjrzyjmy się bliżej tak zapisanej liczbie. Składa się ona z 3 osobnych części:

Jeśli umówimy się, że podstawa p jest stała, to nie musimy ją zapisywać. Zostanie nam para liczb (c,m). Cecha c jest liczbą całkowitą. Mantysa m jest liczbą stałoprzecinkową. Możemy teraz skonstruować prosty binarny kod zmiennoprzecinkowy o długości 8 bitów:

Podział bitów w naszym słowie kodowym FP będzie następujący:

Wartość liczby w tym kodzie jest równa m · 2^c. Policzmy wartości kilku kodów.

Rozdzielamy bity kodu FP na bity cechy i bity mantysy:

Jak widzisz, kod FP potrafi zapisywać liczby całkowite i ułamkowe dodatnie i ujemne. Obliczenie wartości kodu nie jest takie proste jak w kodach NBC i U2, które są częścią składową kodu FP.

Przejdźmy do własności liczb zmiennoprzecinkowych. Tutaj bardzo przyda się nasz przykładowy kod FP z uwagi na jego prostotę. Na początek policzmy zakres liczb FP w naszym kodzie.

Liczbę najmniejszą dostaniemy dla najmniejszej (najbardziej ujemnej) mantysy i największej cechy:

Największą liczbę otrzymamy dla największej cechy i największej mantysy:

Podsumowując, zakres wynosi od -128 do 112.

Zwróć uwagę, że wzór na granice zakresu jest następujący:

Ponieważ mantysa jest liczbą mniejszą od 1, to zakres zależy głównie od cechy. Im więcej bitów przeznaczymy na cechę, tym bardziej wzrośnie zakres liczb możliwych do przedstawienia w danym kodzie. Zapamiętaj to. Na co wpływają bity mantysy? Na precyzję liczby FP. Im więcej bitów ma mantysa, tym dokładniej można przedstawić określone wartości. Pokażemy to na przykładach

Załóżmy, że chcemy w naszym kodzie przedstawić liczbę 12. Jak to zrobić? Otóż musimy otrzymać wartość mantysy mniejszą od 1 i wartość cechy. Zapisujemy:

Otrzymaliśmy:

Otrzymujemy:

Liczbę 12 dało się przedstawić bez problemu. Przyjmijmy roboczo, że przez precyzję liczby binarnej będziemy rozumieli liczbę bitów od pierwszego bitu 1 do ostatniego bitu 1. Liczba 12 w kodzie NBC ma zapis 1100_(NBC), posiada zatem precyzję 2 bitów. Mantysa naszego kodu ma precyzję 3 bitów, zatem liczba 12 mieści się w kodzie.

Weźmy teraz liczbę 9, której kod NBC ma postać 1001. Tym razem precyzja wynosi 4 bity. Czy da się tę liczbę zapisać w naszym kodzie? Operację dzielenia przez 2 możemy zastąpić prostą operacją przesuwania bitów w prawo. Zapiszmy liczbę 9 w kodzie stałoprzecinkowym z 3 bitami ułamkowymi i rozpocznijmy przesuwanie bitów w prawo, tak aby najstarszy bit trafił za przecinek, wtedy otrzymamy mantysę mniejszą od 1:

Zwróć uwagę, że w czwartym przesunięciu najmłodszy bit 1 wyszedł poza bity ułamkowe mantysy. Dlatego otrzymujemy:

Z liczby 9 zrobiła nam się liczba 8. Dlaczego? Ponieważ liczba 9 wymaga 4 bitów precyzji, a mantysa udostępnia jedynie 3 bity. Następuje zatem utrata precyzji i wynikowa liczba obarczona jest błędem zaokrąglenia (ang. rounding error). Jest to typowa własność liczb FP. Zwiększając liczbę bitów mantysy, zwiększamy precyzję, a zatem dokładność liczb.

Istnieją pewne wartości, których nigdy nie da się przedstawić dokładnie w kodzie FP. Taką typową wartością jest np. ¹/₅. Dlaczego? Liczba FP jest sumą potęg liczby 2. Liczba ¹/₅ nie daje się przedstawić jako suma potęg liczby 2.

Dostajemy nieskończony ułamek binarny. Podobną własność w systemie dziesiętnym mają na przykład liczby:

Wykonując obliczenia, należy zwracać na to uwagę, co pokażemy w następnym podrozdziale.

W języku C++ dostępne są trzy typy dla danych zmiennoprzecinkowych (w Pythonie liczby zmiennoprzecinkowe są standardowo reprezentowane jako typ double - 64 bity):

Współczesne mikroprocesory wyposażone są w tzw. koprocesor arytmetyczny. Jest to wyspecjalizowany moduł, który wykonuje szybkie obliczenia na liczbach zmiennoprzecinkowych. Typ long double jest typem danych wykorzystywanych wewnętrznie przez koprocesor. Zapewnia on wysoką dokładność obliczeń. W mikroprocesorach kompatybilnych z Pentium typ long double ma długość 80 bitów, czyli 10 bajtów. Jednak na innych platformach typ ten może posiadać inny rozmiar.

Precyzja odnosi się tutaj do gwarantowanej liczby początkowych cyfr dziesiętnych liczby zmiennoprzecinkowej, które zostaną zapamiętane dokładnie. Przykładowo w typie float (dostępny, lecz obecnie niezalecany z uwagi na niską precyzję) precyzja obejmuje około 7 pierwszych cyfr liczby. Jeśli liczba posiada więcej cyfr, to dokładnie zostanie zapamiętane tylko 7... 8 pierwszych z nich.

Poniższy program demonstruje tę własność dla trzech typów danych:

// Liczby FP - precyzja
// (C)2019 mgr Jerzy Wałaszek
// Metody numeryczne 0025
//---------------------------

#include <iostream>
#include <windows.h>
#include <iomanip>

using namespace std;

int main()
{
  SetConsoleOutputCP(CP_UTF8); 
  SetConsoleCP(CP_UTF8);
  cout << setprecision(0)
       << fixed;
  cout <<
  "Precyzja liczb "
  "zmiennoprzecinkowych\n"
  "---------------"
  "--------------------\n";

  long double x;
  int i;

  x = 1;
  cout <<
  "Cyfry                "
  "float               "
  "double          "
  "long double\n";

  for(i = 1; i < 21; i++)
  {
    cout
    << setw(5)  << i
    << setw(21) << (float)x
    << setw(21) << (double)x
    << setw(21) << x << endl;
    x *= 10;
    x += (i + 1) % 10;
  }

  cout << endl;
  system("pause");
  return 0;
}

Precyzja liczb zmiennoprzecinkowych
-----------------------------------
Cyfry                float               double          long double
    1                    1                    1                    1
    2                   12                   12                   12
    3                  123                  123                  123
    4                 1234                 1234                 1234
    5                12345                12345                12345
    6               123456               123456               123456
    7              1234567              1234567              1234567
    8             12345678             12345678             12345678
    9            123456792            123456789            123456789
   10           1234567936           1234567890           1234567890
   11          12345678848          12345678901          12345678901
   12         123456790528         123456789012         123456789012
   13        1234567954432        1234567890123        1234567890123
   14       12345679020032       12345678901234       12345678901234
   15      123456788103168      123456789012345      123456789012345
   16     1234567948140544     1234567890123456     1234567890123456
   17    12345678407663616    12345678901234568    12345678901234567
   18   123456790519087104   123456789012345680   123456789012345678
   19  1234567939550609408  1234567890123456768  1234567890123456789
   20 12345679395506094080 12345678901234567168 12345678901234567890

Typ long double jest najbardziej "precyzyjny", jednakże nie jest standardowy (na innych platformach może być taki sam jak typ double). Dlatego do zwykłych obliczeń stosujemy typ double, zwany typem o podwójnej precyzji (podwójnej w stosunku do oryginalnego typu float w  C/C++).

Typ float był intensywnie używany w przeszłości, gdy komputery nie miały dużej pamięci i były wolne (starsze mikroprocesory nie posiadały koprocesora arytmetycznego, który był osobnym układem scalonym, dosyć drogim i nie zawsze instalowanym na płycie głównej komputera – wszystkie operacje zmiennoprzecinkowe realizował programowo mikroprocesor, co było dosyć czasochłonne). Dzisiaj lepiej go już nie stosować, standardem jest 64-bitowy typ double (w C++) i typ float (w Pythonie). Typ long double wyszedł z użycia i nie ma nawet wsparcia sprzętowego na niektórych platformach (np. architektura ARM).

Dodawanie/odejmowanie liczb zmiennoprzecinkowych

Nie będziemy się zagłębiać w szczegóły techniczne wykonywania operacji na liczbach zmiennoprzecinkowych. Opiszemy jedynie ich podstawowe własności, które powinieneś znać, aby uniknąć pułapek w trakcie programowania.

Liczbę zmiennoprzecinkową możemy ogólnie zapisać w postaci wyrażenia m · 2^c, gdzie m jest mantysą, c jest cechą. Załóżmy, że mamy dwie liczby zmiennoprzecinkowe a i b:

Dodanie tych dwóch liczb do siebie polega na znalezieniu mantysy i cechy wyniku dodawania:

W tym celu wyrównujemy cechy obu liczb:

Otrzymaną w ten sposób mantysę należy znormalizować, tzn. doprowadzić do wartości poprawnej dla danego kodu, np. w naszym przykładowym kodzie 8-bitowym mantysa jest liczbą mniejszą od 1 i większą lub równą -1. Mnożenie przez potęgi liczby 2 jest dokonywane za pomocą przesuwania bitów. Również normalizacja jest wykonywana za pomocą przesunięć. Gdy bity mantysy są przesuwane w lewo, cecha maleje o 1; gdy są przesuwane w prawo, cecha rośnie o 1. Zobaczmy jak wygląda to na przykładzie.

Mamy dodać dwie liczby 8 i 6. Najpierw znajdźmy ich kody FP:

Wyrównujemy wykładniki. W tym celu mantysę m₂ przesuwamy bitowo w prawo o 1 pozycję, a wykładnik c₂ zwiększamy o 1:

Teraz obie liczby mają ten sam wykładnik, możemy dodać mantysy i otrzymamy mantysę wyniku:

Mantysa mieści się we właściwym przedziale, więc liczby nie musimy normalizować. Otrzymujemy kod wynikowy:

Wynik jest prawidłowy.

Inny przykład. Dodajemy 14  +  14:

Ponieważ oba wykładniki są takie same, nie musimy ich wyrównywać. Sumujemy mantysy:

Mantysa jest większa od 1, musimy ją znormalizować. Przesuwamy jej bity o 1 pozycję w prawo i zwiększamy wykładnik o 1:

Teraz mantysa jest mniejsza od 1, mamy gotowy kod:

Wynik sumowania może być niepoprawny, jeśli nastąpi zaokrąglenie mantysy. Zsumujmy liczbę 8 i 3:

Wyrównujemy wykładniki, mantysę m₂ przesuwamy o 2 bity w prawo, a wykładnik c₂ zwiększamy o 2:

Zwróć uwagę, iż po przesunięciu, najmłodszy bit mantysy m_2' wyszedł poza bity mantysy standardowej, dlatego zaznaczyliśmy go tutaj na czerwono.

Wykładniki są wyrównane, dodajemy mantysy obu liczb:

Mantysa wynikowa jest mniejsza od 1, nie musimy normalizować wyniku. Jednak najmłodszy bit mantysy wynikowej musi zostać odrzucony, ponieważ nie mieści się w bitach mantysy kodu FP. Dokonujemy tzw. zaokrąglenia

i otrzymujemy:

Wynik jest niepoprawny, ponieważ liczba 11 wymaga 4 bitów precyzji (11 = 1011_(NBC)) , a mantysa udostępnia jedynie 3 bity precyzji.

Przedstawiona tutaj sytuacja występuje również w działaniach na liczbach zmiennoprzecinkowych w języku C++ (jest to cecha wspólna wszystkich kodów zmiennoprzecinkowych).

Poniższy program zwiększa o 1 najpierw małą liczbę typu float, a później robi to samo z dużą liczbą typu float. Wyciągnij z tego wnioski:

// Liczby FP - precyzja
// (C)2019 mgr Jerzy Wałaszek
// Metody numeryczne 0026
//---------------------------

#include <iostream>
#include <windows.h>
#include <iomanip>

using namespace std;

int main()
{
  SetConsoleOutputCP(CP_UTF8); 
  SetConsoleCP(CP_UTF8);

  cout << setprecision(0)
       << fixed;
  cout << "Precyzja liczb FP\n"
          "-----------------\n\n";

  float x;

  x = 999;
  cout << "Mała liczba float\n"
          "Przed : " << x;
  x++;
  cout << " Po : " << x
       << endl << endl;

  x = 100000000;
  cout << "Duża liczba float\n"
          "Przed : " << x;
  x++;
  cout << " Po : " << x
       << endl << endl;

  system("pause");
  return 0;
}

# Liczby FP - precyzja
# (C)2026 mgr Jerzy Wałaszek
# Metody numeryczne 0026

print("Precyzja liczb FP\n"
      "-----------------\n")
x = 999.0
print("Mała liczba float\n"
     f"Przed : {x:.0f}")
x += 1
print(f"   Po : {x:.0f}\n")

x = 10000000000000000.0
print("Duża liczba float\n"
     f"Przed : {x:.0f}")
x += 1
print(f"   Po : {x:.0f}\n")

input("Naciśnij Enter...")

Jak napisaliśmy w poprzednim rozdziale, niektóre wartości tworzą nieskończone ułamki binarne i nie dają się dokładnie zapisać w żadnym z typów danych zmiennoprzecinkowych. Taką wartością jest na przykład 0,1 (jedna dziesiąta). Przy sumowaniu tego typu wartości błędy zaokrągleń kumulują się i wynik może odbiegać od wartości dokładnej.

Poniższy program dodaje do zmiennej o początkowej wartości 0 dziesięć razy liczbę 0,1. Następnie odejmuje od tej zmiennej 1. Jeśli wyjdzie wartość 0 (tak wynika z arytmetyki) , to wyświetla napis "DOBRZE". Jeśli wynik odejmowania jest różny od zera, to wyświetla napis "ŹLE" i wypisuje wartość zmiennej z 20 cyframi po przecinku. Wyciągnij wnioski sam:

// Liczby FP - precyzja
// (C)2019 mgr Jerzy Wałaszek
// Metody numeryczne 0027
//---------------------------

#include <iostream>
#include <windows.h>
#include <iomanip>

using namespace std;

int main()
{
  SetConsoleOutputCP(CP_UTF8); 
  SetConsoleCP(CP_UTF8);

  cout << setprecision(20)
       << fixed;

  cout << "Precyzja liczb FP\n"
          "-----------------\n\n";

  double x = 0;

  // Do zmiennej x dodajemy
  // dziesięć razy liczbę 0.1.
  for(int i = 0; i < 10; i++)
    x += 0.1;

  // W x powinna być wartość 1.
  // Odejmujemy 1 od x.
  // Powinniśmy otrzymać 0:
  x -= 1;
  if(x == 0)
    cout << "DOBRZE";
  else
    cout << "ŹLE: " << x;

  cout << endl << endl;
  system("pause");
  return 0;
}

# Liczby FP - precyzja
# (C)2019 mgr Jerzy Wałaszek
# Metody numeryczne 0027
#---------------------------

print("Precyzja liczb FP\n"
      "-----------------\n")

x = 0.0

# Do zmiennej x dodajemy
# dziesięć razy liczbę 0.1.
for i in range(10):
    x += 0.1

# W x powinna być wartość 1.
# Odejmujemy 1 od x.
# Powinniśmy otrzymać 0:
x -= 1
if x == 0:
    print("DOBRZE")
else:
    print(f"ŹLE: {x:.20f}\n")

input("Naciśnij Enter...")

Błąd jest bardzo mały, lecz komputer porównuje bity i różnica nawet jednego bitu powoduje, iż wyświetli się napis "ŹLE". Wynika z tego, iż liczb zmiennoprzecinkowych nie powinno się porównywać z liczbami dokładnymi, ponieważ z powodu błędów zaokrągleń wynik może być obarczony pewnym błędem. Jak zatem sprawdzić, czy liczba zmiennoprzecinkowa ma pożądaną wartość? Musisz zdecydować, z jaką dokładnością chcesz przeprowadzić to sprawdzenie. Należy zatem oszacować możliwy błąd, Nie jest to zadanie proste i dokładne metody poznasz dopiero na studiach. Tutaj możemy podejść do problemu w sposób prosty, lecz nieprofesjonalny:

Liczbę zmiennoprzecinkową L_FP możemy potraktować jako sumę liczby dokładnej L_d oraz błędu zaokrąglenia L_e:

Wartość L_e zależy od dostępnej precyzji oraz od wartości samej liczby dokładnej L_d. Dlatego zwykle posługujemy się pojęciem błędu względnego:

Ponieważ błąd może być dodatni lub ujemny, to stosujemy wartość bezwzględną tego błędu:

Po podstawieniach mamy:

Jeśli dana reprezentacja FP posiada precyzję n cyfr, to znaczy, że pierwsze n cyfr liczby jest dokładne. Począwszy od cyfry (n + 1) dokładność nie jest gwarantowana i mogą pojawiać się błędy. Jeśli nasza liczba L_d = 0,1, a dokładność wynosi 15 cyfr, to w najgorszym przypadku |L_e| = 0,000000000000000999... Dla prostoty przyjmijmy |L_e| = 0,000000000000001. Czyli błąd względny ma wartość:

Jeśli zsumujemy 10 razy liczbę FP, to

Po podstawieniach otrzymamy:

Aby sprawdzić, czy suma osiągnęła założoną wartość x_(FP) nie porównujemy jej z tą wartością bezpośrednio, lecz sprawdzamy, czy wartość bezwzględna różnicy sumy i wartości oczekiwanej jest równa lub mniejsza od oszacowanego błędu:

Jeśli tak, to przyjmujemy, że suma ma w przybliżeniu wartość oczekiwaną.

Wynika z tego następujący wniosek:

Błąd względny zależy od precyzji obliczeń. W przybliżeniu możesz przyjąć (przypadek pesymistyczny) , że:

Gdzie p oznacza liczbę cyfr dokładnych w danej precyzji.

Zmieniamy nasz program następująco:

// Liczby FP - precyzja
// (C)2019 mgr Jerzy Wałaszek
// Metody numeryczne 0028
//---------------------------

#include <iostream>
#include <windows.h>
#include <cmath>
#include <iomanip>

using namespace std;

// Wartość spodziewanego błędu
const double EPS = 0.00000000001;

int main()
{
  SetConsoleOutputCP(CP_UTF8); 
  SetConsoleCP(CP_UTF8);

  cout << setprecision(20)
       << fixed;
  cout << "Precyzja liczb FP\n"
          "-----------------\n";

  double x = 0;

  // Do zmiennej x dodajemy
  // dziesięć razy liczbę 0,1.
  for(int i = 0; i < 10; i++)
    x += 0.1;

  // W x powinna być wartość 1.
  // Odejmujemy 1 od x.
  // Powinniśmy otrzymać 0:
  x -= 1;
  
  // Sprawdzamy, czy wynik
  // wpada w otoczenie zera
  // o promieniu EPS
  if(fabs(x) <= EPS)
    cout << "DOBRZE";
  else
    cout << "ŹLE: " << x;

  cout << endl << endl;
  system("pause");
  return 0;
}

# Liczby FP - precyzja
# (C)2026 mgr Jerzy Wałaszek
# Metody numeryczne 0028
#---------------------------

import math

# Wartosc spodziewanego bledu
EPS = 0.00000000001

print("Precyzja liczb FP")
print("-----------------")

x = 0.0

# Do zmiennej x dodajemy
# dziesiec razy liczbe 0.1.
for i in range(10):
    x += 0.1

# W x powinna byc wartosc 1.
# Odejmujemy 1 od x.
# Powinnismy otrzymac 0:
x -= 1.0

# Sprawdzamy, czy wynik
# wpada w otoczenie zera
# o promieniu EPS
if math.fabs(x) <= EPS:
    print("DOBRZE")
else:
    print(f"ZLE: {x:.20f}")

print("\n")
input("Nacisnij Enter...")

Z tej zasady będziemy korzystali zawsze przy porównywaniu liczb zmiennoprzecinkowych. Zapamiętaj ją.

Odejmowanie jest dodawaniem liczby przeciwnej:

Jeśli odejmujesz liczby prawie równe, to wynik może być bardzo niedokładny. Dlaczego? Wyjaśnijmy to na przykładzie. Załóżmy, że mamy precyzję 3 cyfr, tzn. 3 pierwsze cyfry liczby są dokładne, reszta już nie. Weźmy teraz dwie liczby 6-cio cyfrowe:

Odejmujemy:

Precyzja wyniku spadła do 1 cyfry, ponieważ pozostałe są niepewne, a w niekorzystnych okolicznościach nawet ta pierwsza cyfra nie jest pewna.

Mnożenie/dzielenie liczb zmiennoprzecinkowych

Zasada mnożenia liczb zmiennoprzecinkowych jest następująca:

Mamy 2 liczby zmiennoprzecinkowe:

Tworzymy ich iloczyn:

Mantysa wynikowa jest iloczynem mantys obu mnożonych liczb. Cecha wynikowa jest sumą cech mnożonych liczb. Po operacji mnożenia mantysa wynikowa musi zostać znormalizowana, czyli sprowadzona do odpowiedniego zakresu za pomocą przesuwów bitowych, jak przy dodawaniu.

Zobaczmy na przykładzie w naszym prostym systemie FP jak wygląda mnożenie dwóch liczb zmiennoprzecinkowych.

Mnożymy mantysy:

Dodajemy wykładniki

Mantysę normalizujemy przesuwając jej bity o jedna pozycję w lewo (odpowiada to pomnożeniu liczby przez 2) i zmniejszając o 1 cechę (odpowiada to podzieleniu liczby przez 2, w sumie dostajemy tę samą liczbę):

I otrzymujemy kod wynikowy:

Dla mnożenia dwóch liczb zmiennoprzecinkowych mamy:

Jeśli precyzja liczby jest duża, to kwadrat błędu jest bardzo mały i można go pominąć:

Przy mnożeniu 3 liczb zmiennoprzecinkowych otrzymujemy:

Możemy to kontynuować dla następnych iloczynów i ostatecznie otrzymamy, że błąd mnożenia n liczb zmiennoprzecinkowych jest w przybliżeniu równy:

Dzielenie jest odwrotnością mnożenia:

Obowiązują tutaj te same zasady, co przy mnożeniu.

Liczby pseudolosowe całkowite opisane zostały w poprzednim rozdziale.

Liczbę pseudolosową rzeczywistą możemy otrzymać z wbudowanego generatora pseudolosowego dzieląc odpowiednio jego wynik. Liczby z przedziału obustronnie domkniętego <0,1> daje nam poniższe wyrażenie:

Rzutowanie na typ double jest konieczne, aby kompilator zastosował dzielenie zmiennoprzecinkowe. W przeciwnym razie dzielenie będzie całkowitoliczbowe z wynikiem 0 (bardzo często, rand( ) < RAND_MAX) lub 1 (bardzo rzadko, rand( ) = RAND_MAX).

W Pythonie korzystamy z biblioteki random. Funkcja random.random( ) zwraca liczbę z przedziału lewostronnie domkniętego <0;1). Aby otrzymać przedział obustronnie domknięty, używamy funkcji random.uniform(0.0,1.0).

Poniższy program generuje 10 rzeczywistych liczb pseudolosowych:

// Liczby FP
// (C)2019 mgr Jerzy Wałaszek
// Metody numeryczne 0029
//---------------------------

#include <iostream>
#include <windows.h>
#include <cstdlib>
#include <ctime>
#include <iomanip>

using namespace std;

int main()
{
  SetConsoleOutputCP(CP_UTF8); 
  SetConsoleCP(CP_UTF8);

  cout << setprecision(10)
       << fixed;
  cout <<
  "Pseudolosowe liczby FP "
  "w przedziale <0,1>\n"
  "-----------------------"
  "------------------\n\n";

  // Inicjujemy generator
  // liczb pseudolosowych
  srand(time(nullptr));

  double x;

  // Generujemy 10 liczb pseudolosowych
  for(int i = 0; i < 10; i++)
  {
    x = rand() / (double)RAND_MAX;
    cout << x << endl;
  }

  cout << endl;
  system("pause");
  return 0;
}

# Liczby FP
# (C)2026 mgr Jerzy Wałaszek
# Metody numeryczne 0029
#---------------------------

import random

print("Pseudolosowe liczby FP "
      "w przedziale <0,1>\n"
      "-----------------------"
      "------------------\n")

# Generujemy 10 liczb FP
# z przedziału <0,1>
for _ in range(10):
    print(
    f"{random.uniform(0.0, 1.0):.10f}")

print()
input("Nacisnij Enter...")

Granice przedziału generowanych liczb możemy modyfikować:

Mając przedział 0...1 możemy go dowolnie rozszerzać, np na przedział a...b:

Poniższy program generuje liczby w zakresie od a do b.

// Liczby zmiennoprzecinkowe
// (C)2019 mgr Jerzy Wałaszek
// Metody numeryczne 0030
//---------------------------

#include <iostream>
#include <windows.h>
#include <cstdlib>
#include <ctime>
#include <iomanip>

using namespace std;

int main()
{
  double a,b,x;

  SetConsoleOutputCP(CP_UTF8); 
  SetConsoleCP(CP_UTF8);

  cout << setprecision(5)
       << fixed;
  cout <<
  "Pseudolosowe liczby FP "
  "w przedziale <a,b>\n"
  "-----------------------"
  "------------------\n\n"
  "Podaj granice przedziału:\n";

  // Odczytujemy granice
  // przedziału liczb
  // pseudolosowych
  cout << "a = ? "; cin >> a;
  cout << "b = ? "; cin >> b;
  cout << endl;

  // Inicjujemy generator
  // liczb pseudolosowych
  srand(time(NULL));

  // Generujemy 10 liczb
  // pseudolosowych
  // i zamieniamy je
  // na liczby FP
  for(int i = 0; i < 10; i++)
  {
    x = a + (b - a) *
       (rand() / (double)RAND_MAX);
    cout << setw(12) << x << endl;
  }

  cout << endl;
  system("pause");
  return 0;
}

Pseudolosowe liczby FP w przedziale <a,b>
-----------------------------------------

Podaj granice przedziału:

a = ? -200
b = ? 200

   164.81292
   145.49710
   -19.96217
    53.89440
   -69.71423
   177.92743
  -145.82139
  -166.57449
   -81.22680
  -104.80364

# Liczby zmiennoprzecinkowe
# (C)2026 mgr Jerzy Wałaszek
# Metody numeryczne 0030
#---------------------------

import random

print(
  "Pseudolosowe liczby FP "
  "w przedziale <a,b>\n"
  "-----------------------"
  "------------------\n\n"
  "Podaj granice przedziału:\n")

# Odczytujemy granice
# przedziału liczb
# pseudolosowych
a = float(input("a = ? "))
b = float(input("b = ? "))
print()

# Generujemy 10 liczb
# pseudolosowych
for _ in range(10):
    x = random.uniform(a, b)
    print(f"{x:12.5f}")

print()
input("Nacisnij Enter...")

Jeśli musisz generować zmiennoprzecinkowe liczby pseudolosowe w swoim programie, to lepszym rozwiązaniem jest skorzystanie z biblioteki szablonowej <random>. Poniższy program jest wersją poprzedniego. Różnica dotyczy zakresu generowanych liczb. Przy obiekcie rozkładu uniform_real_distribution parametry a,b określają przedział <a;b) – domknięty lewostronnie, otwarty prawostronnie.

Pamiętaj o ustawieniu w opcjach kompilatora obsługi standardu 11 języka C++:

Dla przedziału <a;b) w Pythonie wykorzystujemy wzór:

a + (b - a) * random.random( )

Poniższy program generuje liczby w przedziale <a;b).

// Liczby FP
// (C)2019 mgr Jerzy Wałaszek
// Metody numeryczne 0031
//---------------------------
nclude <iomanip>

#include <iostream>
#include <windows.h>
#include <random>
#include <ctime>
#i
using namespace std;

int main()
{
  double a,b,x;

  SetConsoleOutputCP(CP_UTF8); 
  SetConsoleCP(CP_UTF8);

  cout << setprecision(5)
       << fixed;
  cout <<
  "Pseudolosowe liczby FP "
  "w przedziale <a,b)\n"
  "-----------------------"
  "------------------\n\n"
  "Podaj granice przedziału:\n";

  // Odczytujemy granice
  // przedziału liczb pseudolosowych
  cout << "a = ? "; cin >> a;
  cout << "b = ? "; cin >> b;
  cout << endl;

  // Tworzymy obiekt generatora
  // pseudolosowego i inicjujemy go
  mt19937 gen(time(NULL));

  // Tworzymy klasę rozkładu.
  // Rozkład jednorodny liczb
  // rzeczywistych w przedziale <a,b)
  uniform_real_distribution
    <double> dist(a,b);

  // Generujemy 10 liczb
  // pseudolosowych
  for(int i = 0; i < 10; i++)
  {
    x = dist(gen);
    cout << setw(12) << x << endl;
  }

  cout << endl;
  system("pause");
  return 0;
}

Pseudolosowe liczby FP w przedziale <a,b)
-----------------------------------------

Podaj granice przedziału:
a = ? -10
b = ? 10

     2.13726
    -0.05279
    -5.74471
    -3.62289
    -6.07315
     6.03373
     7.79354
    -3.40715
    -9.99746
     0.74454

# Liczby FP
# (C)2026 mgr Jerzy Wałaszek
# Metody numeryczne 0031
#---------------------------

import random

print("Pseudolosowe liczby FP "
      "w przedziale <a,b)\n"
      "-----------------------"
      "------------------\n\n"
      "Podaj granice przedziału:\n")

# Odczytujemy granice
# przedziału liczb pseudolosowych
a = float(input("a = ? "))
b = float(input("b = ? "))
print()

# Generujemy 10 liczb
# pseudolosowych
for _ in range(10):
    x = a + (b - a) * random.random()
    print(f"{x:12.5f}")
input("\nNaciśnij Enter...")

Zastanów się, jak generować liczby pseudolosowe w przedziałach <a;b>, (a;b>, (a,b) i <a;b) przy wykorzystaniu jedynie samej klasy generatora pseudolosowego (skorzystaj z funkcji składowych min( ) i max( ) generatora).