379 lines
11 KiB
C++
379 lines
11 KiB
C++
#include "fraction.hpp"
|
|
|
|
#include <QtMath>
|
|
|
|
namespace FractionNS {
|
|
int gcd(int p, int q) {
|
|
if(p < 0) p = -p;
|
|
if(q < 0) q = -q;
|
|
while(true) {
|
|
if(p == 0) return q;
|
|
q %= p;
|
|
if(q == 0) return p;
|
|
p %= q;
|
|
}
|
|
}
|
|
int lcm(int p, int q) {
|
|
int gcd = FractionNS::gcd(p, q);
|
|
|
|
return gcd == 0 ? 0 : (p / gcd * q);
|
|
}
|
|
|
|
void Fraction::reduce()
|
|
{
|
|
auto gcd = FractionNS::gcd(m_numerator, m_denominator);
|
|
if((gcd == 1 && m_denominator >= 0) || gcd == 0) return;
|
|
|
|
if(gcd == 1 && m_denominator < 0) {
|
|
m_numerator = -m_numerator;
|
|
m_denominator = -m_denominator;
|
|
}
|
|
else if(m_denominator < 0)
|
|
{
|
|
m_numerator = -m_numerator / gcd;
|
|
m_denominator = -m_denominator / gcd;
|
|
} else {
|
|
m_numerator /= gcd;
|
|
m_denominator /= gcd;
|
|
}
|
|
}
|
|
|
|
Fraction::Fraction(int numerator, int denominator)
|
|
{
|
|
if(denominator == 0) throw divide_by_zero_error();
|
|
m_numerator = numerator;
|
|
m_denominator = denominator;
|
|
reduce();
|
|
}
|
|
Fraction::Fraction(const int n) {
|
|
m_numerator = n;
|
|
m_denominator = 1;
|
|
}
|
|
Fraction::Fraction(const Fraction& n) {
|
|
m_numerator = n.getNumerator();
|
|
m_denominator = n.getDenominator();
|
|
}
|
|
|
|
int Fraction::getNumerator() const { return m_numerator; }
|
|
int Fraction::getDenominator() const { return m_denominator; }
|
|
|
|
void Fraction::setNumerator(int numerator) {
|
|
auto gcd = FractionNS::gcd(numerator, m_denominator);
|
|
m_numerator = numerator / gcd;
|
|
}
|
|
void Fraction::setDenominator(int denominator) {
|
|
if(denominator == 0) throw divide_by_zero_error();
|
|
auto gcd = FractionNS::gcd(m_numerator, denominator);
|
|
if(gcd == 0)
|
|
{
|
|
m_denominator = 1;
|
|
}
|
|
else
|
|
{
|
|
m_denominator = denominator / gcd;
|
|
}
|
|
}
|
|
|
|
QString Fraction::display() const {
|
|
return QString::number(m_numerator) + '/' + QString::number(m_denominator);
|
|
}
|
|
Fraction& Fraction::inv() const {
|
|
return *new Fraction(m_denominator, m_numerator);
|
|
}
|
|
|
|
float Fraction::toFloat() const { return float(m_numerator) / m_denominator; }
|
|
double Fraction::toDouble() const { return double(m_numerator) / m_denominator; }
|
|
|
|
Fraction& Fraction::add(const Fraction& other) const {
|
|
return *this + other;
|
|
}
|
|
Fraction& Fraction::add(const int n) const {
|
|
return *this + n;
|
|
}
|
|
Fraction& Fraction::sub(const Fraction& other) const {
|
|
return *this - other;
|
|
}
|
|
Fraction& Fraction::sub(const int n) const {
|
|
return *this - n;
|
|
}
|
|
Fraction& Fraction::mul(const Fraction& other) const {
|
|
return *this * other;
|
|
}
|
|
Fraction& Fraction::mul(const int n) const {
|
|
return *this * n;
|
|
}
|
|
Fraction& Fraction::div(const Fraction& other) const {
|
|
return *this / other;
|
|
}
|
|
Fraction& Fraction::div(const int n) const {
|
|
return *this / n;
|
|
}
|
|
|
|
// Equivalent to ++x and --x, respectively
|
|
Fraction& Fraction::inc() {
|
|
return ++(*this);
|
|
}
|
|
Fraction& Fraction::dec() {
|
|
return --(*this);
|
|
}
|
|
|
|
bool Fraction::operator==(const int n) const {
|
|
return m_denominator == 1
|
|
&& m_numerator == n;
|
|
}
|
|
bool Fraction::operator==(const float n) const {
|
|
return (float(m_numerator) / float(m_denominator)) == n;
|
|
}
|
|
bool Fraction::operator==(const double n) const {
|
|
return (double(m_numerator) / double(m_denominator)) == n;
|
|
}
|
|
bool Fraction::operator==(const Fraction& other) const {
|
|
return (m_numerator == other.getNumerator())
|
|
&& (m_denominator == other.getDenominator());
|
|
}
|
|
|
|
bool Fraction::operator!=(const int n) const {
|
|
return (double(m_numerator) / double(m_denominator)) != n;
|
|
}
|
|
bool Fraction::operator!=(const float n) const {
|
|
return (double(m_numerator) / double(m_denominator)) != n;
|
|
}
|
|
bool Fraction::operator!=(const double n) const {
|
|
return (double(m_numerator) / double(m_denominator)) != n;
|
|
}
|
|
bool Fraction::operator!=(const Fraction& other) const {
|
|
return (m_numerator != other.getNumerator())
|
|
|| (m_denominator != other.getDenominator());
|
|
}
|
|
|
|
bool Fraction::operator<(const int n) const {
|
|
return m_numerator < n * m_denominator;
|
|
}
|
|
bool Fraction::operator<(const float n) const {
|
|
return m_numerator < n * m_denominator;
|
|
}
|
|
bool Fraction::operator<(const double n) const {
|
|
return m_numerator < n * m_denominator;
|
|
}
|
|
bool Fraction::operator<(const Fraction& other) const {
|
|
auto lcm = FractionNS::lcm(m_denominator, other.getDenominator());
|
|
|
|
return (m_numerator * (lcm / m_denominator)) < (other.getNumerator() * (lcm / other.getDenominator()));
|
|
}
|
|
|
|
bool Fraction::operator<=(const int n) const {
|
|
return m_numerator <= n * m_denominator;
|
|
}
|
|
bool Fraction::operator<=(const float n) const {
|
|
return m_numerator <= n * m_denominator;
|
|
}
|
|
bool Fraction::operator<=(const double n) const {
|
|
return m_numerator <= n * m_denominator;
|
|
}
|
|
bool Fraction::operator<=(const Fraction& other) const {
|
|
auto lcm = FractionNS::lcm(m_denominator, other.getDenominator());
|
|
|
|
return (m_numerator * (lcm / m_denominator)) <= (other.getNumerator() * (lcm / other.getDenominator()));
|
|
}
|
|
|
|
bool Fraction::operator>(const int n) const {
|
|
return m_numerator > n * m_denominator;
|
|
}
|
|
bool Fraction::operator>(const float n) const {
|
|
return m_numerator > n * m_denominator;
|
|
}
|
|
bool Fraction::operator>(const double n) const {
|
|
return m_numerator > n * m_denominator;
|
|
}
|
|
bool Fraction::operator>(const Fraction& other) const {
|
|
auto lcm = FractionNS::lcm(m_denominator, other.getDenominator());
|
|
|
|
return (m_numerator * (lcm / m_denominator)) > (other.getNumerator() * (lcm / other.getDenominator()));
|
|
}
|
|
|
|
bool Fraction::operator>=(const int n) const {
|
|
return m_numerator >= n * m_denominator;
|
|
}
|
|
bool Fraction::operator>=(const float n) const {
|
|
return m_numerator >= n * m_denominator;
|
|
}
|
|
bool Fraction::operator>=(const double n) const {
|
|
return m_numerator >= n * m_denominator;
|
|
}
|
|
bool Fraction::operator>=(const Fraction& other) const {
|
|
auto lcm = FractionNS::lcm(m_denominator, other.getDenominator());
|
|
|
|
return (m_numerator * (lcm / m_denominator)) >= (other.getNumerator() * (lcm / other.getDenominator()));
|
|
}
|
|
|
|
Fraction& Fraction::operator+(const int n) const {
|
|
auto newNumerator = m_numerator + (n * m_denominator);
|
|
return *new Fraction(newNumerator, m_denominator);
|
|
}
|
|
Fraction& Fraction::operator+(const Fraction& other) const {
|
|
auto lcm = FractionNS::lcm(m_denominator, other.getDenominator());
|
|
|
|
auto ownNumeratorPart = m_numerator * (lcm / m_denominator);
|
|
auto otherNumeratorPart = other.getNumerator() * (lcm / other.getDenominator());
|
|
|
|
return *new Fraction(ownNumeratorPart + otherNumeratorPart, lcm);
|
|
}
|
|
|
|
Fraction& Fraction::operator+=(const int n) {
|
|
m_numerator += n * m_denominator;
|
|
reduce();
|
|
return *this;
|
|
}
|
|
Fraction& Fraction::operator+=(const Fraction& other) {
|
|
// Sanity check for Clang
|
|
// Not strictly necessary since setting to 0 is checked against in setDenominator and constructor(s).
|
|
if(other.getDenominator() == 0) return *this;
|
|
|
|
auto lcm = FractionNS::lcm(m_denominator, other.getDenominator());
|
|
|
|
auto ownNumeratorPart = m_numerator * (lcm / m_denominator);
|
|
auto otherNumeratorPart = other.getNumerator() * (lcm / other.getDenominator());
|
|
|
|
m_numerator = ownNumeratorPart + otherNumeratorPart;
|
|
m_denominator = lcm;
|
|
|
|
reduce();
|
|
return *this;
|
|
}
|
|
|
|
Fraction& Fraction::operator-(const int n) const {
|
|
auto newNumerator = m_numerator - (n * m_denominator);
|
|
return *new Fraction(newNumerator, m_denominator);
|
|
};
|
|
Fraction& Fraction::operator-(const Fraction& other) const {
|
|
auto lcm = FractionNS::lcm(m_denominator, other.getDenominator());
|
|
|
|
auto ownNumeratorPart = m_numerator * (lcm / m_denominator);
|
|
auto otherNumeratorPart = other.getNumerator() * (lcm / other.getDenominator());
|
|
|
|
return *new Fraction(ownNumeratorPart - otherNumeratorPart, lcm);
|
|
}
|
|
|
|
Fraction& Fraction::operator-=(const int n) {
|
|
m_numerator -= n * m_denominator;
|
|
return *this;
|
|
};
|
|
Fraction& Fraction::operator-=(const Fraction& other) {
|
|
// Sanity check for Clang
|
|
// Not strictly necessary since setting to 0 is checked against in setDenominator and constructor(s).
|
|
if(other.getDenominator() == 0) return *this;
|
|
auto lcm = FractionNS::lcm(m_denominator, other.getDenominator());
|
|
|
|
auto ownNumeratorPart = m_numerator * (lcm / m_denominator);
|
|
auto otherNumeratorPart = other.getNumerator() * (lcm / other.getDenominator());
|
|
|
|
m_numerator = ownNumeratorPart - otherNumeratorPart;
|
|
m_denominator = lcm;
|
|
reduce();
|
|
return *this;
|
|
}
|
|
|
|
Fraction& Fraction::operator*(const int n) const {
|
|
return *new Fraction(m_numerator * n, m_denominator);
|
|
}
|
|
Fraction& Fraction::operator*(const Fraction& other) const {
|
|
return *new Fraction(m_numerator * other.getNumerator(), m_denominator * other.getDenominator());
|
|
}
|
|
|
|
Fraction& Fraction::operator*=(const int n) {
|
|
m_numerator *= n;
|
|
return *this;
|
|
}
|
|
Fraction& Fraction::operator*=(const Fraction& other) {
|
|
m_numerator *= other.getNumerator();
|
|
m_denominator *= other.getDenominator();
|
|
reduce();
|
|
return *this;
|
|
}
|
|
|
|
Fraction& Fraction::operator/(const int n) const {
|
|
return *new Fraction(m_numerator, m_denominator * n);
|
|
}
|
|
Fraction& Fraction::operator/(const Fraction& other) const {
|
|
return *new Fraction(m_numerator * other.getDenominator(), m_denominator * other.getNumerator());
|
|
}
|
|
|
|
Fraction& Fraction::operator/=(const int n) {
|
|
m_denominator *= n;
|
|
reduce();
|
|
return *this;
|
|
}
|
|
Fraction& Fraction::operator/=(const Fraction& other) {
|
|
m_numerator *= other.getDenominator();
|
|
m_denominator *= other.getNumerator();
|
|
reduce();
|
|
return *this;
|
|
}
|
|
|
|
double Fraction::pow(const int n) const {
|
|
if(n == 0) {
|
|
if(m_numerator == 0) {
|
|
throw not_defined_error();
|
|
}
|
|
return 1.0;
|
|
}
|
|
if(n < 0) {
|
|
if(m_numerator == 0) {
|
|
throw not_real_error();
|
|
}
|
|
if(n == -1) {
|
|
return double(m_denominator) / m_numerator;
|
|
}
|
|
|
|
return qPow(double(m_denominator) / m_numerator, -n);
|
|
}
|
|
return qPow(double(m_numerator) / m_denominator, n);
|
|
}
|
|
double Fraction::pow(const Fraction& other) const {
|
|
if(other == 0) {
|
|
if(m_numerator == 0) {
|
|
throw not_defined_error();
|
|
}
|
|
return 1.0;
|
|
}
|
|
if(other < 0) {
|
|
if(m_numerator == 0) {
|
|
throw not_real_error();
|
|
}
|
|
if(other == -1) {
|
|
return double(m_denominator) / m_numerator;
|
|
}
|
|
return qPow(double(m_denominator) / m_numerator, -other.toDouble());
|
|
}
|
|
return qPow(double(m_numerator) / m_denominator, other.toDouble());
|
|
}
|
|
|
|
Fraction& Fraction::operator-() const {
|
|
return *new Fraction(-m_numerator, m_denominator);
|
|
}
|
|
Fraction& Fraction::operator+() const {
|
|
return *new Fraction(m_numerator, m_denominator);
|
|
}
|
|
|
|
// Prefix --
|
|
Fraction& Fraction::operator--() {
|
|
return *new Fraction(*this -= 1);
|
|
}
|
|
// Postfix --
|
|
Fraction& Fraction::operator--(const int) {
|
|
auto result = new Fraction(*this);
|
|
*this -= 1;
|
|
return *result;
|
|
}
|
|
|
|
// Prefix ++
|
|
Fraction& Fraction::operator++() {
|
|
return *new Fraction(*this += 1);
|
|
}
|
|
// Postfix ++
|
|
Fraction& Fraction::operator++(const int) {
|
|
auto result = new Fraction(*this);
|
|
*this += 1;
|
|
return *result;
|
|
}
|
|
}
|