Fraction.h

/*
 * Copyright (C) 2025, Robert Patterson
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy
 * of this software and associated documentation files (the "Software"), to deal
 * in the Software without restriction, including without limitation the rights
 * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 * copies of the Software, and to permit persons to whom the Software is
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in
 * all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 */
#pragma once
 
#include <iostream>
#include <numeric>
#include <stdexcept>
#include <limits>
 
#include "musx/dom/Fundamentals.h"
 
namespace musx {
namespace util {
 
class [[nodiscard]] Fraction {
private:
    int m_numerator = 0;    
    int m_denominator = 1;  
 
    static constexpr std::pair<int, int> reduce(int num, int den) {
        int gcd = std::gcd(num, den);
        num /= gcd;
        den /= gcd;
 
        // Ensure denominator is always positive
        if (den < 0) {
            num = -num;
            den = -den;
        }
 
        return {num, den};
    }
 
    constexpr static Fraction fromConstExpr(int num, int den)
    {
        auto [n, d] = reduce(num, den);
        auto result = Fraction(n);
        result.m_denominator = d;
        return result;
    }
 
    friend class std::numeric_limits<Fraction>;
 
public:
    constexpr Fraction() = default;
 
    Fraction(int num, int den)
    {
        if (den == 0) {
            throw std::invalid_argument("Denominator cannot be zero.");
        }
 
        auto [n, d] = reduce(num, den);
        m_numerator = n;
        m_denominator = d;
    }
 
    constexpr Fraction(int value) : m_numerator(value), m_denominator(1) {}
 
    static constexpr Fraction fromEdu(dom::Edu edu) { return fromConstExpr(edu, EDU_PER_WHOLE_NOTE); }
 
    static constexpr Fraction fromPercent(int percent) { return fromConstExpr(percent, 100); }
 
    constexpr int numerator() const { return m_numerator; }
 
    constexpr int denominator() const { return m_denominator; }
 
    constexpr int quotient() const {
        return m_numerator / m_denominator;
    }
 
    Fraction constexpr remainder() const {
        return fromConstExpr(m_numerator % m_denominator, m_denominator);
    }
 
    Fraction reciprocal() const {
        return Fraction(m_denominator, m_numerator);
    }
 
    constexpr dom::Edu calcEduDuration() const
    {
        using Edu = dom::Edu;
        using Wide = std::int64_t;
 
        // Do the scaling in wide integer to avoid overflow.
        const auto num = Wide(m_numerator) * Wide(EDU_PER_WHOLE_NOTE);
        const auto den = Wide(m_denominator); // always > 0 by class invariant
 
        // Round to nearest, 0.5 away from zero, without using double.
        auto rounded = Wide{};
        if (num >= 0) {
            rounded = (num + den / 2) / den;
        } else {
            rounded = (num - den / 2) / den;
        }
 
        // Saturate to dom::Edu range.
        constexpr auto maxEdu = static_cast<Wide>((std::numeric_limits<Edu>::max)());
        constexpr auto minEdu = static_cast<Wide>((std::numeric_limits<Edu>::min)());
 
        if (rounded > maxEdu) {
            rounded = maxEdu;
        } else if (rounded < minEdu) {
            rounded = minEdu;
        }
 
        return Edu(static_cast<int>(rounded));
    }
 
    constexpr Fraction abs() const
    {
        if (numerator() < 0)
            return fromConstExpr(-numerator(), denominator());
        return *this;
    }
 
    constexpr double toDouble() const {
        return double(m_numerator) / double(m_denominator);
    }
 
    Fraction constexpr operator+(const Fraction& other) const {
        return fromConstExpr(
            m_numerator * other.m_denominator + other.m_numerator * m_denominator,
            m_denominator * other.m_denominator
        );
    }
 
    Fraction constexpr operator-(const Fraction& other) const {
        return fromConstExpr(
            m_numerator * other.m_denominator - other.m_numerator * m_denominator,
            m_denominator * other.m_denominator
        );
    }
 
    Fraction constexpr operator*(const Fraction& other) const {
        return fromConstExpr(
            m_numerator * other.m_numerator,
            m_denominator * other.m_denominator
        );
    }
 
    Fraction operator/(const Fraction& other) const {
        return Fraction(
            m_numerator * other.m_denominator,
            m_denominator * other.m_numerator
        );
    }
 
    constexpr Fraction& operator+=(const Fraction& other) {
        *this = *this + other;
        return *this;
    }
 
    constexpr Fraction& operator-=(const Fraction& other) {
        *this = *this - other;
        return *this;
    }
 
    constexpr Fraction& operator*=(const Fraction& other) {
        *this = *this * other;
        return *this;
    }
 
    Fraction& operator/=(const Fraction& other) {
        *this = *this / other;
        return *this;
    }
 
    constexpr bool operator==(const Fraction& other) const {
        return m_numerator == other.m_numerator && m_denominator == other.m_denominator;
    }
 
    constexpr bool operator!=(const Fraction& other) const {
        return !(*this == other);
    }
 
    constexpr bool operator<(const Fraction& other) const {
        double lhs = static_cast<double>(m_numerator) / m_denominator;
        double rhs = static_cast<double>(other.m_numerator) / other.m_denominator;
        return lhs < rhs;
    }
 
    constexpr bool operator<=(const Fraction& other) const {
        return *this < other || *this == other;
    }
 
    constexpr bool operator>(const Fraction& other) const {
        return !(*this <= other);
    }
 
    constexpr bool operator>=(const Fraction& other) const {
        return !(*this < other);
    }
 
    constexpr explicit operator bool() const noexcept {
        return m_numerator != 0;
    }
 
    friend std::ostream& operator<<(std::ostream& os, const Fraction& frac) {
        os << frac.m_numerator;
        if (frac.m_denominator != 1) {
            os << "/" << frac.m_denominator;
        }
        return os;
    }
 
    friend std::istream& operator>>(std::istream& is, Fraction& frac) {
        int num, den;
        char sep;
        is >> num >> sep >> den;
        if (sep != '/' || den == 0) {
            throw std::invalid_argument("Invalid fraction format or zero m_denominator.");
        }
        frac = Fraction(num, den);
        return is;
    }
};
 
constexpr Fraction abs(const Fraction& v) noexcept
{
    return v.abs();
}
 
} // namespace util
} // namespace musx
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
#include <limits>
 
namespace std {
template <>
class numeric_limits<musx::util::Fraction> {
public:
    static constexpr bool is_specialized = true;
 
    // Smallest positive normalized value (not necessarily lowest)
    static constexpr musx::util::Fraction min() noexcept {
        return musx::util::Fraction::fromConstExpr(1, std::numeric_limits<int>::max());
    }
 
    // Largest representable positive fraction
    static constexpr musx::util::Fraction max() noexcept {
        return musx::util::Fraction(std::numeric_limits<int>::max());
    }
 
    // Most negative representable fraction
    static constexpr musx::util::Fraction lowest() noexcept {
        return musx::util::Fraction(std::numeric_limits<int>::lowest());
    }
 
    static constexpr int digits    = std::numeric_limits<int>::digits;
    static constexpr int digits10  = std::numeric_limits<int>::digits10;
 
    static constexpr bool is_signed      = true;
    static constexpr bool is_integer     = false;
    static constexpr bool is_exact       = true;
    static constexpr bool has_infinity   = false;
    static constexpr bool has_quiet_NaN  = false;
    static constexpr bool has_signaling_NaN = false;
 
    static constexpr musx::util::Fraction epsilon() noexcept {
        return musx::util::Fraction::fromConstExpr(1, std::numeric_limits<int>::max());
    }
 
    static constexpr musx::util::Fraction round_error() noexcept {
        return musx::util::Fraction(0);
    }
 
    static constexpr int radix = 2;
 
    static constexpr musx::util::Fraction infinity() noexcept { return musx::util::Fraction(0); }
    static musx::util::Fraction quiet_NaN() noexcept { return musx::util::Fraction(0); }
    static musx::util::Fraction signaling_NaN() noexcept { return musx::util::Fraction(0); }
 
    static constexpr bool is_iec559       = false;
    static constexpr bool is_bounded      = true;
    static constexpr bool is_modulo       = false;
    static constexpr bool traps           = true;  // Because invalid construction throws
    static constexpr bool tinyness_before = false;
    static constexpr float_round_style round_style = round_indeterminate;
};
 
template <>
struct hash<musx::util::Fraction>
{
    size_t operator()(const musx::util::Fraction& frac) const noexcept
    {
        // boost algorithm tailored to Fraction
        size_t seed = std::hash<int>{}(frac.numerator());
        seed ^= std::hash<int>{}(frac.denominator()) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
        return seed;
    }
};
 
} // namespace std
#endif // DOXYGEN_SHOULD_IGNORE_THIS