///////    File:  Fraction.const    ///////

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

inline int ABS(int x) { return(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 Cruct 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) const
{    return( ( num * y.denom < denom * y.num ) ); }

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

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

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

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

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

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

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

Fraction Fraction::operator +(const Fraction& y) const
{    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 -() const
{    return( Fraction(-num, denom, 0) );   }

Fraction Fraction::operator -(const Fraction& y) const
{    if ( num == 0 )           // trivial cases
          return(Fraction(-y.num, y.denom, 0));
     else if ( y.num == 0 )
          return(Fraction(num, denom, 0));
     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);
}

void Fraction::read(istream& in /* = cin */)
{   int num, denom;
    char c;
    in >> num >> c;
    if ( c == '/' )
    {    in >> denom;
         *this = Fraction(num, denom);
    }
    else    // clear() sets error state
         in.clear( ios::badbit | in.rdstate() );
}

istream& operator >>(istream& in, Fraction& f)
{    f.read(in);
     return(in);
}

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

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