Program Listing for File fractions-new.hpp

↰ Return to documentation for file (py2cpp/fractions-new.hpp)

// The template and inlines for the -*- C++ -*- fraction classes.
// Initially implemented by Wai-Shing Luk <luk036@gmail.com>
//

#pragma once

#include <cmath>
#include <numeric>
#include <type_traits>

namespace fun
{

template <typename _Mn>
constexpr _Mn gcd(_Mn __m, _Mn __n)
{
    return __m == 0 ? abs(__n) : __n == 0 ? abs(__m) : gcd(__n, __m % __n);
}

template <typename _Mn>
constexpr _Mn lcm(_Mn __m, _Mn __n)
{
    return (__m != 0 and __n != 0) ? (abs(__m) / gcd(__m, __n)) * abs(__n) : 0;
}

template <typename Z>
struct Fraction
{
    using _Self = Fraction<Z>;

    Z _numerator;
    Z _denominator;

    constexpr Fraction(const Z& numerator, const Z& denominator)
    {
        const Z& common = gcd(numerator, denominator);
        _numerator = (common == Z(0)) ? Z(0) : numerator / common;
        _denominator = (common == Z(0)) ? Z(0) : denominator / common;
    }

    constexpr explicit Fraction(const Z& numerator)
        : _numerator {numerator}
        , _denominator {1}
    {
    }

    constexpr Fraction() = default;
    // Fraction(const _Self &) = delete;
    // Fraction(_Self &&) = default;

    constexpr const Z& numerator() const
    {
        return _numerator;
    }

    constexpr const Z& denominator() const
    {
        return _denominator;
    }

    constexpr _Self abs() const
    {
        return _Self(std::abs(_numerator), std::abs(_denominator));
    }

    constexpr void reciprocal()
    {
        std::swap(_numerator, _denominator);
    }

    constexpr _Self operator-() const
    {
        return _Self(-_numerator, _denominator);
    }

    constexpr _Self operator+(const _Self& frac) const
    {
        if (_denominator == frac._denominator)
        {
            return _Self(_numerator + frac._numerator, _denominator);
        }

        const auto common = lcm(_denominator, frac._denominator);
        const auto n = common / _denominator * _numerator +
            common / frac._denominator * frac._numerator;
        return _Self(n, common);
    }

    constexpr _Self operator-(const _Self& frac) const
    {
        return *this + (-frac);
    }

    constexpr _Self operator*(const _Self& frac) const
    {
        const auto n = _numerator * frac._numerator;
        const auto d = _denominator * frac._denominator;
        return _Self(n, d);
    }

    constexpr _Self operator/(_Self frac) const
    {
        frac.reciprocal();
        return *this * frac;
    }

    constexpr _Self operator+(const Z& i) const
    {
        const auto n = _numerator + _denominator * i;
        return _Self(n, _denominator);
    }

    constexpr _Self operator-(const Z& i) const
    {
        return *this + (-i);
    }

    constexpr _Self operator*(const Z& i) const
    {
        const auto n = _numerator * i;
        return _Self(n, _denominator);
    }

    constexpr _Self operator/(const Z& i) const
    {
        const auto d = _denominator * i;
        return _Self(_numerator, d);
    }

    constexpr _Self operator+=(const _Self& frac)
    {
        return *this = *this + frac;
    }

    constexpr _Self operator-=(const _Self& frac)
    {
        return *this = *this - frac;
    }

    constexpr _Self operator*=(const _Self& frac)
    {
        return *this = *this * frac;
    }

    constexpr _Self operator/=(const _Self& frac)
    {
        return *this = *this / frac;
    }

    constexpr _Self operator+=(const Z& i)
    {
        return *this = *this + i;
    }

    constexpr _Self operator-=(const Z& i)
    {
        return *this = *this - i;
    }

    constexpr _Self operator*=(const Z& i)
    {
        return *this = *this * i;
    }

    constexpr _Self operator/=(const Z& i)
    {
        return *this = *this / i;
    }

    template <typename U>
    constexpr auto cmp(const Fraction<U>& frac) const
    {
        // if (_denominator == frac._denominator) {
        //     return _numerator - frac._numerator;
        // }
        return _numerator * frac._denominator - _denominator * frac._numerator;
    }

    template <typename U>
    constexpr bool operator==(const Fraction<U>& frac) const
    {
        if (_denominator == frac._denominator)
        {
            return _numerator == frac._numerator;
        }
        return this->cmp(frac) == 0;
    }

    template <typename U>
    constexpr bool operator!=(const Fraction<U>& frac) const
    {
        return !(*this == frac);
    }

    template <typename U>
    constexpr bool operator<(const Fraction<U>& frac) const
    {
        if (_denominator == frac._denominator)
        {
            return _numerator < frac._numerator;
        }
        return this->cmp(frac) < 0;
    }

    template <typename U>
    constexpr bool operator>(const Fraction<U>& frac) const
    {
        return frac < *this;
    }

    template <typename U>
    constexpr bool operator<=(const Fraction<U>& frac) const
    {
        return !(frac < *this);
    }

    template <typename U>
    constexpr bool operator>=(const Fraction<U>& frac) const
    {
        return !(*this < frac);
    }

    constexpr auto cmp(const Z& c) const
    {
        return _numerator - _denominator * c;
    }

    constexpr bool operator==(const Z& c) const
    {
        return this->cmp(c) == 0;
    }

    constexpr bool operator!=(const Z& c) const
    {
        return this->cmp(c) != 0;
    }

    constexpr bool operator<(const Z& c) const
    {
        return this->cmp(c) < 0;
    }

    constexpr bool operator>(const Z& c) const
    {
        return this->cmp(c) > 0;
    }

    constexpr bool operator<=(const Z& c) const
    {
        return this->cmp(c) <= 0;
    }

    constexpr bool operator>=(const Z& c) const
    {
        return this->cmp(c) >= 0;
    }

    constexpr explicit operator double()
    {
        return double(_numerator) / _denominator;
    }

    friend constexpr _Self operator+(const Z& c, const _Self& frac)
    {
        return frac + c;
    }

    friend constexpr _Self operator-(const Z& c, const _Self& frac)
    {
        return (-frac) + c;
    }

    friend constexpr _Self operator*(const Z& c, const _Self& frac)
    {
        return frac * c;
    }

    friend constexpr _Self operator+(int&& c, const _Self& frac)
    {
        return frac + c;
    }

    friend constexpr _Self operator-(int&& c, const _Self& frac)
    {
        return (-frac) + c;
    }

    friend constexpr _Self operator*(int&& c, const _Self& frac)
    {
        return frac * c;
    }

    template <typename _Stream>
    friend _Stream& operator<<(_Stream& os, const _Self& frac)
    {
        os << frac.numerator() << "/" << frac.denominator();
        return os;
    }
};


// For template deduction
// typename{Z} Fraction(const Z &, const Z &)->Fraction<Z>;

} // namespace fun