#include <iostream>

using namespace std;

class Wymierna
{
    friend ostream& operator<<(ostream& os, const Wymierna& liczba);
    friend Wymierna operator-(Wymierna A, Wymierna B);
    friend Wymierna operator*(Wymierna A, Wymierna B);
    friend Wymierna operator+(Wymierna A, Wymierna B);
    friend Wymierna operator/(Wymierna A, Wymierna B);
    friend bool operator==(Wymierna A, Wymierna B);
    friend bool operator==(double A, Wymierna B);
    friend bool operator==(Wymierna A, double B);
    int licznik;
    int mianownik;
public:
    Wymierna();     // konstruktor domyślny (bezargumentowy) - tworzy liczbę wymierną 0
    Wymierna(int l);    // konstruktor jednoargumentowy - tworzy liczbę całkowitą o podanej wartości
    Wymierna(int l, int m);
    double wartosc() const;
    void wypisz() const;
    void ustaw_licznik(int l);
    void ustaw_mianownik(int m);
    int pobierz_licznik() const;
    int pobierz_mianownik() const;


};



int nwd(int a, int b)
{
    if(a * b == 0)
        return 0;
    if(a < 0) a = -a;
    if(b < 0) b = -b;
    while(a != b)
    {
        if(a > b)
            a -= b;
        if(b > a)
            b -= a;
    }
    return a;
}

 Wymierna operator+(Wymierna A, Wymierna B)
 {
     int licznik = A.licznik * B.mianownik + A.mianownik * B.licznik;
     int mianownik = A.mianownik * B.mianownik;
     Wymierna wynik(licznik, mianownik);
     return wynik;
 }

 Wymierna operator-(Wymierna A, Wymierna B)
 {
     return A+(B*(-1));


 }


 Wymierna operator/(Wymierna A, Wymierna B)
 {
    int licznik = A.licznik * B.mianownik;
    int mianownik = A.mianownik * B.licznik;
    Wymierna wynik(licznik, mianownik);
    return wynik;


 }


Wymierna operator*(Wymierna A, Wymierna B)
{
    int licznik = A.licznik * B.licznik;
    int mianownik = A.mianownik * B.mianownik;
    Wymierna wynik(licznik, mianownik);
    return wynik;
}

bool operator==(Wymierna A, Wymierna B)
{
    if(A.wartosc() == B.wartosc())
        return true;
    return false;
}

bool operator==(double A, Wymierna B)
{
    if(A == B.wartosc())
        return true;
    return false;
}

bool operator==(Wymierna A, double B)
{
    if(A.wartosc() == B)
        return true;
    return false;
}

/*Wymierna iloczyn(Wymierna A, Wymierna B)
{
    int licznik = A.licznik * B.licznik;
    int mianownik = A.mianownik * B.mianownik;
    Wymierna wynik(licznik, mianownik);
    return wynik;
}*/

Wymierna::Wymierna() : licznik(0), mianownik(1) {}
Wymierna::Wymierna(int l) : licznik(l), mianownik(1) {}

Wymierna::Wymierna(int l, int m)
{
    int dzielnik = nwd(l, m);

    if(m < 0)
    {
        l = -l;
        m = -m;
    }

    licznik = l / dzielnik;
    mianownik = m / dzielnik;
}

double Wymierna::wartosc() const
{
    return 1.0 * licznik / mianownik;
}

void Wymierna::wypisz() const
{
    if(mianownik == 1)
        cout << licznik << endl;
    else
        cout << licznik << '/' << mianownik << endl;
}

ostream& operator<<(ostream& os, const Wymierna& liczba)
{
    if(liczba.mianownik == 1)
        os << liczba.licznik;
    else
        os << liczba.licznik << '/' << liczba.mianownik;
    return os;
}

void Wymierna::ustaw_licznik(int l)
{
    licznik = l;
}

void Wymierna::ustaw_mianownik(int m)
{
    mianownik = m;
}

int Wymierna::pobierz_licznik() const
{
    return licznik;
}

int Wymierna::pobierz_mianownik() const
{
    return mianownik;
}

int main()
{
    Wymierna A(5, 2);
    Wymierna B(3, 4);
    cout << (2.5 == A) << endl;
    return 0;
}