rational.h

Go to the documentation of this file.

 
#pragma once
 
#include <numeric>
#include <algorithm>
#include <promeki/core/namespace.h>
#include <promeki/core/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);
                }
 
                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