// rational-overload.cc
// member function definitions for
// RationalNumber class
// Problem 8.17 in D&D
#include <stdlib.h>
#include "rational-overload.h"

// default constructor default values 0 and 1
RationalNumber::RationalNumber(int num, int denom)
{
  numerator = num;
  denominator = (denom > 0) ? denom : 1;
  reduction();
}

// overload operators for "normal" operation
RationalNumber 
 RationalNumber::operator+(const RationalNumber &a)
{
  RationalNumber sum;

  sum.numerator = numerator * a.denominator +
                  denominator * a.numerator;
  sum.denominator = denominator * a.denominator;
  sum.reduction();
  return sum;
}

RationalNumber 
 RationalNumber::operator-(const RationalNumber &a)
{
  RationalNumber sub;

  sub.numerator = numerator * a.denominator -
                  denominator * a.numerator;
  sub.denominator = denominator * a.denominator;
  sub.reduction();
  return sub;
}

RationalNumber 
 RationalNumber::operator*(const RationalNumber &m)
{
  RationalNumber multiply;

  multiply.numerator = numerator * m.numerator;
  multiply.denominator = denominator * m.denominator;
  multiply.reduction();
  return multiply;
}

RationalNumber 
 RationalNumber::operator/(const RationalNumber &d)
{
RationalNumber divide;
if (d.numerator != 0)
  {
    divide.numerator = numerator * d.denominator;
    divide.denominator = denominator * d.numerator;
    divide.reduction();
  }
else
  {
    cout << "Divide by zero error: terminating program" << endl;
    exit(1);
  }
return divide;
}

// overload relational operators for "normal" operation
int RationalNumber::operator>(const RationalNumber &gr) const
{
  if ((float)numerator / denominator > 
      (float)gr.numerator / gr.denominator)
    return 1;
  else
    return 0;
}

int RationalNumber::operator<(const RationalNumber &lr) const
{
  if ((float)numerator / denominator <
      (float)lr.numerator / lr.denominator)
    return 1;
  else
    return 0;
}

// can use previous definitions in following
int 
 RationalNumber::operator>=(const RationalNumber &ger) const
{
  return *this == ger || *this > ger;
}

int 
 RationalNumber::operator<=(const RationalNumber &ler) const
{
  return *this == ler || *this < ler;
}

int 
 RationalNumber::operator==(const RationalNumber &er) const
{
  if (numerator == er.numerator &&
      denominator == er.denominator)
    return 1;
  else
    return 0;
}

int 
 RationalNumber::operator!=(const RationalNumber &ner) const
{
  return !(*this == ner);
}

void RationalNumber::reduction(void)
{
  int largest, gcd = 1;
  largest = (numerator > denominator) ? numerator : denominator;
  
  for (int loop = 2; loop <= largest; loop++)
    if (numerator % loop == 0 && denominator % loop == 0)
      gcd = loop;

  numerator /= gcd;
  denominator /= gcd;
}

ostream & 
  operator<<(ostream &output, const RationalNumber &rnum)
{
  output << rnum.numerator << "/" << rnum.denominator;
  return output;
}

istream&
  operator>>(istream &input, RationalNumber &rnum)
{
  input >> rnum.numerator;
  input.ignore(1);
  input >> rnum.denominator;
  return input;
}