///////    File:  Fraction.C    ///////

#include <stdlib.h>
#include "Fraction.h"

inline int ABS(int x)
       { return(x < 0 ? -x : x); } 

int gcd(int a, int b)
{       a = ABS(a);
        b = ABS(b);
        if ( a == 0 ) return(b);    // 0 is error value
        if ( b == 0 ) return(a);
	int t;
        while ( b > 0 )
        {   t = a % b;
            a = b;
            b = t;
        }
        return (a);
}

Fraction::Fraction(int n, int d, int reduce /* = 1 */)   // d is not zero
{ int g;
      if ( d == 0 )
      {   cerr << " Fraction: Can't construct fraction with 0 denominator\n";
          exit(1);
      }
      if (n == 0) 
      {   num = 0;
          denom = 1;
          return;
      }
      if (d < 0) 
      {    n = -n;
           d = -d;
      }
      if ( reduce && (g = gcd(n,d)) != 1 )      // remove gcd
      {    n /= g;
           d /= g;
      }
      num = n;
      denom = d;
}

int Fraction::operator<(const Fraction& y)
{    return( ( num * y.denom < denom * y.num ) ); }

int Fraction::operator>(const Fraction& y)
{    return( ( num * y.denom > denom * y.num ) ); }

int Fraction::operator>=(const Fraction& y)
{    return( ( num * y.denom >= denom * y.num ) ); }

int Fraction::operator<=(const Fraction& y)
{    return( ( num * y.denom <= denom * y.num ) ); }

int Fraction::floor()
{   if ( num >= 0 ) return( num % denom );
    else return(-1 - (-num % denom));
}

int Fraction::ceiling()
{   if ( num >= 0 ) return(1 + (num % denom));
    else return ( 1 - (-num % denom) );
}

Fraction Fraction::operator/(const Fraction& y)
{    return( Fraction( num * y.denom, denom * y.num ) ); }

Fraction Fraction::operator*(const Fraction& y)
{    return( Fraction( num * y.num, denom * y.denom ) ); }

Fraction Fraction::operator+(const Fraction& y)
{    if ( num == 0 )
         return(Fraction(y.num, y.denom, 0));
     else if ( y.num == 0 )
         return(Fraction(num, denom, 0));
     else
         return( Fraction( num * y.denom + y.num * denom,
                            denom * y.denom ) );
}

Fraction Fraction::operator-()
{    return( Fraction(-num, denom, 0) );   }

Fraction Fraction::operator-(const Fraction& y)
{    if ( num == 0 )           // trivial cases
          return(Fraction(-y.num, y.denom, 0));
     else if ( y.num == 0 )
          return(*this);
     else                      // sub fractions
          return( Fraction( num * y.denom - y.num * denom,
                            denom * y.denom ) );
}