ERational.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "Rational.hpp"
#include <iomanip>
 
namespace Arkulib {
    template<typename FloatType = double>
    class ERational {
 
    public:
 
        /************************************************************************************************************
         ****************************************** CONSTRUCTOR / DESTRUCTOR ****************************************
         ************************************************************************************************************/
 
        constexpr explicit ERational();
 
        template<typename IntType = int>
        constexpr explicit ERational(
                IntType numerator,
                IntType denominator,
                bool willBeReduce = false,
                bool willDenominatorBeVerified = true
        );
 
        template<typename FloatingType>
        constexpr explicit ERational(const FloatingType &nonRational);
 
        inline constexpr ERational(const ERational<FloatType> &reference) = default;
 
        template<typename IntType>
        inline constexpr explicit ERational(const Rational<IntType> &reference) {
            *this = ERational<FloatType>(reference.getNumerator(), reference.getDenominator());
        };
 
        constexpr ERational(
                FloatType numMultiplier, short int numExponent,
                FloatType denMultiplier, short int denExponent
        );
 
        constexpr ERational(
                std::pair<FloatType, short int> numerator,
                std::pair<FloatType, short int> denominator
        );
 
        inline ~ERational() = default;
 
        /************************************************************************************************************
         ************************************************ GETTERS ***************************************************
         ************************************************************************************************************/
 
        [[maybe_unused]] [[nodiscard]] constexpr inline std::pair<FloatType,short int> getNumerator() const noexcept { return m_numerator; }
        [[nodiscard]] constexpr inline FloatType getNumMultiplier() const noexcept { return m_numerator.first; }
        [[nodiscard]] constexpr inline short int getNumExponent() const noexcept { return m_numerator.second; }
 
        [[maybe_unused]] [[nodiscard]] constexpr inline std::pair<FloatType,short int> getDenominator() const noexcept { return m_denominator; }
        [[nodiscard]] constexpr inline FloatType getDenMultiplier() const noexcept { return m_denominator.first; }
        [[nodiscard]] constexpr inline short int getDenExponent() const noexcept { return m_denominator.second; }
 
        /************************************************************************************************************
         ************************************************ SETTERS ***************************************************
         ************************************************************************************************************/
 
        constexpr inline void setNumerator(std::pair<FloatType, short int> numerator) noexcept { m_numerator = numerator; }
        constexpr inline void setNumerator(FloatType newMultiplier, short int newExponent) noexcept { m_numerator = std::make_pair(newMultiplier, newExponent); }
        constexpr inline void setNumMultiplier(FloatType newNumMultiplier) noexcept { m_numerator.first = newNumMultiplier; }
        constexpr inline void setNumExponent(short int newNumExponent) noexcept { m_numerator.second = newNumExponent; }
 
        constexpr inline void setDenominator(std::pair<FloatType, short int> denominator) noexcept { m_denominator = denominator; }
        constexpr inline void setDenominator(FloatType newMultiplier, short int newExponent) noexcept { m_denominator = std::make_pair(newMultiplier, newExponent); }
        constexpr inline void setDenMultiplier(FloatType newDenMultiplier) noexcept { m_denominator.first = newDenMultiplier; }
        constexpr inline void setDenExponent(short int newDenExponent) noexcept { m_denominator.second = newDenExponent; }
 
        /************************************************************************************************************
         *********************************************** OPERATOR + *************************************************
         ************************************************************************************************************/
 
        constexpr ERational<FloatType> operator+(const ERational<FloatType> &anotherERational) const;
 
        /************************************************************************************************************
         *********************************************** OPERATOR - *************************************************
         ************************************************************************************************************/
 
        constexpr ERational<FloatType> operator-(const ERational<FloatType> &anotherERational) const;
 
        /************************************************************************************************************
         *********************************************** OPERATOR * *************************************************
         ************************************************************************************************************/
 
        constexpr ERational<FloatType> operator*(const ERational<FloatType> &anotherERational) const;
 
        /************************************************************************************************************
         *********************************************** OPERATOR / *************************************************
         ************************************************************************************************************/
 
        constexpr ERational<FloatType> operator/(const ERational<FloatType> &anotherERational) const;
 
        /************************************************************************************************************
         *********************************************** OPERATOR == ************************************************
         ************************************************************************************************************/
 
        constexpr inline bool operator==(const ERational<FloatType> &anotherERational) const;
 
        /************************************************************************************************************
         ********************************************** OPERATOR != *************************************************
         ************************************************************************************************************/
 
        constexpr inline bool operator!=(const ERational<FloatType> &anotherERational) const;
 
        /************************************************************************************************************
         ************************************************* STATUS ***************************************************
         ************************************************************************************************************/
 
        [[maybe_unused]] [[nodiscard]] inline bool isNegative() const noexcept {
            return (getNumMultiplier() < 0. && getDenMultiplier() > 0.)
                    || (getNumMultiplier() > 0. && getDenMultiplier() < 0.);
        };
 
        [[maybe_unused]] [[nodiscard]] inline bool isInteger() const noexcept { return getDenMultiplier() == 1.; };
 
        [[maybe_unused]] [[nodiscard]] inline bool isZero() const noexcept { return getNumMultiplier() == 0.; };
 
        /************************************************************************************************************
         ************************************************** MATHS ***************************************************
         ************************************************************************************************************/
 
        [[maybe_unused]] [[nodiscard]] constexpr inline ERational<FloatType> abs() const {
            return ERational<FloatType>(
                    std::abs(getNumMultiplier()), getNumExponent(),
                    std::abs(getDenMultiplier()), getDenExponent()
            );
        };
 
        [[maybe_unused]] [[nodiscard]] constexpr inline ERational<FloatType> inverse() const {
            return ERational<FloatType>(getDenMultiplier(), getDenExponent(), getNumMultiplier(), getNumExponent());
        }
 
        [[maybe_unused]] constexpr ERational<FloatType> simplify() noexcept;
 
        /************************************************************************************************************
         *********************************************** CONVERSION *************************************************
         ************************************************************************************************************/
 
        template<typename AnotherFloatType = double>
        [[nodiscard]] inline constexpr AnotherFloatType toRealNumber() const noexcept {
            return static_cast<AnotherFloatType>
                (getNumMultiplier() * std::pow(10, getNumExponent())) / (getDenMultiplier() * std::pow(10, getDenExponent())
            );
        }
 
        [[nodiscard]] inline std::string toString() const noexcept {
            return "(" + Tools::toStringWithPrecision(getNumMultiplier()) + " * 10^" + Tools::toStringWithPrecision(getNumExponent()) + ")"
                   + " / " + "(" + Tools::toStringWithPrecision(getDenMultiplier()) + " * 10^" + Tools::toStringWithPrecision(getDenExponent()) + ")";
        }
 
    private:
        /************************************************************************************************************
         ************************************************** METHODS *************************************************
         ************************************************************************************************************/
 
        template<typename IntType = int>
        constexpr void transformToExperimental(IntType numerator, IntType denominator);
 
        template<typename IntType = int>
        static constexpr std::pair<FloatType, short int> transformOperandToPair(IntType operand);
 
        constexpr void verifyDenominator(bool checkIfDenominatorIsNull = true);
 
        constexpr inline void verifyTemplateType() const {
            if (std::is_integral<FloatType>()) throw Exceptions::IntTypeGivenException();
        };
 
        constexpr void setAtSameNumeratorExponent(
            ERational<FloatType> &firstERational,
            ERational<FloatType> &secondERational
        ) const;
 
        constexpr void setAtSameDenominator(
            ERational <FloatType> &firstERational,
            ERational <FloatType> &secondERational
        ) const;
 
        /************************************************************************************************************
         ************************************************** MEMBERS *************************************************
         ************************************************************************************************************/
 
        std::pair<FloatType, short int> m_numerator;
 
        std::pair<FloatType, short int> m_denominator;
        // We also could have create a struct for this pair to ease some methods
        // (for example, we could have isNegative() in the struct or even operators)
    };
 
 
 
 
    /************************************************************************************************************
     ************************************************************************************************************/
 
 
 
    /************************************************************************************************************
     ********************************************* CONSTRUCTOR DEF **********************************************
     ************************************************************************************************************/
 
    template<typename FloatType>
    constexpr ERational<FloatType>::ERational() : m_numerator(0., 0), m_denominator(1., 0) {
        verifyTemplateType();
    }
 
 
    template<typename FloatType>
    template<typename IntType>
    constexpr ERational<FloatType>::ERational(
            const IntType numerator,
            const IntType denominator,
            const bool willBeReduce,
            const bool willDenominatorBeVerified
    )   : m_numerator(transformOperandToPair(numerator)),
          m_denominator(transformOperandToPair(denominator))
    {
        verifyTemplateType();
        verifyDenominator(willDenominatorBeVerified);
 
        if (willBeReduce) {
            const int gcd = std::gcd(numerator, denominator);
            assert(gcd != 0 && "GCD shouldn't be equal to 0");
 
            transformToExperimental(numerator / gcd, denominator / gcd);
            *this = simplify();
        }
    }
 
    template<typename FloatType>
    template<typename AnotherFloatType>
    constexpr ERational<FloatType>::ERational(const AnotherFloatType &nonRational) {
        verifyTemplateType();
 
        Rational<long long int> tmpRational = Rational<long long int>::fromFloatingPoint(nonRational);
        *this = ERational{tmpRational};
    }
 
 
 
    template<typename FloatType>
    constexpr ERational<FloatType>::ERational(
            const FloatType numMultiplier,
            const short int numExponent,
            const FloatType denMultiplier,
            const short int denExponent
    ) {
        m_numerator = std::make_pair(numMultiplier, numExponent);
        m_denominator = std::make_pair(denMultiplier, denExponent);
    }
 
 
    template<typename FloatType>
    constexpr ERational<FloatType>::ERational(
            std::pair<FloatType, short int> numerator,
            std::pair<FloatType, short int> denominator
    ) {
        m_numerator = numerator;
        m_denominator = denominator;
    }
 
    /************************************************************************************************************
     ********************************************* OPERATOR + DEF ***********************************************
     ************************************************************************************************************/
 
    template<typename FloatType>
    constexpr ERational<FloatType> ERational<FloatType>::operator+(const ERational<FloatType> &anotherERational) const {
        // We create new Rational with the same denominator (we multiply them by denominator / denominator)
        ERational<FloatType> firstERational = *this;
        ERational<FloatType> secondERational = anotherERational;
        setAtSameDenominator(firstERational, secondERational);
        setAtSameNumeratorExponent(firstERational, secondERational);
 
        return ERational<FloatType>(
                std::make_pair(
                        firstERational.getNumMultiplier() + secondERational.getNumMultiplier(),
                        firstERational.getNumExponent()
                ),
                firstERational.getDenominator()
        );
    }
 
    /************************************************************************************************************
 ********************************************* OPERATOR - DEF ***********************************************
 ************************************************************************************************************/
 
    template<typename FloatType>
    constexpr ERational<FloatType> ERational<FloatType>::operator-(const ERational<FloatType> &anotherERational) const {
        // We create new Rational with the same denominator (we multiply them by denominator / denominator)
        ERational<FloatType> firstERational = *this;
        ERational<FloatType> secondERational = anotherERational;
        setAtSameDenominator(firstERational, secondERational);
        setAtSameNumeratorExponent(firstERational, secondERational);
 
        return ERational<FloatType>(
                std::make_pair(
                        firstERational.getNumMultiplier() - secondERational.getNumMultiplier(),
                        firstERational.getNumExponent()
                ),
                firstERational.getDenominator()
        );
    }
 
    /************************************************************************************************************
     ********************************************* OPERATOR * DEF ***********************************************
     ************************************************************************************************************/
 
    template<typename FloatType>
    constexpr ERational<FloatType> ERational<FloatType>::operator*(const ERational<FloatType> &anotherERational) const {
        return ERational<FloatType>(
                getNumMultiplier() * anotherERational.getNumMultiplier(),
                getNumExponent() + anotherERational.getNumExponent(),
                getDenMultiplier() * anotherERational.getDenMultiplier(),
                getDenExponent() + anotherERational.getDenExponent()
        );
    }
 
    /************************************************************************************************************
     ********************************************* OPERATOR / DEF ***********************************************
     ************************************************************************************************************/
 
    template<typename FloatType>
    constexpr ERational<FloatType> ERational<FloatType>::operator/(const ERational<FloatType> &anotherERational) const {
        return ERational<FloatType>(
                getNumMultiplier() * anotherERational.getDenMultiplier(),
                getNumExponent() + anotherERational.getDenExponent(),
                getDenMultiplier() * anotherERational.getNumMultiplier(),
                getDenExponent() + anotherERational.getNumExponent()
        );
    }
 
    /************************************************************************************************************
     ********************************************* OPERATOR == DEF **********************************************
     ************************************************************************************************************/
 
    template<typename FloatType>
    constexpr bool ERational<FloatType>::operator==(const ERational<FloatType> &anotherERational) const {
        ERational<FloatType> leftRational = this->simplify();
        ERational<FloatType> rightRational = anotherERational->simplify();
 
        if (leftRational.getNumExponent() != rightRational.getNumExponent()
            || leftRational.getDenExponent() != rightRational.getDenExponent()
            || leftRational.toRealNumber() != rightRational.toRealNumber()) {
            return false;
        }
 
        return true;
    }
 
    /************************************************************************************************************
     ********************************************* OPERATOR != DEF **********************************************
     ************************************************************************************************************/
 
    template<typename FloatType>
    constexpr bool ERational<FloatType>::operator!=(const ERational<FloatType> &anotherERational) const {
        return (*this == anotherERational) == false;
    }
 
    /************************************************************************************************************
     ************************************************ MATHS DEF *************************************************
     ************************************************************************************************************/
 
    template<typename FloatType>
    constexpr ERational<FloatType> ERational<FloatType>::simplify() noexcept {
        const int exponentDifference = std::abs(getNumExponent() - getDenExponent());
 
        if (exponentDifference == 0 && getNumExponent() != 0) {
            setNumExponent(0);
            setDenExponent(0);
        }
 
        const int minExponent = std::min(getNumExponent(), getDenExponent());
        if (exponentDifference != 0 && minExponent > 0) {
            setNumExponent(getNumExponent() - minExponent);
            setDenExponent(getDenExponent() - minExponent);
        }
 
        return *this;
    }
 
    /************************************************************************************************************
     ************************************************ METHODS DEF ***********************************************
     ************************************************************************************************************/
 
    template<typename FloatType>
    template<typename IntType>
    constexpr void ERational<FloatType>::transformToExperimental(const IntType numerator, const IntType denominator) {
        setNumerator(transformOperandToPair(numerator));
        setDenominator(transformOperandToPair(denominator));
    }
 
    template<typename FloatType>
    template<typename IntType>
    constexpr std::pair<FloatType, short> ERational<FloatType>::transformOperandToPair(IntType operand) {
        const int operandLength = Tools::getNumberLength(operand);
        return std::make_pair(
                operand * std::pow(10, -operandLength),
                operandLength
        );
    }
 
    template<typename FloatType>
    constexpr void ERational<FloatType>::verifyDenominator(bool checkIfDenominatorIsNull) {
        if (getDenMultiplier() == 0. && checkIfDenominatorIsNull)
            throw Exceptions::DivideByZeroException();
 
        if (getDenMultiplier() < 0.) {
            setNumMultiplier(-getNumMultiplier());
            setDenMultiplier(-getDenMultiplier());
        }
    }
 
    template<typename FloatType>
    constexpr void ERational<FloatType>::setAtSameNumeratorExponent(
            ERational<FloatType> &firstERational,
            ERational<FloatType> &secondERational
    ) const {
        const int exponentDifference = firstERational.getNumExponent() - secondERational.getNumExponent();
        secondERational.setNumMultiplier(secondERational.getNumMultiplier() / std::pow(10, exponentDifference));
        secondERational.setNumExponent(secondERational.getNumExponent() + exponentDifference);
 
        assert(firstERational.getNumExponent() == secondERational.getNumExponent() &&
               "The two numerator exponents should be equal");
    }
 
    template<typename FloatType>
    constexpr void ERational<FloatType>::setAtSameDenominator(
            ERational <FloatType> &firstERational,
            ERational <FloatType> &secondERational
    ) const {
        firstERational= firstERational * ERational(secondERational.getDenominator(), secondERational.getDenominator());
        secondERational= secondERational * ERational(this->getDenominator(), this->getDenominator());
        assert(firstERational.getDenominator() == secondERational.getDenominator() &&
               "The two denominators should be equal");
    }
 
    /************************************************************************************************************
     ************************************************* STD::COUT ************************************************
     ************************************************************************************************************/
 
    template<typename FloatType>
    std::ostream &operator<<(std::ostream &stream, const ERational<FloatType> &rational) {
        return stream << rational.toString();
    }
 
};