Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Licensed to the Apache Software Foundation (ASF) under one or more
   * contributor license agreements.  See the NOTICE file distributed with
   * this work for additional information regarding copyright ownership.
   * The ASF licenses this file to You under the Apache License, Version 2.0
   * (the "License"); you may not use this file except in compliance with
   * the License.  You may obtain a copy of the License at
   * 
   *      http://www.apache.org/licenses/LICENSE-2.0
  * 
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package org.apache.commons.lang.math;
 

Fraction is a Number implementation that stores fractions accurately.

This class is immutable, and interoperable with most methods that accept a Number.

Author(s):
Travis Reeder
Stephen Colebourne
Tim O'Brien
Pete Gieser
C. Scott Ananian
Version:
$Id: Fraction.java 599500 2007-11-29 16:25:54Z mbenson $
Since:
2.0
 
 public final class Fraction extends Number implements Comparable {

    
Required for serialization support. Lang version 2.0.

 
     private static final long serialVersionUID = 65382027393090L;

    
Fraction representation of 0.
 
     public static final Fraction ZERO = new Fraction(0, 1);
    
Fraction representation of 1.
 
     public static final Fraction ONE = new Fraction(1, 1);
    
Fraction representation of 1/2.
 
     public static final Fraction ONE_HALF = new Fraction(1, 2);
    
Fraction representation of 1/3.
 
     public static final Fraction ONE_THIRD = new Fraction(1, 3);
    
Fraction representation of 2/3.
 
     public static final Fraction TWO_THIRDS = new Fraction(2, 3);
    
Fraction representation of 1/4.
 
     public static final Fraction ONE_QUARTER = new Fraction(1, 4);
    
Fraction representation of 2/4.
 
     public static final Fraction TWO_QUARTERS = new Fraction(2, 4);
    
Fraction representation of 3/4.
 
     public static final Fraction THREE_QUARTERS = new Fraction(3, 4);
    
Fraction representation of 1/5.
 
     public static final Fraction ONE_FIFTH = new Fraction(1, 5);
    
Fraction representation of 2/5.
 
     public static final Fraction TWO_FIFTHS = new Fraction(2, 5);
    
Fraction representation of 3/5.
 
     public static final Fraction THREE_FIFTHS = new Fraction(3, 5);
    
Fraction representation of 4/5.
 
     public static final Fraction FOUR_FIFTHS = new Fraction(4, 5);


    
The numerator number part of the fraction (the three in three sevenths).
 
     private final int numerator;
    
The denominator number part of the fraction (the seven in three sevenths).
    private final int denominator;

    
Cached output hashCode (class is immutable).
    private transient int hashCode = 0;
    
Cached output toString (class is immutable).
    private transient String toString = null;
    
Cached output toProperString (class is immutable).
    private transient String toProperString = null;

    

Constructs a Fraction instance with the 2 parts of a fraction Y/Z.

Parameters:
numerator the numerator, for example the three in 'three sevenths'
denominator the denominator, for example the seven in 'three sevenths'
    private Fraction(int numeratorint denominator) {
        super();
        this.numerator = numerator;
        this.denominator = denominator;
    }

    

Creates a Fraction instance with the 2 parts of a fraction Y/Z.

Any negative signs are resolved to be on the numerator.

Parameters:
numerator the numerator, for example the three in 'three sevenths'
denominator the denominator, for example the seven in 'three sevenths'
Returns:
a new fraction instance
Throws:
java.lang.ArithmeticException if the denomiator is zero
    public static Fraction getFraction(int numeratorint denominator) {
        if (denominator == 0) {
            throw new ArithmeticException("The denominator must not be zero");
        }
        if (denominator < 0) {
            if (numerator==Integer.MIN_VALUE ||
                    denominator==Integer.MIN_VALUE) {
                throw new ArithmeticException("overflow: can't negate");
            }
            numerator = -numerator;
            denominator = -denominator;
        }
        return new Fraction(numerator, denominator);
    }

    

Creates a Fraction instance with the 3 parts of a fraction X Y/Z.

The negative sign must be passed in on the whole number part.

Parameters:
whole the whole number, for example the one in 'one and three sevenths'
numerator the numerator, for example the three in 'one and three sevenths'
denominator the denominator, for example the seven in 'one and three sevenths'
Returns:
a new fraction instance
Throws:
java.lang.ArithmeticException if the denomiator is zero
java.lang.ArithmeticException if the denominator is negative
java.lang.ArithmeticException if the numerator is negative
java.lang.ArithmeticException if the resulting numerator exceeds Integer.MAX_VALUE
    public static Fraction getFraction(int wholeint numeratorint denominator) {
        if (denominator == 0) {
            throw new ArithmeticException("The denominator must not be zero");
        }
        if (denominator < 0) {
            throw new ArithmeticException("The denominator must not be negative");
        }
        if (numerator < 0) {
            throw new ArithmeticException("The numerator must not be negative");
        }
        long numeratorValue;
        if (whole < 0) {
            numeratorValue = whole * (long)denominator - numerator;
        } else {
            numeratorValue = whole * (long)denominator + numerator;
        }
        if (numeratorValue < Integer.MIN_VALUE ||
                numeratorValue > Integer.MAX_VALUE)  {
            throw new ArithmeticException("Numerator too large to represent as an Integer.");
        }
        return new Fraction((int) numeratorValue, denominator);
    }

    

Creates a reduced Fraction instance with the 2 parts of a fraction Y/Z.

For example, if the input parameters represent 2/4, then the created fraction will be 1/2.

Any negative signs are resolved to be on the numerator.

Parameters:
numerator the numerator, for example the three in 'three sevenths'
denominator the denominator, for example the seven in 'three sevenths'
Returns:
a new fraction instance, with the numerator and denominator reduced
Throws:
java.lang.ArithmeticException if the denominator is zero
    public static Fraction getReducedFraction(int numeratorint denominator) {
        if (denominator == 0) {
            throw new ArithmeticException("The denominator must not be zero");
        }
        if (numerator==0) {
            return ZERO; // normalize zero.
        }
        // allow 2^k/-2^31 as a valid fraction (where k>0)
        if (denominator==Integer.MIN_VALUE && (numerator&1)==0) {
            numerator/=2; denominator/=2;
        }
        if (denominator < 0) {
            if (numerator==Integer.MIN_VALUE ||
                    denominator==Integer.MIN_VALUE) {
                throw new ArithmeticException("overflow: can't negate");
            }
            numerator = -numerator;
            denominator = -denominator;
        }
        // simplify fraction.
        int gcd = greatestCommonDivisor(numerator, denominator);
        numerator /= gcd;
        denominator /= gcd;
        return new Fraction(numerator, denominator);
    }

    

Creates a Fraction instance from a double value.

This method uses the continued fraction algorithm, computing a maximum of 25 convergents and bounding the denominator by 10,000.

Parameters:
value the double value to convert
Returns:
a new fraction instance that is close to the value
Throws:
java.lang.ArithmeticException if |value| > Integer.MAX_VALUE or value = NaN
java.lang.ArithmeticException if the calculated denominator is zero
java.lang.ArithmeticException if the the algorithm does not converge
    public static Fraction getFraction(double value) {
        int sign = (value < 0 ? -1 : 1);
        value = Math.abs(value);
        if (value  > Integer.MAX_VALUE || Double.isNaN(value)) {
            throw new ArithmeticException
                ("The value must not be greater than Integer.MAX_VALUE or NaN");
        }
        int wholeNumber = (int) value;
        value -= wholeNumber;
        
        int numer0 = 0;  // the pre-previous
        int denom0 = 1;  // the pre-previous
        int numer1 = 1;  // the previous
        int denom1 = 0;  // the previous
        int numer2 = 0;  // the current, setup in calculation
        int denom2 = 0;  // the current, setup in calculation
        int a1 = (int) value;
        int a2 = 0;
        double x1 = 1;
        double x2 = 0;
        double y1 = value - a1;
        double y2 = 0;
        double delta1, delta2 = Double.MAX_VALUE;
        double fraction;
        int i = 1;
//        System.out.println("---");
        do {
            delta1 = delta2;
            a2 = (int) (x1 / y1);
            x2 = y1;
            y2 = x1 - a2 * y1;
            numer2 = a1 * numer1 + numer0;
            denom2 = a1 * denom1 + denom0;
            fraction = (double) numer2 / (double) denom2;
            delta2 = Math.abs(value - fraction);
//            System.out.println(numer2 + " " + denom2 + " " + fraction + " " + delta2 + " " + y1);
            a1 = a2;
            x1 = x2;
            y1 = y2;
            numer0 = numer1;
            denom0 = denom1;
            numer1 = numer2;
            denom1 = denom2;
            i++;
//            System.out.println(">>" + delta1 +" "+ delta2+" "+(delta1 > delta2)+" "+i+" "+denom2);
        } while ((delta1 > delta2) && (denom2 <= 10000) && (denom2 > 0) && (i < 25));
        if (i == 25) {
            throw new ArithmeticException("Unable to convert double to fraction");
        }
        return getReducedFraction((numer0 + wholeNumber * denom0) * sign, denom0);
    }

    

Creates a Fraction from a String.

The formats accepted are:

  1. double String containing a dot
  2. 'X Y/Z'
  3. 'Y/Z'
  4. 'X' (a simple whole number)
and a .

Parameters:
str the string to parse, must not be null
Returns:
the new Fraction instance
Throws:
java.lang.IllegalArgumentException if the string is null
java.lang.NumberFormatException if the number format is invalid
    public static Fraction getFraction(String str) {
        if (str == null) {
            throw new IllegalArgumentException("The string must not be null");
        }
        // parse double format
        int pos = str.indexOf('.');
        if (pos >= 0) {
            return getFraction(Double.parseDouble(str));
        }
        // parse X Y/Z format
        pos = str.indexOf(' ');
        if (pos > 0) {
            int whole = Integer.parseInt(str.substring(0, pos));
            str = str.substring(pos + 1);
            pos = str.indexOf('/');
            if (pos < 0) {
                throw new NumberFormatException("The fraction could not be parsed as the format X Y/Z");
            } else {
                int numer = Integer.parseInt(str.substring(0, pos));
                int denom = Integer.parseInt(str.substring(pos + 1));
                return getFraction(whole, numer, denom);
            }
        }
        // parse Y/Z format
        pos = str.indexOf('/');
        if (pos < 0) {
            // simple whole number
            return getFraction(Integer.parseInt(str), 1);
        } else {
            int numer = Integer.parseInt(str.substring(0, pos));
            int denom = Integer.parseInt(str.substring(pos + 1));
            return getFraction(numer, denom);
        }
    }
    // Accessors
    //-------------------------------------------------------------------

    

Gets the numerator part of the fraction.

This method may return a value greater than the denominator, an improper fraction, such as the seven in 7/4.

Returns:
the numerator fraction part
    public int getNumerator() {
        return numerator;
    }

    

Gets the denominator part of the fraction.

Returns:
the denominator fraction part
    public int getDenominator() {
        return denominator;
    }

    

Gets the proper numerator, always positive.

An improper fraction 7/4 can be resolved into a proper one, 1 3/4. This method returns the 3 from the proper fraction.

If the fraction is negative such as -7/4, it can be resolved into -1 3/4, so this method returns the positive proper numerator, 3.

Returns:
the numerator fraction part of a proper fraction, always positive
    public int getProperNumerator() {
        return Math.abs(numerator % denominator);
    }

    

Gets the proper whole part of the fraction.

An improper fraction 7/4 can be resolved into a proper one, 1 3/4. This method returns the 1 from the proper fraction.

If the fraction is negative such as -7/4, it can be resolved into -1 3/4, so this method returns the positive whole part -1.

Returns:
the whole fraction part of a proper fraction, that includes the sign
    public int getProperWhole() {
        return numerator / denominator;
    }
    // Number methods
    //-------------------------------------------------------------------

    

Gets the fraction as an int. This returns the whole number part of the fraction.

Returns:
the whole number fraction part
    public int intValue() {
        return numerator / denominator;
    }

    

Gets the fraction as a long. This returns the whole number part of the fraction.

Returns:
the whole number fraction part
    public long longValue() {
        return (long) numerator / denominator;
    }

    

Gets the fraction as a float. This calculates the fraction as the numerator divided by denominator.

Returns:
the fraction as a float
    public float floatValue() {
        return ((float) numerator) / ((float) denominator);
    }

    

Gets the fraction as a double. This calculates the fraction as the numerator divided by denominator.

Returns:
the fraction as a double
    public double doubleValue() {
        return ((double) numerator) / ((double) denominator);
    }
    // Calculations
    //-------------------------------------------------------------------

    

Reduce the fraction to the smallest values for the numerator and denominator, returning the result.

For example, if this fraction represents 2/4, then the result will be 1/2.

Returns:
a new reduced fraction instance, or this if no simplification possible
    public Fraction reduce() {
        if (numerator == 0) {
            return equals(ZERO) ? this : ZERO;
        }
        int gcd = greatestCommonDivisor(Math.abs(numerator), denominator);
        if (gcd == 1) {
            return this;
        }
        return Fraction.getFraction(numerator / gcd, denominator / gcd);
    }

    

Gets a fraction that is the inverse (1/fraction) of this one.

The returned fraction is not reduced.

Returns:
a new fraction instance with the numerator and denominator inverted.
Throws:
java.lang.ArithmeticException if the fraction represents zero.
    public Fraction invert() {
        if (numerator == 0) {
            throw new ArithmeticException("Unable to invert zero.");
        }
        if (numerator==Integer.MIN_VALUE) {
            throw new ArithmeticException("overflow: can't negate numerator");
        }
        if (numerator<0) {
            return new Fraction(-denominator, -numerator);
        } else {
            return new Fraction(denominator, numerator);
        }
    }

    

Gets a fraction that is the negative (-fraction) of this one.

The returned fraction is not reduced.

Returns:
a new fraction instance with the opposite signed numerator
    public Fraction negate() {
        // the positive range is one smaller than the negative range of an int.
        if (numerator==Integer.MIN_VALUE) {
            throw new ArithmeticException("overflow: too large to negate");
        }
        return new Fraction(-numerator, denominator);
    }

    

Gets a fraction that is the positive equivalent of this one.

More precisely: (fraction >= 0 ? this : -fraction)

The returned fraction is not reduced.

Returns:
this if it is positive, or a new positive fraction instance with the opposite signed numerator
    public Fraction abs() {
        if (numerator >= 0) {
            return this;
        }
        return negate();
    }

    

Gets a fraction that is raised to the passed in power.

The returned fraction is in reduced form.

Parameters:
power the power to raise the fraction to
Returns:
this if the power is one, ONE if the power is zero (even if the fraction equals ZERO) or a new fraction instance raised to the appropriate power
Throws:
java.lang.ArithmeticException if the resulting numerator or denominator exceeds Integer.MAX_VALUE
    public Fraction pow(int power) {
        if (power == 1) {
            return this;
        } else if (power == 0) {
            return ONE;
        } else if (power < 0) {
            if (power==Integer.MIN_VALUE) { // MIN_VALUE can't be negated.
                return this.invert().pow(2).pow(-(power/2));
            }
            return this.invert().pow(-power);
        } else {
            Fraction f = this.multiplyBy(this);
            if ((power % 2) == 0) { // if even...
                return f.pow(power/2);
            } else { // if odd...
                return f.pow(power/2).multiplyBy(this);
            }
        }
    }

    

Gets the greatest common divisor of the absolute value of two numbers, using the "binary gcd" method which avoids division and modulo operations. See Knuth 4.5.2 algorithm B. This algorithm is due to Josef Stein (1961).

Parameters:
u a non-zero number
v a non-zero number
Returns:
the greatest common divisor, never zero
    private static int greatestCommonDivisor(int uint v) {
        //if either op. is abs 0 or 1, return 1:
        if (Math.abs(u) <= 1 || Math.abs(v) <= 1) {
            return 1;
        }
        // keep u and v negative, as negative integers range down to
        // -2^31, while positive numbers can only be as large as 2^31-1
        // (i.e. we can't necessarily negate a negative number without
        // overflow)
        if (u>0) { u=-u; } // make u negative
        if (v>0) { v=-v; } // make v negative
        // B1. [Find power of 2]
        int k=0;
        while ((u&1)==0 && (v&1)==0 && k<31) { // while u and v are both even...
            u/=2; v/=2; k++; // cast out twos.
        }
        if (k==31) {
            throw new ArithmeticException("overflow: gcd is 2^31");
        }
        // B2. Initialize: u and v have been divided by 2^k and at least
        //     one is odd.
        int t = ((u&1)==1) ? v : -(u/2)/*B3*/;
        // t negative: u was odd, v may be even (t replaces v)
        // t positive: u was even, v is odd (t replaces u)
        do {
            /* assert u<0 && v<0; */
            // B4/B3: cast out twos from t.
            while ((t&1)==0) { // while t is even..
                t/=2; // cast out twos
            }
            // B5 [reset max(u,v)]
            if (t>0) {
                u = -t;
            } else {
                v = t;
            }
            // B6/B3. at this point both u and v should be odd.
            t = (v - u)/2;
            // |u| larger: t positive (replace u)
            // |v| larger: t negative (replace v)
        } while (t!=0);
        return -u*(1<<k); // gcd is u*2^k
    }
    // Arithmetic
    //-------------------------------------------------------------------

    
Multiply two integers, checking for overflow.

Parameters:
x a factor
y a factor
Returns:
the product x*y
Throws:
java.lang.ArithmeticException if the result can not be represented as an int
    private static int mulAndCheck(int xint y) {
        long m = ((long)x)*((long)y);
        if (m < Integer.MIN_VALUE ||
            m > Integer.MAX_VALUE) {
            throw new ArithmeticException("overflow: mul");
        }
        return (int)m;
    }
    
    
Multiply two non-negative integers, checking for overflow.

Parameters:
x a non-negative factor
y a non-negative factor
Returns:
the product x*y
Throws:
java.lang.ArithmeticException if the result can not be represented as an int
    private static int mulPosAndCheck(int xint y) {
        /* assert x>=0 && y>=0; */
        long m = ((long)x)*((long)y);
        if (m > Integer.MAX_VALUE) {
            throw new ArithmeticException("overflow: mulPos");
        }
        return (int)m;
    }
    
    
Add two integers, checking for overflow.

Parameters:
x an addend
y an addend
Returns:
the sum x+y
Throws:
java.lang.ArithmeticException if the result can not be represented as an int
    private static int addAndCheck(int xint y) {
        long s = (long)x+(long)y;
        if (s < Integer.MIN_VALUE ||
            s > Integer.MAX_VALUE) {
            throw new ArithmeticException("overflow: add");
        }
        return (int)s;
    }
    
    
Subtract two integers, checking for overflow.

Parameters:
x the minuend
y the subtrahend
Returns:
the difference x-y
Throws:
java.lang.ArithmeticException if the result can not be represented as an int
    private static int subAndCheck(int xint y) {
        long s = (long)x-(long)y;
        if (s < Integer.MIN_VALUE ||
            s > Integer.MAX_VALUE) {
            throw new ArithmeticException("overflow: add");
        }
        return (int)s;
    }
    
    

Adds the value of this fraction to another, returning the result in reduced form. The algorithm follows Knuth, 4.5.1.

Parameters:
fraction the fraction to add, must not be null
Returns:
a Fraction instance with the resulting values
Throws:
java.lang.IllegalArgumentException if the fraction is null
java.lang.ArithmeticException if the resulting numerator or denominator exceeds Integer.MAX_VALUE
    public Fraction add(Fraction fraction) {
        return addSub(fraction, true /* add */);
    }

    

Subtracts the value of another fraction from the value of this one, returning the result in reduced form.

Parameters:
fraction the fraction to subtract, must not be null
Returns:
a Fraction instance with the resulting values
Throws:
java.lang.IllegalArgumentException if the fraction is null
java.lang.ArithmeticException if the resulting numerator or denominator cannot be represented in an int.
    public Fraction subtract(Fraction fraction) {
        return addSub(fraction, false /* subtract */);
    }

    
Implement add and subtract using algorithm described in Knuth 4.5.1.

Parameters:
fraction the fraction to subtract, must not be null
isAdd true to add, false to subtract
Returns:
a Fraction instance with the resulting values
Throws:
java.lang.IllegalArgumentException if the fraction is null
java.lang.ArithmeticException if the resulting numerator or denominator cannot be represented in an int.
    private Fraction addSub(Fraction fractionboolean isAdd) {
        if (fraction == null) {
            throw new IllegalArgumentException("The fraction must not be null");
        }
        // zero is identity for addition.
        if (numerator == 0) {
            return isAdd ? fraction : fraction.negate();
        }
        if (fraction.numerator == 0) {
            return this;
        }     
        // if denominators are randomly distributed, d1 will be 1 about 61%
        // of the time.
        int d1 = greatestCommonDivisor(denominator, fraction.denominator);
        if (d1==1) {
            // result is ( (u*v' +/- u'v) / u'v')
            int uvp = mulAndCheck(numerator, fraction.denominator);
            int upv = mulAndCheck(fraction.numerator, denominator);
            return new Fraction
                (isAdd ? addAndCheck(uvp, upv) : subAndCheck(uvp, upv),
                 mulPosAndCheck(denominator, fraction.denominator));
        }
        // the quantity 't' requires 65 bits of precision; see knuth 4.5.1
        // exercise 7.  we're going to use a BigInteger.
        // t = u(v'/d1) +/- v(u'/d1)
        BigInteger uvp = BigInteger.valueOf(numerator)
            .multiply(BigInteger.valueOf(fraction.denominator/d1));
        BigInteger upv = BigInteger.valueOf(fraction.numerator)
            .multiply(BigInteger.valueOf(denominator/d1));
        BigInteger t = isAdd ? uvp.add(upv) : uvp.subtract(upv);
        // but d2 doesn't need extra precision because
        // d2 = gcd(t,d1) = gcd(t mod d1, d1)
        int tmodd1 = t.mod(BigInteger.valueOf(d1)).intValue();
        int d2 = (tmodd1==0)?d1:greatestCommonDivisor(tmodd1, d1);
        // result is (t/d2) / (u'/d1)(v'/d2)
        BigInteger w = t.divide(BigInteger.valueOf(d2));
        if (w.bitLength() > 31) {
            throw new ArithmeticException
                ("overflow: numerator too large after multiply");
        }
        return new Fraction
            (w.intValue(),
             mulPosAndCheck(denominator/d1, fraction.denominator/d2));
    }

    

Multiplies the value of this fraction by another, returning the result in reduced form.

Parameters:
fraction the fraction to multiply by, must not be null
Returns:
a Fraction instance with the resulting values
Throws:
java.lang.IllegalArgumentException if the fraction is null
java.lang.ArithmeticException if the resulting numerator or denominator exceeds Integer.MAX_VALUE
    public Fraction multiplyBy(Fraction fraction) {
        if (fraction == null) {
            throw new IllegalArgumentException("The fraction must not be null");
        }
        if (numerator == 0 || fraction.numerator == 0) {
            return ZERO;
        }
        // knuth 4.5.1
        // make sure we don't overflow unless the result *must* overflow.
        int d1 = greatestCommonDivisor(numerator, fraction.denominator);
        int d2 = greatestCommonDivisor(fraction.numerator, denominator);
        return getReducedFraction
            (mulAndCheck(numerator/d1, fraction.numerator/d2),
             mulPosAndCheck(denominator/d2, fraction.denominator/d1));
    }

    

Divide the value of this fraction by another.

Parameters:
fraction the fraction to divide by, must not be null
Returns:
a Fraction instance with the resulting values
Throws:
java.lang.IllegalArgumentException if the fraction is null
java.lang.ArithmeticException if the fraction to divide by is zero
java.lang.ArithmeticException if the resulting numerator or denominator exceeds Integer.MAX_VALUE
    public Fraction divideBy(Fraction fraction) {
        if (fraction == null) {
            throw new IllegalArgumentException("The fraction must not be null");
        }
        if (fraction.numerator == 0) {
            throw new ArithmeticException("The fraction to divide by must not be zero");
        }
        return multiplyBy(fraction.invert());
    }
    // Basics
    //-------------------------------------------------------------------

    

Compares this fraction to another object to test if they are equal.

.

To be equal, both values must be equal. Thus 2/4 is not equal to 1/2.

Parameters:
obj the reference object with which to compare
Returns:
true if this object is equal
    public boolean equals(Object obj) {
        if (obj == this) {
            return true;
        }
        if (obj instanceof Fraction == false) {
            return false;
        }
        Fraction other = (Fraction) obj;
        return (getNumerator() == other.getNumerator() &&
                getDenominator() == other.getDenominator());
    }

    

Gets a hashCode for the fraction.

Returns:
a hash code value for this object
    public int hashCode() {
        if (hashCode == 0) {
            // hashcode update should be atomic.
            hashCode = 37 * (37 * 17 + getNumerator()) + getDenominator();
        }
        return hashCode;
    }

    

Compares this object to another based on size.

Note: this class has a natural ordering that is inconsistent with equals, because, for example, equals treats 1/2 and 2/4 as different, whereas compareTo treats them as equal.

Parameters:
object the object to compare to
Returns:
-1 if this is less, 0 if equal, +1 if greater
Throws:
java.lang.ClassCastException if the object is not a Fraction
java.lang.NullPointerException if the object is null
    public int compareTo(Object object) {
        Fraction other = (Fraction) object;
        if (this==other) {
            return 0;
        }
        if (numerator == other.numerator && denominator == other.denominator) {
            return 0;
        }
        // otherwise see which is less
        long first = (long) numerator * (long) other.denominator;
        long second = (long) other.numerator * (long) denominator;
        if (first == second) {
            return 0;
        } else if (first < second) {
            return -1;
        } else {
            return 1;
        }
    }

    

Gets the fraction as a String.

The format used is 'numerator/denominator' always.

Returns:
a String form of the fraction
    public String toString() {
        if (toString == null) {
            toString = new StringBuffer(32)
                .append(getNumerator())
                .append('/')
                .append(getDenominator()).toString();
        }
        return toString;
    }

    

Gets the fraction as a proper String in the format X Y/Z.

The format used in 'wholeNumber numerator/denominator'. If the whole number is zero it will be ommitted. If the numerator is zero, only the whole number is returned.

Returns:
a String form of the fraction
    public String toProperString() {
        if (toProperString == null) {
            if (numerator == 0) {
                toProperString = "0";
            } else if (numerator == denominator) {
                toProperString = "1";
            } else if (numerator == -1 * denominator) {
                toProperString = "-1";
            } else if ((numerator>0?-numerator:numerator) < -denominator) {
                // note that we do the magnitude comparison test above with
                // NEGATIVE (not positive) numbers, since negative numbers
                // have a larger range.  otherwise numerator==Integer.MIN_VALUE
                // is handled incorrectly.
                int properNumerator = getProperNumerator();
                if (properNumerator == 0) {
                    toProperString = Integer.toString(getProperWhole());
                } else {
                    toProperString = new StringBuffer(32)
                        .append(getProperWhole()).append(' ')
                        .append(properNumerator).append('/')
                        .append(getDenominator()).toString();
                }
            } else {
                toProperString = new StringBuffer(32)
                    .append(getNumerator()).append('/')
                    .append(getDenominator()).toString();
            }
        }
        return toProperString;
    }
New to GrepCode? Check out our FAQ X