// File: RationalOverload.cpp
// Simple Operator Overload Example

#include "RationalOverloads.h"

// Constructor
RationalOvld::RationalOvld(int n, int d) 
{  numerator = d < 0 ? -n : n;            // if <0, numerator negative
   denominator = d < 0 ? -d : d;          // denominator is always positive
   reduce();                              // lowest terms
}

void RationalOvld::setNumerator(int n)
{ numerator=n;
}

void RationalOvld::setDenominator(int d)
{ denominator=d;
}   

int RationalOvld::getNumerator() const
{ return(numerator);
}

int RationalOvld::getDenominator() const
{ return(denominator);
}

bool RationalOvld::operator>(const RationalOvld &right) const 
{  return (float)numerator/denominator > (float)right.numerator/right.denominator ;
}

bool RationalOvld::operator<(const RationalOvld &right) const 
{  return (float)numerator/denominator < (float)right.numerator/right.denominator ;
}

bool RationalOvld::operator>=(const RationalOvld &right) const {
   return *this == right || *this > right;
}

bool RationalOvld::operator<=(const RationalOvld &right) const {
   return *this == right || *this < right;
}

bool RationalOvld::operator==(const RationalOvld &right) const {
   return (numerator == right.numerator && denominator == right.denominator);
}

bool RationalOvld::operator!=(const RationalOvld &right) const {
   return !(*this == right);
}

// operator+=  
// overloaded +=: current object = current object + parameter 
// Result is reduced to lowest terms.
RationalOvld& RationalOvld::operator+=(const RationalOvld &right) 
{  numerator = right.getNumerator() * getDenominator()
				+ right.getDenominator() * getNumerator();
   denominator = right.denominator * denominator;
   reduce();
   return *this;
}

RationalOvld operator+(const RationalOvld &left,const RationalOvld &right) 
{  RationalOvld sum;
   sum.setNumerator(right.getNumerator() * left.getDenominator() + 
				right.getDenominator() * left.getNumerator());
   sum.setDenominator(right.getDenominator() * left.getDenominator());
   sum.reduce();
   return sum;
}

RationalOvld operator-(const RationalOvld &left,const RationalOvld &right) 
{  RationalOvld sub;
   sub.setNumerator(right.getDenominator() * left.getNumerator() - 
				left.getDenominator() * right.getNumerator());
   sub.setDenominator(left.getDenominator() * right.getDenominator());
   sub.reduce();
   return sub;
}

RationalOvld operator*(const RationalOvld &left,const RationalOvld &right) 
{  RationalOvld mult;
   mult.setNumerator(left.getNumerator() * right.getNumerator());
   mult.setDenominator(left.getDenominator() * right.getDenominator());
   mult.reduce();
   return mult;
}

RationalOvld operator/(const RationalOvld &left,const RationalOvld &right) 
{  RationalOvld div;
   if (right.getNumerator() != 0) {              // make sure new denominator != zero
      div.setNumerator(right.getDenominator() * left.getNumerator());
      div.setDenominator(left.getDenominator() * right.getNumerator());
      div.reduce();
      return(div);
   }
   return 0;
}

//----------------------------------------------------------------------------
// operator<< 
// overloaded <<: prints "DIVIDE BY ZERO ERROR!!!" if denominator is zero,
//    prints whole numbers without denominator (as ints), otherwise uses '/'
ostream& operator<<(ostream &output, const RationalOvld &right) {
   if (right.getDenominator() == 0)
      output << endl << "DIVIDE BY ZERO ERROR!!!" << endl;
   else if (right.getNumerator() == 0)                              // zero rational
      output << 0;
   else if (right.getDenominator() == 1)                            // whole number
      output << right.getNumerator();
   else
      output << right.getNumerator() << "/" << right.getDenominator();
   
   return output;
}

int gcd(int x, int y)
  { if (!y) {
      return(x);
  }
  return(gcd(y,x%y));
}

void RationalOvld::reduce() {
   int n = numerator < 0 ? -numerator : numerator;  // make numerator positive

   // Euclidean gcd algorithm
   int greatestCommon=gcd(n,denominator);
   if (gcd != 0) {
      numerator /= greatestCommon;
      denominator /= greatestCommon;
   }
}