com.landawn.abacus.util.Fraction Maven / Gradle / Ivy
Show all versions of abacus-util-se Show documentation
/*
* 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 com.landawn.abacus.util;
import java.math.BigInteger;
/**
*
* Note: it's copied from Apache Commons Lang developed at The Apache Software Foundation (http://www.apache.org/), or
* under the Apache License 2.0. The methods copied from other products/frameworks may be modified in this class.
*
*
*
* Fraction is a Number implementation that stores fractions accurately.
*
*
*
* This class is immutable, and interoperable with most methods that accept a Number.
*
*
*
* Note that this class is intended for common use cases, it is int based and thus suffers from various overflow
* issues. For a BigInteger based equivalent, please see the Commons Math BigFraction class.
*
*
* @version $Id: Fraction.java 1583482 2014-03-31 22:54:57Z niallp $
* @since 2.0
*/
public final class Fraction extends Number implements Comparable {
/**
* Required for serialization support. Lang version 2.0.
*
* @see java.io.Serializable
*/
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.
*
*
* @param numerator
* the numerator, for example the three in 'three sevenths'
* @param denominator
* the denominator, for example the seven in 'three sevenths'
*/
private Fraction(final int numerator, final int denominator) {
super();
this.numerator = numerator;
this.denominator = denominator;
}
/**
*
* @param numerator
* @param denominator
* @return
* @see #of(int, int, boolean)
*/
public static Fraction of(int numerator, int denominator) {
return of(numerator, denominator, false);
}
/**
*
* Creates a Fraction instance with the 2 parts of a fraction Y/Z.
*
*
*
* Any negative signs are resolved to be on the numerator.
*
*
* @param numerator
* the numerator, for example the three in 'three sevenths'
* @param denominator
* the denominator, for example the seven in 'three sevenths'
* @param reduce
* if it's true, reduce 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.
* @return a new fraction instance
* @throws ArithmeticException
* if the denominator is zero or the denominator is {@code negative} and the numerator is
* {@code Integer#MIN_VALUE}
*/
public static Fraction of(int numerator, int denominator, boolean reduce) {
if (denominator == 0) {
throw new ArithmeticException("The denominator must not be zero");
}
if (reduce) {
// 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;
}
if (reduce) {
if (numerator == 0) {
return ZERO; // normalize zero.
}
// simplify fraction.
final int gcd = greatestCommonDivisor(numerator, denominator);
numerator /= gcd;
denominator /= gcd;
return new Fraction(numerator, denominator);
} else {
return new Fraction(numerator, denominator);
}
}
/**
*
* @param whole
* @param numerator
* @param denominator
* @return
* @see {{@link #of(int, int, int, boolean)}
*/
public static Fraction of(final int whole, final int numerator, final int denominator) {
return of(whole, numerator, denominator, false);
}
/**
*
* 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.
*
*
whole the whole number, for example the one in 'one and three sevenths'
the numerator, for example the three in 'one and three sevenths'
the denominator, for example the seven in 'one and three sevenths'
* @param reduce
* @return a new fraction instance
* @throws ArithmeticException if the resulting numerator exceeds Integer.MAX_VALUE
*/
public static Fraction of(final int whole, final int numerator, final int denominator, boolean reduce) {
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 of((int) numeratorValue, denominator, reduce);
}
/**
*
* 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.
*
*
value the double value to convert
* @return a new fraction instance that is close to the value
* @throws ArithmeticException if the the algorithm does not converge
*/
public static Fraction of(double value) {
final 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");
}
final 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 of((numer0 + wholeNumber * denom0) * sign, denom0, true);
}
/**
*
* Creates a Fraction from a String.
*
*
*
* The formats accepted are:
*
*
*
* double String containing a dot- 'X Y/Z'
* - 'Y/Z'
* - 'X' (a simple whole number)
*
*
* and a .
*
*
* @param str
* the string to parse, must not be null
* @return
* @throws IllegalArgumentException
* if the string is null
* @throws NumberFormatException
* if the number format is invalid
*/
public static Fraction of(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 of(Double.parseDouble(str));
}
// parse X Y/Z format
pos = str.indexOf(' ');
if (pos > 0) {
final 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 {
final int numer = Integer.parseInt(str.substring(0, pos));
final int denom = Integer.parseInt(str.substring(pos + 1));
return of(whole, numer, denom);
}
}
// parse Y/Z format
pos = str.indexOf('/');
if (pos < 0) {
// simple whole number
return of(Integer.parseInt(str), 1);
} else {
final int numer = Integer.parseInt(str.substring(0, pos));
final int denom = Integer.parseInt(str.substring(pos + 1));
return of(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.
*
*
* @return
* @deprecated replaced by {@code numerator}
*/
@Deprecated
public int getNumerator() {
return numerator;
}
/**
*
* @return
*/
public int numerator() {
return numerator;
}
/**
*
* Gets the denominator part of the fraction.
*
*
* @return
* @deprecated replaced by {@code denominator}
*/
@Deprecated
public int getDenominator() {
return denominator;
}
/**
*
* @return
*/
public int denominator() {
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.
*
*
* @return
* @deprecated replaced by {@code properNumerator}
*/
@Deprecated
public int getProperNumerator() {
return Math.abs(numerator % denominator);
}
/**
*
* @return
*/
public int properNumerator() {
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.
*
*
* @return
* @deprecated replaced by {@code properWhole}
*/
@Deprecated
public int getProperWhole() {
return numerator / denominator;
}
/**
*
* @return
*/
public int properWhole() {
return numerator / denominator;
}
// Number methods
//-------------------------------------------------------------------
/**
*
* Gets the fraction as an int. This returns the whole number part of the fraction.
*
*
* @return
*/
@Override
public int intValue() {
return numerator / denominator;
}
/**
*
* Gets the fraction as a long. This returns the whole number part of the fraction.
*
*
* @return
*/
@Override
public long longValue() {
return (long) numerator / denominator;
}
/**
*
* Gets the fraction as a float. This calculates the fraction as the numerator divided by denominator.
*
*
* @return
*/
@Override
public float floatValue() {
return (float) numerator / (float) denominator;
}
/**
*
* Gets the fraction as a double. This calculates the fraction as the numerator divided by denominator.
*
*
* @return
*/
@Override
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.
*
*
* @return a new reduced fraction instance, or this if no simplification possible
*/
public Fraction reduce() {
if (numerator == 0) {
return equals(ZERO) ? this : ZERO;
}
final int gcd = greatestCommonDivisor(Math.abs(numerator), denominator);
if (gcd == 1) {
return this;
}
return Fraction.of(numerator / gcd, denominator / gcd);
}
/**
*
* Gets a fraction that is the inverse (1/fraction) of this one.
*
*
*
* The returned fraction is not reduced.
*
*
* @return a new fraction instance with the numerator and denominator inverted.
* @throws 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.
*
*
* @return 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.
*
*
* @return 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.
*
*
* @param power
* the power to raise the fraction to
* @return 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 ArithmeticException
* if the resulting numerator or denominator exceeds Integer.MAX_VALUE
*/
public Fraction pow(final 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 {
final Fraction f = this.multipliedBy(this);
if (power % 2 == 0) { // if even...
return f.pow(power / 2);
} else { // if odd...
return f.pow(power / 2).multipliedBy(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).
*
*
* @param u
* a non-zero number
* @param v
* a non-zero number
* @return
*/
private static int greatestCommonDivisor(int u, int v) {
// From Commons Math:
if (u == 0 || v == 0) {
if (u == Integer.MIN_VALUE || v == Integer.MIN_VALUE) {
throw new ArithmeticException("overflow: gcd is 2^31");
}
return Math.abs(u) + Math.abs(v);
}
//if either operand is abs 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.
*
* @param x
* a factor
* @param y
* a factor
* @return
* @throws ArithmeticException
* if the result can not be represented as an int
*/
private static int mulAndCheck(final int x, final int y) {
final 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.
*
* @param x
* a non-negative factor
* @param y
* a non-negative factor
* @return
* @throws ArithmeticException
* if the result can not be represented as an int
*/
private static int mulPosAndCheck(final int x, final int y) {
/* assert x>=0 && y>=0; */
final 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.
*
* @param x
* an addend
* @param y
* an addend
* @return
* @throws ArithmeticException
* if the result can not be represented as an int
*/
private static int addAndCheck(final int x, final int y) {
final 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.
*
* @param x
* the minuend
* @param y
* the subtrahend
* @return
* @throws ArithmeticException
* if the result can not be represented as an int
*/
private static int subAndCheck(final int x, final int y) {
final 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.
*
*
* @param fraction
* the fraction to add, must not be null
* @return a Fraction instance with the resulting values
* @throws IllegalArgumentException
* if the fraction is null
* @throws ArithmeticException
* if the resulting numerator or denominator exceeds Integer.MAX_VALUE
*/
public Fraction add(final 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.
*
*
* @param fraction
* the fraction to subtract, must not be null
* @return a Fraction instance with the resulting values
* @throws IllegalArgumentException
* if the fraction is null
* @throws ArithmeticException
* if the resulting numerator or denominator cannot be represented in an int.
*/
public Fraction subtract(final Fraction fraction) {
return addSub(fraction, false /* subtract */);
}
/**
* Implement add and subtract using algorithm described in Knuth 4.5.1.
*
* @param fraction
* the fraction to subtract, must not be null
* @param isAdd
* true to add, false to subtract
* @return a Fraction instance with the resulting values
* @throws IllegalArgumentException
* if the fraction is null
* @throws ArithmeticException
* if the resulting numerator or denominator cannot be represented in an int.
*/
private Fraction addSub(final Fraction fraction, final boolean 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.
final int d1 = greatestCommonDivisor(denominator, fraction.denominator);
if (d1 == 1) {
// result is ( (u*v' +/- u'v) / u'v')
final int uvp = mulAndCheck(numerator, fraction.denominator);
final 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)
final BigInteger uvp = BigInteger.valueOf(numerator).multiply(BigInteger.valueOf(fraction.denominator / d1));
final BigInteger upv = BigInteger.valueOf(fraction.numerator).multiply(BigInteger.valueOf(denominator / d1));
final 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)
final int tmodd1 = t.mod(BigInteger.valueOf(d1)).intValue();
final int d2 = tmodd1 == 0 ? d1 : greatestCommonDivisor(tmodd1, d1);
// result is (t/d2) / (u'/d1)(v'/d2)
final 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.
*
*
* @param fraction
* the fraction to multiply by, must not be null
* @return a Fraction instance with the resulting values
* @throws IllegalArgumentException
* if the fraction is null
* @throws ArithmeticException
* if the resulting numerator or denominator exceeds Integer.MAX_VALUE
*/
public Fraction multipliedBy(final 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.
final int d1 = greatestCommonDivisor(numerator, fraction.denominator);
final int d2 = greatestCommonDivisor(fraction.numerator, denominator);
return of(mulAndCheck(numerator / d1, fraction.numerator / d2), mulPosAndCheck(denominator / d2, fraction.denominator / d1), true);
}
/**
*
* Divide the value of this fraction by another.
*
*
the fraction to divide by, must not be null
* @return a Fraction instance with the resulting values
* @throws IllegalArgumentException if the fraction is null
* @throws ArithmeticException if the resulting numerator or denominator exceeds Integer.MAX_VALUE
*/
public Fraction dividedBy(final 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 multipliedBy(fraction.invert());
}
// Basics
//-------------------------------------------------------------------
/**
*
* 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.
*
* @param other
* the object to compare to
* @return -1 if this is less, 0 if equal, +1 if greater
* @throws ClassCastException
* if the object is not a Fraction
* @throws NullPointerException
* if the object is null
*/
@Override
public int compareTo(final Fraction other) {
if (this == other) {
return 0;
}
if (numerator == other.numerator && denominator == other.denominator) {
return 0;
}
// otherwise see which is less
final long first = (long) numerator * (long) other.denominator;
final 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 proper String in the format X Y/Z.
*
*
*
* The format used in 'wholeNumber numerator/denominator'. If the whole number is zero it will
* be omitted. If the numerator is zero, only the whole number is returned.
*
*
* @return 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.
final int properNumerator = getProperNumerator();
if (properNumerator == 0) {
toProperString = Integer.toString(getProperWhole());
} else {
toProperString = new StringBuilder(32).append(getProperWhole())
.append(' ')
.append(properNumerator)
.append('/')
.append(getDenominator())
.toString();
}
} else {
toProperString = new StringBuilder(32).append(getNumerator()).append('/').append(getDenominator()).toString();
}
}
return toProperString;
}
/**
*
* 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.
*
*
* @param obj
* the reference object with which to compare
* @return true if this object is equal
*/
@Override
public boolean equals(final Object obj) {
if (obj == this) {
return true;
}
if (obj instanceof Fraction == false) {
return false;
}
final Fraction other = (Fraction) obj;
return getNumerator() == other.getNumerator() && getDenominator() == other.getDenominator();
}
/**
*
* Gets a hashCode for the fraction.
*
*
* @return a hash code value for this object
*/
@Override
public int hashCode() {
if (hashCode == 0) {
// hashcode update should be atomic.
hashCode = 37 * (37 * 17 + getNumerator()) + getDenominator();
}
return hashCode;
}
/**
*
* Gets the fraction as a String.
*
*
*
* The format used is 'numerator/denominator' always.
*
* @return a String form of the fraction
*/
@Override
public String toString() {
if (toString == null) {
toString = new StringBuilder(32).append(getNumerator()).append('/').append(getDenominator()).toString();
}
return toString;
}
}