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

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

#define ABS(x)  ((x) < 0 ? -(x) : (x)) 

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

/*
int Fraction::operator[](unsigned int i)  // must be member
{   if ( i == 1 ) return num;
    else return(denom);
}
*/
    

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 ) );
}

/*ostream& operator<<(ostream& out, Fraction& x)
{   out << x[1] << "/" << x[2];
    return(out);
}

istream& operator>>(istream& in, Fraction& x)
{   int num, denom = 1;
    char c;
    in >> num;
    in >> c;
    if ( c == '/' ) in >> denom;
    else    // set error state
    {    in.clear( ios::badbit | in.rdstate() );
         return(in);
    }
    x = Fraction(num, denom);
    return(in);
}

Fraction operator+(Fraction& f, int i)
{   return (Fraction(i*f.denom+f.num, f.denom));   }

Fraction operator+(int i, Fraction& f)
{   return (Fraction(i*f.denom+f.num, f.denom));   }
*/