Rational.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <cassert>
#include <cmath>
#include <fstream>
#include <iostream>
#include <numeric>
 
#include "Exceptions/Exceptions.hpp"
#include "Tools/Utils.hpp"
 
namespace Arkulib {
    template<typename IntType = int>
    class Rational {
 
    public:
 
        /************************************************************************************************************
         ****************************************** CONSTRUCTOR / DESTRUCTOR ****************************************
         ************************************************************************************************************/
 
        inline constexpr Rational() : m_numerator(0), m_denominator(1) { verifyTemplateType(); }
 
        constexpr Rational(
                IntType numerator,
                IntType denominator,
                bool willBeReduce = true,
                bool willDenominatorBeVerified = true
        );
 
        template<typename FloatingType>
        constexpr explicit Rational(const FloatingType &nonRational);
 
        inline constexpr Rational(const Rational<IntType> &reference) = default;
 
        template<typename AnotherIntType>
        constexpr explicit Rational(Rational<AnotherIntType> &copiedRational);
 
        inline ~Rational() = default;
 
        /************************************************************************************************************
         ************************************************ GETTERS ***************************************************
         ************************************************************************************************************/
 
        [[nodiscard]] constexpr inline IntType getNumerator() const noexcept { return m_numerator; }
 
        [[nodiscard]] constexpr inline IntType getDenominator() const noexcept { return m_denominator; }
 
        inline const IntType &operator[](const size_t &id) const;
 
        [[maybe_unused]] [[nodiscard]] constexpr inline IntType getLargerOperand() const noexcept {
            return std::max(getNumerator(), getDenominator());
        }
 
        [[maybe_unused]] [[nodiscard]] constexpr inline IntType getLowerOperand() const noexcept {
            return std::min(getNumerator(), getDenominator());
        }
 
        /************************************************************************************************************
         ************************************************ SETTERS ***************************************************
         ************************************************************************************************************/
 
        constexpr inline void setNumerator(IntType numerator) { m_numerator = numerator; };
 
        constexpr inline void setDenominator(IntType denominator) {
            verifyDenominator(denominator);
            m_denominator = denominator;
        };
 
        inline IntType &operator[](const size_t &id);
 
        /************************************************************************************************************
         ************************************************* STATUS ***************************************************
         ************************************************************************************************************/
 
        [[maybe_unused]] [[nodiscard]] inline bool isNegative() const noexcept { return getNumerator() < 0; };
 
        [[maybe_unused]] [[nodiscard]] inline bool isInteger() const noexcept { return getDenominator() == 1; };
 
        [[maybe_unused]] [[nodiscard]] inline bool isZero() const noexcept { return getNumerator() == 0; };
 
        /************************************************************************************************************
         *********************************************** OPERATOR + *************************************************
         ************************************************************************************************************/
 
        constexpr Rational<IntType> operator+(const Rational<IntType> &anotherRational) const;
 
        template<typename NonRationalType>
        constexpr inline Rational<IntType> operator+(const NonRationalType &nonRational) const {
            return Rational<IntType>(nonRational) + *this;
        }
 
        template<typename NonRationalType>
        constexpr inline friend Rational<IntType> operator+(
                const NonRationalType nonRational,
                const Rational<IntType> &rational
        ) {
            return Rational<IntType>(nonRational) + rational;
        }
 
        /************************************************************************************************************
         *********************************************** OPERATOR - *************************************************
         ************************************************************************************************************/
 
        constexpr Rational<IntType> operator-(const Rational<IntType> &anotherRational) const;
 
        template<typename NonRationalType>
        constexpr inline Rational<IntType> operator-(const NonRationalType &nonRational) const {
            return *this - Rational<IntType>(nonRational);
        }
 
        template<typename NonRationalType>
        constexpr inline friend Rational<IntType> operator-(
                const NonRationalType nonRational,
                const Rational<IntType> &rational
        ) {
            return Rational<IntType>(nonRational) - rational;
        }
 
        constexpr inline friend Rational operator-(const Rational &rational) {
            return Rational<IntType>(-rational.getNumerator(), rational.getDenominator());
        }
 
        /************************************************************************************************************
         *********************************************** OPERATOR * *************************************************
         ************************************************************************************************************/
 
        constexpr Rational<IntType> operator*(const Rational<IntType> &anotherRational) const;
 
        template<typename NonRationalType>
        constexpr inline Rational<IntType> operator*(const NonRationalType &nonRational) const {
            return *this * Rational<IntType>(nonRational);
        }
 
        template<typename NonRationalType>
        constexpr inline friend Rational<IntType> operator*(
                const NonRationalType nonRational,
                const Rational<IntType> &rational
        ) {
            return Rational<IntType>(nonRational) * rational;
        }
 
        /************************************************************************************************************
         *********************************************** OPERATOR / *************************************************
         ************************************************************************************************************/
 
        constexpr Rational<IntType> operator/(const Rational<IntType> &anotherRational) const;
 
        template<typename NonRationalType>
        constexpr inline Rational<IntType> operator/(const NonRationalType &nonRational) const {
            return *this / Rational<IntType>(nonRational);
        }
 
        template<typename NonRationalType>
        constexpr inline friend Rational<IntType> operator/(
                const NonRationalType nonRational,
                const Rational<IntType> &rational
        ) {
            return Rational<IntType>(nonRational) / rational;
        }
 
        /************************************************************************************************************
         ********************************************** OPERATOR == *************************************************
         ************************************************************************************************************/
 
        constexpr inline bool operator==(const Rational<IntType> &anotherRational) const {
            Rational<IntType> leftRational = simplify();
            Rational<IntType> rightRational = anotherRational.simplify();
 
            return (leftRational.getNumerator() == rightRational.getNumerator() &&
                    leftRational.getDenominator() == rightRational.getDenominator());
        }
 
        template<typename NonRationalType>
        constexpr inline bool operator==(const NonRationalType &nonRational) const {
            return Rational<IntType>(nonRational) == *this;
        }
 
        template<typename NonRationalType>
        constexpr inline friend bool operator==(
                const NonRationalType nonRational,
                const Rational<IntType> &rational
        ) {
            return Rational<IntType>(nonRational) == rational;
        }
 
        /************************************************************************************************************
         ********************************************** OPERATOR != *************************************************
         ************************************************************************************************************/
 
        constexpr inline bool operator!=(const Rational<IntType> &anotherRational) const {
            Rational<IntType> leftRational = simplify();
            Rational<IntType> rightRational = anotherRational.simplify();
 
            return (leftRational.getNumerator() != rightRational.getNumerator() ||
                    leftRational.getDenominator() != rightRational.getDenominator());
        }
 
        template<typename NonRationalType>
        constexpr inline bool operator!=(const NonRationalType &nonRational) const {
            return Rational<IntType>(nonRational) != *this;
        }
 
        template<typename NonRationalType>
        constexpr inline friend bool operator!=(
                const NonRationalType nonRational,
                const Rational<IntType> &rational
        ) {
            return Rational<IntType>(nonRational) != rational;
        }
 
        /************************************************************************************************************
         *********************************************** OPERATOR < *************************************************
         ************************************************************************************************************/
 
        constexpr inline bool operator<(const Rational<IntType> &anotherRational) const {
            return toRealNumber() < anotherRational.toRealNumber();
        }
 
        template<typename NonRationalType>
        constexpr inline bool operator<(const NonRationalType &nonRational) const { return *this < Rational<IntType>(nonRational); }
 
        template<typename NonRationalType>
        constexpr inline friend bool operator<(
                const NonRationalType nonRational,
                const Rational<IntType> &rational
        ) {
            return Rational<IntType>(nonRational) < rational;
        }
 
        /************************************************************************************************************
         *********************************************** OPERATOR <= *************************************************
         ************************************************************************************************************/
 
        constexpr inline bool operator<=(const Rational<IntType> &anotherRational) const {
            return toRealNumber() <= anotherRational.toRealNumber();
        }
 
        template<typename NonRationalType>
        constexpr inline bool operator<=(const NonRationalType &nonRational) const {
            return *this <= Rational<IntType>(nonRational);
        }
 
        template<typename NonRationalType>
        constexpr inline friend bool operator<=(
                const NonRationalType nonRational,
                const Rational<IntType> &rational
        ) {
            return Rational<IntType>(nonRational) <= rational;
        }
 
        /************************************************************************************************************
         *********************************************** OPERATOR > *************************************************
         ************************************************************************************************************/
 
        constexpr inline bool operator>(const Rational<IntType> &anotherRational) const {
            return toRealNumber() > anotherRational.toRealNumber();
        }
 
        template<typename NonRationalType>
        constexpr inline bool operator>(const NonRationalType &nonRational) const {
            return *this > Rational<IntType>(nonRational);
        }
 
        template<typename NonRationalType>
        constexpr inline friend bool operator>(
                const NonRationalType nonRational,
                const Rational<IntType> &rational
        ) {
            return Rational<IntType>(nonRational) > rational;
        }
 
        /************************************************************************************************************
         *********************************************** OPERATOR >= *************************************************
         ************************************************************************************************************/
 
        constexpr inline bool operator>=(const Rational<IntType> &anotherRational) const {
            return toRealNumber() >= anotherRational.toRealNumber();
        }
 
        template<typename NonRationalType>
        constexpr inline bool operator>=(const NonRationalType &nonRational) const {
            return *this >= Rational<IntType>(nonRational);
        }
 
        template<typename NonRationalType>
        constexpr inline friend bool operator>=(
                const NonRationalType nonRational,
                const Rational<IntType> &rational
        ) {
            return Rational<IntType>(nonRational) >= rational;
        }
 
        /************************************************************************************************************
         *********************************************** OPERATOR += ************************************************
         ************************************************************************************************************/
 
        constexpr Rational<IntType> operator+=(const Rational<IntType> &anotherRational) {
            *this = *this + anotherRational;
            return *this;
        }
 
        template<typename NonRationalType>
        constexpr inline Rational<IntType> operator+=(const NonRationalType &nonRational) {
            *this = *this + Rational<IntType>(nonRational);
            return *this;
        }
 
        /************************************************************************************************************
         *********************************************** OPERATOR ++ ************************************************
         ************************************************************************************************************/
 
         constexpr inline void operator++() { *this += 1; }
 
        /************************************************************************************************************
         *********************************************** OPERATOR -= ************************************************
         ************************************************************************************************************/
 
        constexpr Rational<IntType> operator-=(const Rational<IntType> &anotherRational) {
            *this = *this - anotherRational;
            return *this;
        }
 
        template<typename NonRationalType>
        constexpr inline Rational<IntType> operator-=(const NonRationalType &nonRational) {
            *this = *this - Rational<IntType>(nonRational);
            return *this;
        }
 
        /************************************************************************************************************
         *********************************************** OPERATOR -- ************************************************
         ************************************************************************************************************/
 
        constexpr inline void operator--() { *this -= 1; }
 
        /************************************************************************************************************
         *********************************************** OPERATOR *= ************************************************
         ************************************************************************************************************/
 
        constexpr inline Rational<IntType> operator*=(const Rational<IntType> &anotherRational) {
            *this = *this * anotherRational;
            return *this;
        }
 
        template<typename NonRationalType>
        constexpr inline Rational<IntType> operator*=(const NonRationalType &nonRational) {
            *this = *this * Rational<IntType>(nonRational);
            return *this;
        }
 
        /************************************************************************************************************
         *********************************************** OPERATOR /= ************************************************
         ************************************************************************************************************/
 
        constexpr inline Rational<IntType> operator/=(const Rational<IntType> &anotherRational) {
            *this = *this / anotherRational;
            return *this;
        }
 
        template<typename NonRationalType>
        constexpr inline Rational<IntType> operator/=(const NonRationalType &nonRational) {
            *this = *this / Rational<IntType>(nonRational);
            return *this;
        }
 
 
        /************************************************************************************************************
         ************************************************* MATHS ****************************************************
         ************************************************************************************************************/
 
        [[maybe_unused]] [[nodiscard]] constexpr inline Rational<IntType> inverse() const {
            return Rational<IntType>(getDenominator(), getNumerator());
        }
 
        [[maybe_unused]] [[nodiscard]] constexpr Rational<IntType> sqrt() const;
 
        [[maybe_unused]] [[nodiscard]] constexpr Rational<IntType> cos() const;
 
        [[maybe_unused]] [[nodiscard]] constexpr Rational<IntType> exp() const;
 
        template<typename FloatingType>
        [[maybe_unused]] [[nodiscard]] constexpr Rational<IntType> pow(const FloatingType &k) const;
 
        [[maybe_unused]] [[nodiscard]] constexpr inline Rational<IntType> abs() const {
            return Rational<IntType>(std::abs(getNumerator()), std::abs(getDenominator()));
        };
 
        [[maybe_unused]] [[nodiscard]] constexpr Rational<IntType> simplify() const noexcept;
 
        /************************************************************************************************************
         ************************************************* MINIMUM **************************************************
         ************************************************************************************************************/
 
        [[maybe_unused]] [[nodiscard]] constexpr static Rational<IntType> min(
            Rational<IntType> rational1,
            Rational<IntType> rational2
        ) noexcept;
 
        template<typename ...Args>
        [[maybe_unused]] [[nodiscard]] constexpr static Rational<IntType> min(
            Rational<IntType> rational,
            Args... args
        ) noexcept;
 
        /************************************************************************************************************
         ************************************************* MAXIMUM **************************************************
         ************************************************************************************************************/
 
        [[maybe_unused]] [[nodiscard]] constexpr static Rational<IntType> max(
                Rational<IntType> rational1,
                Rational<IntType> rational2
        ) noexcept;
 
        template<typename ...Args>
        [[maybe_unused]] [[nodiscard]] constexpr static Rational<IntType> max(
                Rational<IntType> rational,
                Args... args
        ) noexcept;
 
        /************************************************************************************************************
         ************************************************* STATIC ***************************************************
         ************************************************************************************************************/
 
        inline constexpr static Rational<IntType> Zero() noexcept { return Rational<IntType>(0, 1); }
 
        inline constexpr static Rational<IntType> One() noexcept { return Rational<IntType>(1, 1); }
 
        inline constexpr static Rational<IntType> Pi() noexcept { return Rational<IntType>(355, 113, false); }
 
        [[maybe_unused]] inline constexpr static Rational<IntType> Infinite() noexcept { return Rational<IntType>(1, 0, false, false); }
 
        /************************************************************************************************************
         *********************************************** CONVERSION *************************************************
         ************************************************************************************************************/
 
        [[nodiscard]] inline constexpr Rational<IntType> toApproximation(
                unsigned int digitsKept = Constant::DEFAULT_KEPT_DIGITS_APPROXIMATE
        ) const;
 
        [[nodiscard]] inline constexpr IntType toInteger() const noexcept {
            assert(getDenominator() != 0 && "This denominator shouldn't never be equal to 0");
            return IntType(getNumerator() / getDenominator());
        }
 
        template<typename FloatingType = float>
        [[nodiscard]] inline constexpr FloatingType toRealNumber() const noexcept {
            assert(getDenominator() != 0 && "This denominator shouldn't never be equal to 0");
            return getNumerator() / FloatingType(getDenominator());
        }
 
        [[nodiscard]] inline std::string toString() const noexcept {
            return "(" + std::to_string(getNumerator()) + " / " + std::to_string(getDenominator()) + ")";
        }
 
        template<typename FloatingType = double>
        [[nodiscard]] static constexpr Rational<IntType> fromFloatingPoint(
                FloatingType floatingRatio,
                size_t iter = Constant::DEFAULT_ITERATIONS_FROM_FP
        );
 
        [[maybe_unused]] inline constexpr void static print(const Rational<IntType> rational) noexcept {
            std::cout << rational.toString() << std::endl << std::endl;
        }
 
        template<typename... Args>
        [[maybe_unused]] inline constexpr void static print(const Rational<IntType> rational, Args... args) noexcept {
            std::cout << rational.toString() << std::endl;
            print(args...);
        }
 
 
    protected:
        /************************************************************************************************************
         ********************************************* MEMBERS ******************************************************
         ************************************************************************************************************/
 
        IntType m_numerator; 
        IntType m_denominator; 
        /************************************************************************************************************
         ********************************************* METHODS ******************************************************
         ************************************************************************************************************/
 
        constexpr inline void verifyTemplateType() const {
            if (!std::is_integral<IntType>()) throw Exceptions::FloatTypeGivenException();
        };
 
        constexpr void verifyDenominator(IntType denominator, bool checkIfDenominatorIsNull = true);
 
        template<typename AnotherIntType>
        constexpr void verifyNumberLargeness(Rational<AnotherIntType> &anotherRational) const;
 
        constexpr inline static Rational<IntType> checkForOverflowThenReturn(
                const long long int numerator,
                const long long int denominator
        ) {
            Rational<long long int> errorChecker(numerator, denominator);
            return Rational<IntType>(errorChecker);
            // During the copy constructor, the method verifyLargeness will be executed.
        }
    };
 
 
 
 
    /************************************************************************************************************
     ************************************************************************************************************/
 
 
 
    /************************************************************************************************************
     ********************************************* CONSTRUCTOR DEF **********************************************
     ************************************************************************************************************/
 
    template<typename IntType>
    constexpr Rational<IntType>::Rational(
            const IntType numerator,
            const IntType denominator,
            const bool willBeReduce,
            const bool willDenominatorBeVerified
    ) : m_numerator(numerator), m_denominator(denominator) {
        verifyTemplateType();
        verifyDenominator(denominator, willDenominatorBeVerified);
 
        if (willBeReduce) *this = simplify();
    }
 
    /************************************************************************************************************/
 
    template<typename IntType>
    template<typename FloatingType>
    constexpr Rational<IntType>::Rational(const FloatingType &nonRational) {
        verifyTemplateType();
 
        if (std::is_integral<FloatingType>()) {
            *this = Rational<IntType>(nonRational, 1);
        }
 
        else {
            Rational<long long int> tmpRational = Rational<long long int>::fromFloatingPoint(nonRational);
 
            if (tmpRational.isZero() && Tools::roundToWantedPrecision(nonRational) != static_cast<FloatingType>(0)) {
                // Because Very large number return 0
                throw Exceptions::NumberTooLargeException();
            }
 
            *this = Rational<IntType>(tmpRational);
        }
    }
 
    /************************************************************************************************************/
 
    template<typename IntType>
    template<typename AnotherIntType>
    constexpr Rational<IntType>::Rational(Rational<AnotherIntType> &copiedRational)
            : m_numerator(copiedRational.getNumerator()), m_denominator(copiedRational.getDenominator()){
        verifyNumberLargeness(copiedRational);
    }
 
    /************************************************************************************************************
     ********************************************* OPERATORS[] DEF **********************************************
     ************************************************************************************************************/
 
    template<typename IntType>
    const IntType &Rational<IntType>::operator[](const size_t &id) const {
        if (id == 0) return getNumerator();
        else if (id == 1) return getDenominator();
        else throw Exceptions::InvalidAccessArgument();
    }
 
    template<typename IntType>
    IntType &Rational<IntType>::operator[](const size_t &id) {
        if (id == 0) return m_numerator;
        else if (id == 1) return m_denominator;
        else throw Exceptions::InvalidAccessArgument();
    }
 
    /************************************************************************************************************
     ********************************************* OPERATOR + DEF ***********************************************
     ************************************************************************************************************/
 
    template<typename IntType>
    constexpr Rational<IntType> Rational<IntType>::operator+(const Rational<IntType> &anotherRational) const {
        return Rational<IntType>::checkForOverflowThenReturn(
                static_cast<long long int>(getNumerator()) * anotherRational.getDenominator() + getDenominator() * anotherRational.getNumerator(),
                static_cast<long long int>(getDenominator()) * anotherRational.getDenominator()
        );
    }
 
    /************************************************************************************************************
     ********************************************* OPERATOR - DEF ***********************************************
     ************************************************************************************************************/
 
    template<typename IntType>
    constexpr Rational<IntType> Rational<IntType>::operator-(const Rational<IntType> &anotherRational) const {
        return Rational<IntType>::checkForOverflowThenReturn(
                static_cast<long long int>(getNumerator()) * anotherRational.getDenominator() - getDenominator() * anotherRational.getNumerator(),
                static_cast<long long int>(getDenominator()) * anotherRational.getDenominator()
        );
    }
 
    /************************************************************************************************************
     ********************************************* OPERATOR * DEF ***********************************************
     ************************************************************************************************************/
 
    template<typename IntType>
    constexpr Rational<IntType> Rational<IntType>::operator*(const Rational<IntType> &anotherRational) const {
        return Rational<IntType>::checkForOverflowThenReturn(
                static_cast<long long int>(getNumerator()) * anotherRational.getNumerator(),
                static_cast<long long int>(getDenominator()) * anotherRational.getDenominator()
        );
    }
 
    /************************************************************************************************************
     ********************************************* OPERATOR / DEF ***********************************************
     ************************************************************************************************************/
 
    template<typename IntType>
    constexpr Rational<IntType> Rational<IntType>::operator/(const Rational<IntType> &anotherRational) const {
        return Rational<IntType>::checkForOverflowThenReturn(
                static_cast<long long int>(getNumerator()) * anotherRational.getDenominator(),
                static_cast<long long int>(getDenominator()) * anotherRational.getNumerator()
        );
    }
 
    /************************************************************************************************************
     ************************************************ MATHS DEF *************************************************
     ************************************************************************************************************/
 
    template<typename IntType>
    constexpr Rational<IntType> Rational<IntType>::sqrt() const {
        if (isNegative()) throw Exceptions::NegativeSqrtException();
        return Rational<IntType>(
                std::sqrt(static_cast<double>(getNumerator()) / getDenominator())
        );
    }
 
    template<typename IntType>
    Rational<IntType> constexpr Rational<IntType>::cos() const {
        return Rational<IntType>(
                std::cos(static_cast<double>(getNumerator()) / getDenominator())
        );
    }
 
    template<typename IntType>
    Rational<IntType> constexpr Rational<IntType>::exp() const {
        return Rational<IntType>(
                std::exp(static_cast<double>(getNumerator()) / getDenominator())
        );
    }
 
    template<typename IntType>
    template<typename FloatingType>
    constexpr Rational<IntType> Rational<IntType>::pow(const FloatingType &k) const {
        return Rational<IntType>(
                std::pow(static_cast<double>(getNumerator()) / getDenominator(), k)
        );
    }
 
    template<typename IntType>
    Rational<IntType> constexpr Rational<IntType>::simplify() const noexcept {
        const int gcd = std::gcd(getNumerator(), getDenominator());
        assert(gcd != 0 && "GCD shouldn't be equal to 0");
 
        return Rational<IntType>(
                getNumerator() / gcd,
                getDenominator() / gcd,
                false
        );
    }
 
    /************************************************************************************************************
     ************************************************ MINIMUM DEF ***********************************************
     ************************************************************************************************************/
 
    template<typename IntType>
    constexpr Rational<IntType> Rational<IntType>::min(
            const Rational<IntType> rational1,
            const Rational<IntType> rational2
    ) noexcept {
        return rational1 < rational2 ? rational1 : rational2;
    }
 
    template<typename IntType>
    template<typename... Args>
    constexpr Rational<IntType> Rational<IntType>::min(
            const Rational<IntType> rational,
            Args... args
    ) noexcept {
        return min(rational, min(args...));
    }
 
    /************************************************************************************************************
     ************************************************ MAXIMUM DEF ***********************************************
     ************************************************************************************************************/
 
    template<typename IntType>
    constexpr Rational<IntType> Rational<IntType>::max(
            const Rational<IntType> rational1,
            const Rational<IntType> rational2
    ) noexcept {
        return rational1 < rational2 ? rational2 : rational1;
    }
 
    template<typename IntType>
    template<typename... Args>
    constexpr Rational<IntType> Rational<IntType>::max(
            const Rational<IntType> rational,
            Args... args
    ) noexcept {
        return max(rational, max(args...));
    }
 
    /************************************************************************************************************
     ********************************************** CONVERSION DEF **********************************************
     ************************************************************************************************************/
 
    template<typename IntType>
    constexpr Rational<IntType> Rational<IntType>::toApproximation(const unsigned int digitsKept) const  {
        if (digitsKept > Constant::DEFAULT_MAX_DIGITS_APPROXIMATE) throw Exceptions::DigitsTooLargeException();
        return Rational<IntType>(Tools::roundToWantedPrecision(toRealNumber<double>(), std::pow(10,digitsKept)));
    }
 
    template<typename IntType>
    template<typename FloatingType>
    Rational<IntType> constexpr Rational<IntType>::fromFloatingPoint(
            const FloatingType floatingRatio,
            size_t iter
    ) {
        constexpr FloatingType ZERO = 0;
        constexpr FloatingType ONE = 1;
 
        if (floatingRatio < ZERO) {
            return -fromFloatingPoint(-floatingRatio, iter);
        }
 
        if (floatingRatio <= static_cast<FloatingType>(Constant::DEFAULT_THRESHOLD_FROM_FP) || iter == 0) {
            return Rational<IntType>::Zero();
        }
 
        if (floatingRatio < ONE) {
            assert(floatingRatio != 0 && "floatingRatio shouldn't never be equal to 0 here");
            return fromFloatingPoint(ONE / floatingRatio, iter).inverse();
        }
 
        auto integerPart = static_cast<IntType>(floatingRatio);
        return fromFloatingPoint(floatingRatio - integerPart, iter - 1)
               + Rational<IntType>(integerPart, ONE);
    }
 
    /************************************************************************************************************
     ************************************************ METHODS DEF ***********************************************
     ************************************************************************************************************/
 
    template<typename IntType>
    template<typename AnotherIntType>
    constexpr void Rational<IntType>::verifyNumberLargeness(
            Rational<AnotherIntType> &anotherRational
    ) const {
        // If the value of the other rational is above the limits of IntType
        if ((std::numeric_limits<IntType>::max() < anotherRational.getLargerOperand() ||
             std::numeric_limits<IntType>::lowest() > anotherRational.getLowerOperand())) {
            throw Exceptions::NumberTooLargeException();
        }
        // We assume (sadly) that the user won't go beyond long long int max (so naive)
    }
 
    template<typename IntType>
    constexpr void Rational<IntType>::verifyDenominator(
            const IntType denominator,
            const bool checkIfDenominatorIsNull
    ) {
        constexpr IntType ZERO = 0;
        if (denominator == ZERO && checkIfDenominatorIsNull)
            throw Exceptions::DivideByZeroException();
 
        if (denominator < ZERO) {
            m_numerator = -m_numerator;
            m_denominator = -denominator;
        }
    }
 
    /************************************************************************************************************
     ******************************************* STD::COUT OVERRIDE *********************************************
     ************************************************************************************************************/
 
    template<typename IntType>
    std::ostream &operator<<(std::ostream &stream, const Rational<IntType> &rational) {
        return stream << rational.toString();
    }
}