// A2X - C++ Course 1998
// Copyright © 1998 by Thomas Papanikolaou - All rights reserved.

// include the header for the class rational
#include "rational.h"

// constructors and desctructor 
rational::rational ( )
{
  n = 0;
  d = 1;
}

rational::rational ( int i )
{
  n = i;
  d = 1;
}

rational::rational ( int i , int j )
{
  // here we have to simplify
  n = i;
  d = j;
  simplify(); 
}

rational::rational ( const rational & x )
{
  // here we don't
  n = x.n;
  d = x.d;
}

rational::~rational ( )
{
  // yes, it is empty
}

// overloading of the assignment operator =
rational & rational::operator = ( const rational & x )
{
  n = x.n;
  d = x.d;

  // return a reference to THIS object so that we
  // can write x = y = z = ...
  return *this;
}

// overloading of the unary operator -
rational operator - ( const rational & x )
{
  rational res(x);
  res.n = -res.n;
  return res;
}

// overloadings of the binary operators +, -, *, /
rational operator + ( const rational & x , const rational & y )
{
  return rational(x.n * y.d + x.d * y.n, x.d * y.d);
}

rational operator - ( const rational & x , const rational & y )
{
  return rational(x.n * y.d - x.d * y.n, x.d * y.d);
}

rational operator * ( const rational & x , const rational & y )
{
  return rational(x.n * y.n, x.d * y.d);
}

rational operator / ( const rational & x , const rational & y )
{
  return rational(x.n * y.d, x.d * y.n);
}

bool operator == ( const rational & x , const rational & y )
{
  return (x.n * y.d == x.d * y.n);
}

bool operator < ( const rational & x , const rational & y )
{
  if (x.d * y.d > 0)
    return (x.n * y.d < x.d * y.n);
  else
    return (x.n * y.d < x.d * y.n);
}

bool operator > ( const rational & x , const rational & y )
{
  if (x.d * y.d < 0)
    return (x.n * y.d < x.d * y.n);
  else
    return (x.n * y.d < x.d * y.n);
}


// overloading of the input operator
istream & operator >> ( istream & in , rational & x )
{
  char ch;

  // read the numerator
  in >> x.n;

  // if the next character is a '/' read a denominator
  // otherwise set the denominator to 1
  do { in.get(ch); } while (ch == ' ');
  if (ch == '/')
    in >> x.d;
  else
    {
      in.putback(ch);
      x.d = 1;
    }
  
  x.simplify();

  return in; 
}

// overloading of the output operator
ostream & operator << ( ostream & out , const rational & x )
{
  if (x.d == 1)
    out << x.n;
  else
    out << x.n << "/" << x.d;
  return out;
}