///////   file Fraction.java   ///////

// fraction constructor throws exception here

public class Fraction
{  
    public Fraction() { }  // default constructor
    public String toString()   // override
    {   return(num + "/" + denom); 
    }

    public boolean equals(Fraction y)  // fraction equality
    {    return( num == y.num && denom == y.denom );
    }

// The following equals method explained in chapter 4

    public boolean equals(Object y)   // override
    {   return ( y == this ||
                 (this.getClass() == y.getClass()
                  && num == ((Fraction)y).num
                  && denom == ((Fraction)y).denom )
               );
    }

    public boolean is_zero() { return(denom == 1 && num == 0); }
    public boolean is_one()  { return(denom == 1 && num == 1); }
    public boolean is_int()  { return(denom == 1); }


    public static int gcd(int a, int b)
    {       a = Math.abs(a);
            b = Math.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);
    }
// constructor, d is not zero
   public Fraction(int n, int d)
          throws ZeroDenominatorException
   {      if ( d == 0 )
          {   throw( new ZeroDenominatorException(
                "Fraction: fraction with 0 denominator?"));
          }
          init(n,d);
   }

   private void init(int n, int d)
   {      int g;
          if (n == 0) 
          {   num = 0;
              denom = 1;
              return;
          }
          if (d < 0) 
          {    n = -n;
               d = -d;
          }
          if ( (g = gcd(n,d)) != 1 )      // remove gcd
          {    n /= g;
               d /= g;
          }
          num = n;
          denom = d;
    }

    public Fraction(Fraction f)   // make a copy
    {  num=f.num; denom=f.denom; }


    public boolean less(Fraction y)
    {    return( ( num * y.denom < denom * y.num ) ); }

    public boolean greater(Fraction y)
    {    return( ( num * y.denom > denom * y.num ) ); }

    public boolean greater_eq(Fraction y)
    {    return( ( num * y.denom >= denom * y.num ) ); }

    public boolean less_eq(Fraction y)
    {    return( ( num * y.denom <= denom * y.num ) ); }

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

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

    public Fraction divide(Fraction y)
          throws ZeroDenominatorException
    {    return  new Fraction(num * y.denom,
                              denom * y.num );
    }

    public Fraction times(Fraction y)
    {    Fraction ans = new Fraction();
         ans.init( num * y.num, denom * y.denom );
         return ans;
    }

    public Fraction plus(Fraction y)
    {    if ( num == 0 )
             return(makeFraction(y.num, y.denom));
         else if ( y.num == 0 )
             return(makeFraction(num, denom));
         else
         {   Fraction ans = new Fraction();
             ans.init( num * y.denom + y.num * denom,
                                denom * y.denom );
             return ans;
         }
    }

    public Fraction minus()
    {    return( makeFraction(-num, denom) );   }

    public Fraction minus(Fraction y)
    {    if ( num == 0 )           // trivial cases
              return(makeFraction(-y.num, y.denom));
         else if ( y.num == 0 )
              return( new Fraction(this) );
         else                      // sub fractions
         {   Fraction ans = new Fraction();
             ans.init( num * y.denom - y.num * denom,
                                denom * y.denom );
             return ans;
         }
    }

    private Fraction makeFraction(int n, int d)
    {     Fraction f = new Fraction();
          f.num = n;
          f.denom = d;
          return(f);
    }
    // data members
    private int num;    // numerator
    private int denom;  // denominator
}