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:

1110,0101

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 zmiennoprzecinkowych 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ć 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.

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:

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 zmiennoprzecinkowe - precyzja
// (C)2019 mgr Jerzy Wałaszek
// Metody numeryczne
//-----------------------------------------

#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
    setlocale(LC_ALL,"");

    cout << setprecision(0) << fixed;
    cout << "Precyzja liczb zmiennoprzecinkowych" << endl
         << "-----------------------------------" << endl;

    long double x;
    int i;

    x = 1;

    cout << "Cyfry                   float                  double             long double" << endl;

    for(i = 1; i < 21; i++)
    {

        cout << setw( 5) << i
             << setw(24) << (float) x
             << setw(24) << (double) x
             << setw(24) << x << endl;

        x *= 10;
        x += (i + 1) % 10;
    }

    cout << endl;

    return 0;
}

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 typu float ).

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ć.

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 przez przesuwanie 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 zmiennoprzecinkowe - precyzja
// (C)2019 mgr Jerzy Wałaszek
// Metody numeryczne
//-----------------------------------------

#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
    setlocale(LC_ALL,"");

    cout << setprecision(0) << fixed;
    cout << "Precyzja liczb zmiennoprzecinkowych" << endl
         << "-----------------------------------" << endl;

    float x;

    x = 999;

    cout << "Mała liczba float" << endl
         << "Przed : " << x;
    x++;
    cout << " Po : " << x << endl << endl;

    x = 100000000;

    cout << "Duża liczba float" << endl
         << "Przed : " << x;
    x++;
    cout << " Po : " << x << endl << endl;

    return 0;
}

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 takich 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 zmiennoprzecinkowe - precyzja
// (C)2019 mgr Jerzy Wałaszek
// Metody numeryczne
//-----------------------------------------

#include <iostream>
#include <iomanip>

using namespace std;

int main()
{
    setlocale(LC_ALL,"");

    cout << setprecision(20) << fixed;
    cout << "Precyzja liczb zmiennoprzecinkowych" << endl
         << "-----------------------------------" << endl;

    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;

    return 0;
}

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:

L_FP = L_d + 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 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 zmiennoprzecinkowe - precyzja
// (C)2019 mgr Jerzy Wałaszek
// Metody numeryczne
//-----------------------------------------

#include <iostream>
#include <cmath>
#include <iomanip>

using namespace std;

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

int main()
{
    setlocale(LC_ALL,"");

    cout << setprecision(20) << fixed;
    cout << "Precyzja liczb zmiennoprzecinkowych" << endl
         << "-----------------------------------" << endl;

    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(fabs(x) <= EPS) cout << "DOBRZE";
    else               cout << "ŹLE " << x;

    cout << endl << endl;

    return 0;
}

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 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:

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 ).

Poniższy program generuje 10 rzeczywistych liczb pseudolosowych:

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

#include <iostream>
#include <cstdlib>
#include <ctime>
#include <iomanip>

using namespace std;

int main()
{
    setlocale(LC_ALL,"");

    cout << setprecision(10) << fixed;
    cout << "Zmiennoprzecinkowe liczby pseudolosowe w przedziale [0,1]" << endl
         << "---------------------------------------------------------" << endl << endl;

    // Inicjujemy generator liczb pseudolosowych

    srand(time(NULL));

    double x;

    // Generujemy 10 liczb pseudolosowych

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

    cout << endl;

    return 0;
}

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
//-----------------------------------------

#include <iostream>
#include <cstdlib>
#include <ctime>
#include <iomanip>

using namespace std;

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

    setlocale(LC_ALL,"");

    cout << setprecision(5) << fixed;
    cout << "Zmiennoprzecinkowe liczby pseudolosowe w przedziale [a,b]" << endl
         << "---------------------------------------------------------" << endl << endl
         << "Podaj granice przedziału:" << endl;

    // 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 zmiennoprzecinkowe

    for(int i = 0; i < 10; i++)
    {
        x = a + (b - a) * (rand() / (double) RAND_MAX);
        cout << setw(12) << x << endl;
    }

    cout << endl;

    return 0;
}

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++:

Poniższy program generuje liczby w przedziale [a,b).

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

#include <iostream>
#include <random>
#include <ctime>
#include <iomanip>

using namespace std;

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

    setlocale(LC_ALL,"");

    cout << setprecision(5) << fixed;
    cout << "Zmiennoprzecinkowe liczby pseudolosowe w przedziale [a,b)" << endl
         << "---------------------------------------------------------" << endl << endl
         << "Podaj granice przedziału:" << endl;

    // 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;

    return 0;
}

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 ).