rational.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_CORE
#include <algorithm>
#include <cmath>
#include <limits>
#include <numeric>
#include <promeki/namespace.h>
#include <promeki/result.h>
#include <promeki/string.h>
 
PROMEKI_NAMESPACE_BEGIN
 
template <typename T = int> class Rational {
        public:
                Rational(T n = 0, T d = 1) : _num(n), _den(d) {
                        if (_den != 0) simplify();
                }
 
                bool isValid() const { return _den != 0; }
 
                Rational operator+(const Rational &rhs) const {
                        if (!isValid() || !rhs.isValid()) return Rational(0, 0);
                        T lcm = std::lcm(_den, rhs._den);
                        T num = _num * (lcm / _den) + rhs._num * (lcm / rhs._den);
                        return Rational(num, lcm);
                }
 
                Rational operator-(const Rational &rhs) const {
                        if (!isValid() || !rhs.isValid()) return Rational(0, 0);
                        T lcm = std::lcm(_den, rhs._den);
                        T num = _num * (lcm / _den) - rhs._num * (lcm / rhs._den);
                        return Rational(num, lcm);
                }
 
                Rational operator*(const Rational &rhs) const {
                        if (!isValid() || !rhs.isValid()) return Rational(0, 0);
                        T num = _num * rhs._num;
                        T den = _den * rhs._den;
                        return Rational(num, den);
                }
 
                Rational operator/(const Rational &rhs) const {
                        if (!isValid() || !rhs.isValid() || rhs._num == 0) return Rational(0, 0);
                        T num = _num * rhs._den;
                        T den = _den * rhs._num;
                        return Rational(num, den);
                }
 
                bool operator==(const Rational &rhs) const { return _num == rhs._num && _den == rhs._den; }
 
                bool operator!=(const Rational &rhs) const { return !(*this == rhs); }
 
                T numerator() const { return _num; }
 
                T denominator() const { return _den; }
 
                double toDouble() const {
                        if (!isValid()) return 0.0;
                        return static_cast<double>(_num) / static_cast<double>(_den);
                }
 
                static Result<Rational<T>> fromDouble(double val) {
                        if (!std::isfinite(val)) return makeError<Rational<T>>(Error::ParseFailed);
                        double rounded = std::nearbyint(val);
                        if (rounded != val) return makeError<Rational<T>>(Error::ParseFailed);
                        if (rounded < static_cast<double>(std::numeric_limits<T>::lowest()) ||
                            rounded > static_cast<double>(std::numeric_limits<T>::max())) {
                                return makeError<Rational<T>>(Error::OutOfRange);
                        }
                        return makeResult(Rational<T>(static_cast<T>(rounded), T(1)));
                }
 
                String toString() const { return String::dec(_num) + "/" + String::dec(_den); }
 
                operator String() const { return toString(); }
 
        private:
                T _num;
                T _den;
 
                void simplify() {
                        T gcd = std::gcd(_num, _den);
                        _num /= gcd;
                        _den /= gcd;
                        return;
                }
};
 
PROMEKI_NAMESPACE_END
 
template <typename T> struct std::formatter<promeki::Rational<T>> : promeki::ToStringFormatter<promeki::Rational<T>> {};
 
#endif // PROMEKI_ENABLE_CORE