#include <iostream>
#include <cmath>

namespace fraction
{
    int gcd(int a, int b)
    {
        if (!a)
            return b;
        return gcd(b % a, a);
    }

    int lcm(int a, int b)
    {
        return (a * b) / gcd(a, b);
    }


    struct fraction
    {
        fraction() {}
        fraction(int, int);
        fraction(const fraction&);
        fraction(double);

        fraction &operator+(int);
        fraction &operator+(fraction &);

        fraction &operator-(int);
        fraction &operator-(fraction &);

        fraction &operator*(int);
        fraction &operator*(fraction &);

        fraction &operator/(int);
        fraction &operator/(fraction &);

        fraction &operator=(const fraction &);

        fraction &simplify();
        fraction &fpow(int);


        friend bool operator<(fraction &, fraction &);

        friend bool operator>=(fraction &, fraction &);
        friend bool operator==(fraction &, fraction &);
        friend bool operator>(fraction &, fraction &);
        friend bool operator<=(fraction &, fraction &);
        friend bool operator!=(fraction &, fraction &);


        friend std::ostream &operator<<(std::ostream &, const fraction &);



    private:
        int numerator;
        int denominator;
    };


    fraction::fraction(int numerator, int denominator)
    {
        fraction f;
        f.numerator = numerator;
        f.denominator = denominator;
        f.simplify();
        this->numerator = f.numerator;
        this->denominator = f.denominator;
    }

    fraction::fraction(const fraction &f)
    {
        this->numerator = f.numerator;
        this->denominator = f.denominator;
    }

    fraction::fraction(double d)
    {
        int i = 0;
        for (; d!=((int)d); i++) { d*=10; }

        this->numerator = d * pow(10, i);
        this->denominator = pow(10, i);
        this->simplify();
    }

    fraction &fraction::operator+(int digit)
    {
        this->numerator += digit * this->denominator;
        this->simplify();
        return *this;
    }

    fraction &fraction::operator+(fraction &f)
    {
        int lcm = ::fraction::lcm(this->denominator, f.denominator);
        this->numerator *= lcm / this->denominator;
        f.numerator *= lcm / f.denominator;
        f.denominator = lcm;
        this->numerator += f.numerator;
        this->denominator = lcm;

        f.simplify();
        this->simplify();
        return *this;

    }

    fraction &fraction::operator-(int digit)
    {
        this->numerator -= digit * this->denominator;

        this->simplify();
        return *this;
    }

    fraction &fraction::operator-(fraction &f)
    {
        int lcm = ::fraction::lcm(this->denominator, f.denominator);
        this->numerator *= lcm / this->denominator;
        f.numerator *= lcm / f.denominator;
        f.denominator = lcm;
        this->numerator -= f.numerator;
        this->denominator = lcm;

        f.simplify();
        this->simplify();
        return *this;

    }

    fraction &fraction::operator*(int digit)
    {
        this->numerator *= digit;

        this->simplify();
        return *this;
    }

    fraction &fraction::operator*(fraction &f)
    {
        this->numerator *= f.numerator;
        this->denominator *= f.denominator;

        this->simplify();
        return *this;

    }

    fraction &fraction::operator/(int digit)
    {
        this->denominator *= digit;

        this->simplify();
        return *this;
    }

    fraction &fraction::operator/(fraction &f)
    {
        this->numerator *= f.denominator;
        this->denominator *= f.numerator;

        this->simplify();
        return *this;
    }

    fraction& fraction::operator=(const fraction &f)
    {
        this->numerator = f.numerator;
        this->denominator = f.denominator;

        return *this;

    }

    //advanced arithmetics
    fraction &fraction::simplify()
    {
        int gcd = ::fraction::gcd(this->numerator, this->denominator);
        this->numerator /= gcd;
        this->denominator /= gcd;

        return *this;
    }

    fraction& fraction::fpow(int pow)
    {
        this->numerator *= pow;
        this->denominator *= pow;

        return *this;
    }


    //logical
    bool operator<(fraction &l, fraction &r)
    {
        l.simplify();
        r.simplify();

        int lcm = ::fraction::lcm(l.denominator, r.denominator);
        l.numerator *= lcm / l.denominator;
        l.denominator = lcm;
        r.numerator *= lcm / r.denominator;
        r.denominator = lcm;

        return l.numerator < r.numerator;
    }


    bool operator>(fraction &l, fraction &r)
    {
        return r < l;
    }

    bool operator>=(fraction &l, fraction &r)
    {
        return !(l < r);
    }

    bool operator<=(fraction &l, fraction &r)
    {
        return !(l > r);
    }

    bool operator!=(fraction &l, fraction &r)
    {
        return l > r || r > l;
    }

    bool operator==(fraction &l, fraction &r)
    {
        return !(l != r);
    }


    std::ostream &operator<<(std::ostream &l, const fraction &r)
    {
        return l << r.numerator << "/" << r.denominator;
    }




    extern "C" void init()
    {

        std::cout << "Over here!\n";
        fraction f1(3,4), f2(1,2);
        fraction f = f1 + f2;
        std::cout << f1 << ((f1 > f2) ? " bigger than " : " smaller than ") << f2 << "\n";
        std::cout << "+: " << f << "\n";
        f = f1 - f2;
        std::cout << "-: " << f << "\n";
        f = f1 * f2;
        std::cout << "*: " << f << "\n";
        f = f1 / f2;
        std::cout << "/: " << f << "\n";


    }

}


int main() {
    using namespace fraction;

    init();
    return 0;
}