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 "musx/dom/Fundamentals.h"
 
namespace musx {
namespace util {
 
class Fraction {
private:
    int m_numerator; 
    int m_denominator; 
 
    void reduce() {
        int gcd = std::gcd(m_numerator, m_denominator);
        m_numerator /= gcd;
        m_denominator /= gcd;
 
        // Ensure the m_denominator is always positive
        if (m_denominator < 0) {
            m_numerator = -m_numerator;
            m_denominator = -m_denominator;
        }
    }
 
public:
    Fraction(int num = 0, int den = 1) : m_numerator(num), m_denominator(den) {
        if (m_denominator == 0) {
            throw std::invalid_argument("Denominator cannot be zero.");
        }
        reduce();
    }
 
    static Fraction fromEdu(int edu);
 
    int numerator() const { return m_numerator; }
 
    int denominator() const { return m_denominator; }
 
    int quotient() const {
        return m_numerator / m_denominator;
    }
 
    Fraction remainder() const {
        return Fraction(m_numerator % m_denominator, m_denominator);
    }
 
    Fraction reciprocal() const {
        return Fraction(m_denominator, m_numerator);
    }
 
    dom::Edu calcEduDuration() const;
 
    Fraction operator+(const Fraction& other) const {
        return Fraction(
            m_numerator * other.m_denominator + other.m_numerator * m_denominator,
            m_denominator * other.m_denominator
        );
    }
 
    Fraction operator-(const Fraction& other) const {
        return Fraction(
            m_numerator * other.m_denominator - other.m_numerator * m_denominator,
            m_denominator * other.m_denominator
        );
    }
 
    Fraction operator*(const Fraction& other) const {
        return Fraction(
            m_numerator * other.m_numerator,
            m_denominator * other.m_denominator
        );
    }
 
    Fraction operator/(const Fraction& other) const {
        if (other.m_numerator == 0) {
            throw std::invalid_argument("Cannot divide by zero fraction.");
        }
        return Fraction(
            m_numerator * other.m_denominator,
            m_denominator * other.m_numerator
        );
    }
 
    Fraction& operator+=(const Fraction& other) {
        *this = *this + other;
        return *this;
    }
 
    Fraction& operator-=(const Fraction& other) {
        *this = *this - other;
        return *this;
    }
 
    Fraction& operator*=(const Fraction& other) {
        *this = *this * other;
        return *this;
    }
 
    Fraction& operator/=(const Fraction& other) {
        *this = *this / other;
        return *this;
    }
 
    bool operator==(const Fraction& other) const {
        return m_numerator == other.m_numerator && m_denominator == other.m_denominator;
    }
 
    bool operator!=(const Fraction& other) const {
        return !(*this == other);
    }
 
    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;
    }
 
    bool operator<=(const Fraction& other) const {
        return *this < other || *this == other;
    }
 
    bool operator>(const Fraction& other) const {
        return !(*this <= other);
    }
 
    bool operator>=(const Fraction& other) const {
        return !(*this < other);
    }
 
    explicit operator bool() const {
        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;
    }
};
 
} // namespace util
} // namespace musx
 
#ifndef DOXYGEN_SHOULD_IGNORE_THIS
// automatic hash function for Fraction
namespace std {
    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;
        }
    };
}
#endif // DOXYGEN_SHOULD_IGNORE_THIS