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

#include "Rational.h"

// Constructor
Rational::Rational(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 Rational::setNumerator(int n)
{ numerator=n;
}

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

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

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

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

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

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

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

Rational slashOp(const Rational &left,const Rational &right) 
{  Rational 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;
}

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

void Rational::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;
   }
}