Fraction.hpp

#include <type_traits>

template <
    class TInt, 
    typename std::enable_if<
        std::is_integral<TInt>::value, 
        int
    >::type = 0
>
class Fraction {
private:
    TInt Numerator;
    TInt Denominator;

    template <class T>
    constexpr static T Gcd(T x, T y) noexcept {
        return y == 0 ? x : Gcd(y, x % y);
    }

    constexpr void Normalize() noexcept {
        const auto Gcd = Fraction::Gcd(this->Numerator, this->Denominator);
        this->Numerator /= Gcd;
        this->Denominator /= Gcd;
    }

public:
    constexpr Fraction(TInt Number) noexcept :
        Numerator(Number), Denominator(1) {}

    constexpr Fraction(TInt Numerator, TInt Denominator) noexcept :
        Numerator(Numerator), Denominator(Denominator)
    {
        this->Normalize();
    }

    constexpr TInt GetNumerator() const noexcept {
        return this->Numerator;
    }

    constexpr TInt GetDenominator() const noexcept {
        return this->Denominator;
    }

    constexpr Fraction& operator *= (Fraction Other) noexcept {
        this->Numerator *= Other.Numerator;
        this->Denominator *= Other.Denominator;
        this->Normalize();
        return *this;
    }

    constexpr Fraction& operator /= (Fraction Other) noexcept {
        this->Numerator *= Other.Denominator;
        this->Denominator *= Other.Numerator;
        this->Normalize();
        return *this;
    }

    constexpr Fraction& operator += (Fraction Other) noexcept {
        this->Numerator = this->Numerator * Other.Denominator +
                          Other.Numerator * this->Denominator;
        this->Denominator *= Other.Denominator;
        this->Normalize();
        return *this;
    }

    constexpr Fraction& operator -= (Fraction Other) noexcept {
        this->Numerator = this->Numerator * Other.Denominator -
                          Other.Numerator * this->Denominator;
        this->Denominator *= Other.Denominator;
        this->Normalize();
        return *this;
    }

    constexpr friend Fraction operator * (Fraction Lhs, Fraction Rhs) noexcept {
        return (Lhs *= Rhs);
    }

    constexpr friend Fraction operator / (Fraction Lhs, Fraction Rhs) noexcept {
        return (Lhs /= Rhs);
    }

    constexpr friend Fraction operator + (Fraction Lhs, Fraction Rhs) noexcept {
        return (Lhs += Rhs);
    }

    constexpr friend Fraction operator - (Fraction Lhs, Fraction Rhs) noexcept {
        return (Lhs -= Rhs);
    }
};