Ułamki

Cel

Ten artykuł rozpoczyna serię artykułów dotyczących implementacji ułamków. Konkretniej chodzi o stworzenie biblioteki, którą będzie można zaimplementować w dowolnym projekcie, aby można było swobodnie pracować na ułamkach (używając nowego typu danych). Przed przystąpieniem do pisania warto przypomnieć sobie definicję ułamka:

Definicja

Ułamek to wyrażenie \(\frac{a}{b}\) , gdzie a i b to dowolne wyrażenia algebraiczne.

Implementacja

Część prywatna

Biblioteka będzie zawierać nową klasę ulamek. Pozwoli to na zadeklarowanie zmiennej tego typu w dowolnym miejscu w kodzie. Utworzenie nowej klasy rozpoczyna słowo kluczowe class i nazwa klasy 

1
class ulamek {

1
    class ulamek {

Następnie rozpoczyna się sekcja prywatna klasy. Jest to część hermetyzacji klasy. Ma to za zadanie ograniczyć co może wywołać programista na tej klasie. Pozostawienie niektórych z tych funkcji publicznych mogłoby doprowadzić do nieoczekiwanego przerwania działania programu (poprzez nieprawidłową operację). W prywatnej części są zadeklarowane dwie zmienne typu int , które odpowiadają licznikowi i mianownikowi ułamka.

1
2
private:
    int licznik, mianownik;

1
2
        private int licznik;
        private int mianownik;

Następnie do programu zostają wprowadzone prywatne funkcje pomocnicze. Ich zadanie polega na wykonaniu określonych operacji arytmetycznych. Przykładowo pierwsza funkcja dodaj() dodaje nowy ułamek do aktualnie przechowywanego w zmiennej.

1
2
3
    ulamek dodaj(const ulamek &a) {
        return ulamek(licznik * a.mianownik + a.licznik * mianownik, mianownik * a.mianownik);
    }

1
2
3
        private static ulamek dodaj(ulamek a, ulamek b) {
            return new ulamek(a.licznik * b.mianownik + b.licznik * a.mianownik, a.mianownik * b.mianownik);
        }

Na podobnej zasadzie działają funkcje odejmij(),mnozenie() oraz dzielenie().

1
2
3
    ulamek odejmij(const ulamek &a) {
        return ulamek(licznik * a.mianownik - a.licznik * mianownik, mianownik * a.mianownik);
    }

1
2
3
        private static ulamek odejmij(ulamek a, ulamek b) {
            return new ulamek(a.licznik * b.mianownik - b.licznik * a.mianownik, a.mianownik * b.mianownik);
        }

1
2
3
    ulamek mnozenie(const ulamek &a) {
        return ulamek(licznik * a.licznik, mianownik * a.mianownik);
    }

1
2
3
        private static ulamek mnozenie(ulamek a, ulamek b) {
            return new ulamek(a.licznik * b.licznik, a.mianownik * b.mianownik);
        }

1
2
3
    ulamek dzielenie(const ulamek &a) {
        return ulamek(licznik * a.mianownik, mianownik * a.licznik);
    }

1
2
3
        private static ulamek dzielenie(ulamek a, ulamek b) {
            return new ulamek(a.licznik * b.mianownik, a.mianownik * b.licznik);
        }

Ostatnią prywatną funkcją jest nwd(), która jest implementacją szukania największego wspólnego dzielnika przy pomocy Algorytmu Euklidesa . Funkcja ta zostanie użyta podczas redukowania ułamka.

1
2
3
    int nwd(int a, int b) {
        return (a == 0) ? b : nwd(b % a, a);
    }

1
2
3
        private int nwd(int a, int b) {
            return (a == 0) ? b : nwd(b % a, a);
        }

Część publiczna

Teraz w klasie zadeklarowana część publiczna. Świadczy o tym słowo kluczowe public . Część ta udostępni określone funkcje dla programisty. Pierwsza z nich to będzie konstruktor, który pozwoli utworzyć zmienną typu ulamek.

1
2
3
4
5
6
public:
    ulamek(int _licznik, int _mianownik = 1) {
        licznik = _licznik;
        mianownik = _mianownik;
        redukuj();
    }

1
2
3
4
5
        public ulamek(int licznik, int mianownik) {
            this.licznik = licznik;
            this.mianownik = mianownik;
            this.redukuj();
        }

(2.) Konstruktor przyjmuje dwa argumenty _licznik oraz _mianownik. Argument _mianownik domyślnie ma wartość 1. Pozwoli to na utworzenie ułamka przy pomocy tylko wartości licznika. Są to wartości, które (3., 4.) zostaną przypisane do wcześniej zadeklarowanych zmiennych. Po przypisaniu program (5.) zredukuje ułamek.

Dodatkowo, aby można było tworzyć ułamek podając jedynie licznik zdefiniowany został konstruktor jednoargumentowy.
1
        public ulamek(int licznik) : this(licznik, 1) { }

Użyta funkcja redukuj() wygląda następująco:

1
2
3
4
5
    void redukuj() {
        int t = nwd(licznik, mianownik);
        licznik /= t;
        mianownik /= t;
    }

1
2
3
4
5
        public void redukuj() {
            int t = nwd(licznik, mianownik);
            licznik /= t;
            mianownik /= t;
        }

(1.) Funkcja nic nie zwraca. (2.) Oblicza największy wspólny dzielnik, a potem (3., 4.) dzieli zarówno licznik i mianownik przez wyliczoną wartość.

Pomimo zwiększenia precyzji przechowywania danych programista lub użytkownik mogą chcieć, aby program wypisał wartość dziesiętną przechowywanego ułamka. W tym celu można posłużyć się funkcją pobierzWartosc(), która podzieli licznik przez mianownik i zwróci liczbę rzeczywistą.

1
2
3
    double pobierzWartosc() {
        return (double)licznik / (double)mianownik;
    }

1
2
3
        public double pobierzWartosc() {
            return (double)licznik / (double)mianownik;
        }

O ile do tej pory ciężko było znaleźć przewagę nowej klasy nad typowym przechowywaniem ułamka w zmiennej typu rzeczywistego to funkcja odwroc() z pewnością to zmieni. Potrafi ona odwrócić ułamek nie tracąc żadnych danych przez błąd przybliżenia.

1
2
3
    void odwroc() {
        *this = ulamek(mianownik, licznik);
    }

1
2
3
4
5
        public void odwroc() {
            int t = licznik;
            licznik = mianownik;
            mianownik = t;
        }

Operatory

Klasa ulamek jest już prawie gotowa, ale wciąż brakuje możliwości wykonywania operacji na ułamkach. Są oczywiście zadeklarowane, ale programista nie ma do nich dostępu. W celu uproszczenia wykonywanych operacji zadeklarowane zostaną operatory. Pozwoli to wykonywać operacje arytmetyczne na ułamku tak samo jak w przypadku prostych typów danych.

Pierwszy operator << ma za zadanie ułatwić wypisywanie ułamka na dowolny strumień danych. Ułamek zostanie wypisany w postaci licznik/mianownik.

1
2
3
4
5
6
    friend ostream& operator << (ostream& out, const ulamek& a) {
        out << a.licznik;
        if (a.mianownik != 1)
            out << "/" << a.mianownik;
        return out;
    }

1
2
3
4
5
6
        public override string ToString() {
            string s = "" + licznik;
            if (mianownik != 1)
                s += "/" + mianownik;
            return s;
        }

Dalej zostaje zdefiniowany operacje dodawania:

1
2
3
    ulamek operator + (const ulamek &a) {
        return dodaj(a);
    }

1
2
3
    ulamek &operator += (const ulamek &a) {
        return (*this = dodaj(a));
    }

1
2
3
        public static ulamek operator +(ulamek a, ulamek b) {
            return dodaj(a, b);
        }

Analogicznie do zadeklarowanych operatorów dodawania zostają zadeklarowane pozostałe operatory do wykonywania operacji arytmetycznych:

1
2
3
    ulamek operator - (const ulamek &a) {
        return odejmij(a);
    }

1
2
3
    ulamek &operator -= (const ulamek &a) {
        return (*this = odejmij(a));
    }

1
2
3
    ulamek operator * (const ulamek &a) {
        return mnozenie(a);
    }

1
2
3
    ulamek &operator *= (const ulamek &a) {
        return (*this = mnozenie(a));
    }

1
2
3
    ulamek operator / (const ulamek &a) {
        return dzielenie(a);
    }

1
2
3
    ulamek &operator /= (const ulamek &a) {
        return (*this = dzielenie(a));
    }

1
2
3
        public static ulamek operator -(ulamek a, ulamek b) {
            return odejmij(a, b);
        }

1
2
3
        public static ulamek operator *(ulamek a, ulamek b) {
            return mnozenie(a, b);
        }

1
2
3
        public static ulamek operator /(ulamek a, ulamek b) {
            return dzielenie(a, b);
        }

Pozostało teraz jeszcze dodać przykładowo konwersję liczb całkowitych na ułamki. Jest to niezwykle przydatna konwersja, która umożliwia mieszanie liczb całkowitych i ułamków nie definiując dodatkowych operatorów.

1
2
3
        public static implicit operator ulamek(int d) {
            return new ulamek(d, 1);
        }

Na sam koniec deklaracji klasy nie należy zapomnieć o poprawnym zakończeniu klasy:

1
};

1
    }

Korzystanie z klasy

Deklaracja

1
2
3
    ulamek c1 = 120;
    ulamek c2 = ulamek(13);
    ulamek c3 = ulamek(13, 3);

1
2
3
            ulamek c1 = 120;
            ulamek c2 = new ulamek(13);
            ulamek c3 = new ulamek(13, 3);

(1.) Tworzy ułamek \(\frac{120}{1}\) . (2.) Podobnie jak w pierwszym przypadku \(\frac{13}{1}\) . (3.) Utworzenie ułamka niewłaściwego \(\frac{13}{3}\)

Operacje arytmetyczne

Operacje arytmetyczne można wykonać używając operatorów dwuargumentowych:

4
5
6
7
    c1 = c1 + 3;
    c1 = c1 - 6;
    c2 = c2 * ulamek(7, 2);
    c3 = c1 - c2;

4
5
6
7
            c1 = c1 + 3;
            c1 = c1 - 6;
            c2 = c2 * new ulamek(7, 2);
            c3 = c1 - c2;

Można też oczywiście użyć operatorów skróconych co znacznie ułatwia zapis:

 8
 9
10
11
    c1 += 3;
    c1 -= 6;
    c2 *= ulamek(7, 2);
    c3.odwroc();

 8
 9
10
11
            c1 += 3;
            c1 -= 6;
            c2 *= new ulamek(7, 2);
            c3.odwroc();

Po wykonaniu wszystkich operacji wyżej można wypisać dane w następujący sposób:

12
13
14
    cout << c1 << endl;
    cout << c2.pobierzWartosc() << endl;
    cout << (int)(c3.pobierzWartosc()) << endl;

12
13
14
15
            Console.WriteLine(c1);
            Console.WriteLine(c2.pobierzWartosc());
            Console.WriteLine((int)(c3.pobierzWartosc()));
            Console.ReadKey();

(1.) Wypisanie ułamka w postaci licznik/mianownik. (2.) Wypisanie wartości dziesiętnej ułamka oraz (3.) obcięcie części dziesiętnej wypisywanego ułamka.