Fleshing out BigFraction

We have created the bulk of the BigFraction class. You are going to add some nice little extras. They are specified in the methods here. Download this on the left; it should compile for you because all of the methods have been stubbed in.

import java.math.BigInteger;
public class BigFraction
{
    public static final BigFraction ONE;
    public static final BigFraction ZERO;
    public static final BigFraction HALF;
    static
    {
        ONE = BigFraction.valueOf(1, 1);
        ZERO = BigFraction.valueOf(0, 1);
        HALF = BigFraction.valueOf(1, 2);
    }
    private final BigInteger num;
    private final BigInteger denom;
    public BigFraction(BigInteger num, BigInteger denom)
    {
        if(denom.compareTo(BigInteger.ZERO) < 0)
        {
            num = num.negate();
            denom = denom.negate();
        }
        BigInteger d = num.gcd(denom);
        this.num = num.divide(d);
        this.denom = denom.divide(d);
    }
    public BigFraction(String num, String denom)
    {
        this(new BigInteger(num), new BigInteger(denom));
    }
    public static BigFraction valueOf(long num, long denom)
    {
        return new BigFraction(BigInteger.valueOf(num),
            BigInteger.valueOf(denom));
    }
    public String toString()
    {
        return String.format("%s/%s", num, denom);
    }
    public boolean equals(Object o)
    {
        if( !(o instanceof BigFraction))
        {
            return false;
        }
        BigFraction that = (BigFraction) o;
        return num.equals(that.num) && denom.equals(that.denom);
    }
    public BigFraction add(BigFraction that)
    {
        //  a/b + c/d = (ad + bc)/bd;
        BigInteger top = num.multiply(that.denom).add(denom.multiply(that.num));
        BigInteger bottom = denom.multiply(that.denom);
        return new BigFraction(top, bottom);
    }
    public BigFraction subtract(BigFraction that)
    {
        //  a/b - c/d = (ad - bc)/bd;
        BigInteger top = num.multiply(that.denom).subtract(denom.multiply(that.num));
        BigInteger bottom = denom.multiply(that.denom);
        return new BigFraction(top, bottom);
    }
    public BigFraction multiply(BigFraction that)
    {
        //  a/b * c/d = (ac)/bd;
        BigInteger top = num.multiply(that.num);
        BigInteger bottom = denom.multiply(that.denom);
        return new BigFraction(top, bottom);
    }
    public BigFraction divide(BigFraction that)
    {
        //  (a/b) / (c/d) = (ad)/bc;
        BigInteger top = num.multiply(that.denom);
        BigInteger bottom = denom.multiply(that.num);
        return new BigFraction(top, bottom);
    }
    /***************** Programming Exercises *******************/
    public BigFraction pow(int n)
    {   
        return null;
    }   
    //integer divide num/denom and round toward zero
    public BigInteger bigIntegerValue()
    {   
        return null;
    }   
    //return -this
    public BigFraction negate()
    {   
        return null;
    }   
    //return |this|
    public BigInteger abs()
    {   
        return null;
    }  
   //return a negative interger if this < that, a positive integer
    //if this > that, and 0 if this.equals(that).
    public int compareTo(BigFraction that)
    {
        return 0;
    }
    //return max(this, that)
    public BigFraction max(BigFraction that)
    {
        return null;
    }
    //return min(this, that)
    public BigFraction min(BigFraction that)
    {
        return null;
    }
   public static BigFraction harmonic(int n)
    {
        //return the nth harmonic number
        return null;
    }
    //annoying challenge problem.
    //return this big fraction as a double.  Sticky question:
    //how to deal with the infinite and zero cases.....
    //Note static members Double.NEGATIVE_INFINITY and Double.INFINITY.
    //test carefully. It's quite hard to get this right.
    public double doubleValue()
    {
        return 0;
    }
    public static void main(String[] args)
    {

        BigFraction f = BigFraction.valueOf(2,3);
        BigFraction g = BigFraction.valueOf(2, 4);
        BigFraction gag = BigFraction.valueOf(1,2);
        System.out.println(f.add(gag).equals(BigFraction.valueOf(7,6)));
        System.out.println(f.subtract(gag).equals(BigFraction.valueOf(1,6)));
        System.out.println(f.multiply(g).equals(BigFraction.valueOf(1,3)));
        System.out.println(f.divide(g).equals(BigFraction.valueOf(4,3)));
        System.out.printf("%s equals %s: %s\n", g, gag, g.equals(gag));
        BigFraction h = BigFraction.valueOf(7776, 1048576);
        System.out.println(f);
        System.out.println(g);
        System.out.println(h);
        System.out.println(f.add(g));
        BigFraction total = BigFraction.ZERO;
        BigFraction x = new BigFraction("1331", "726");
        System.out.println(x);
        for(int k = 1; k <= 100; k++)
        {
            total = total.add(BigFraction.valueOf(1,k));
        }
        System.out.println(total);
    }
}