com.landawn.abacus.util.Fraction Maven / Gradle / Ivy
/*
* 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.
*
*
* @since 2.0
* @version $Id: Fraction.java 1583482 2014-03-31 22:54:57Z niallp $
*/
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);
}
}
/**
* @see {{@link #of(int, int, int, boolean)}
*
* @param whole
* @param numerator
* @param denominator
* @return
*/
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.
*
*
* @param whole
* the whole number, for example the one in 'one and three sevenths'
* @param numerator
* the numerator, for example the three in 'one and three sevenths'
* @param denominator
* the denominator, for example the seven in 'one and three sevenths'
* @return a new fraction instance
* @throws ArithmeticException
* if the denominator is zero
* @throws ArithmeticException
* if the denominator is negative
* @throws ArithmeticException
* if the numerator is negative
* @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.
*
*
* @param value
* the double value to convert
* @return a new fraction instance that is close to the value
* @throws ArithmeticException
* if |value| > Integer.MAX_VALUE or value = NaN
* @throws ArithmeticException
* if the calculated denominator is zero
* @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 the new Fraction instance
* @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 the numerator fraction part
* @deprecated replaced by {@code numerator}
*/
@Deprecated
public int getNumerator() {
return numerator;
}
public int numerator() {
return numerator;
}
/**
*
* Gets the denominator part of the fraction.
*
*
* @return the denominator fraction part
* @deprecated replaced by {@code denominator}
*/
@Deprecated
public int getDenominator() {
return denominator;
}
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 the numerator fraction part of a proper fraction, always positive
* @deprecated replaced by {@code properNumerator}
*/
@Deprecated
public int getProperNumerator() {
return Math.abs(numerator % denominator);
}
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 the whole fraction part of a proper fraction, that includes the sign
* @deprecated replaced by {@code properWhole}
*/
@Deprecated
public int getProperWhole() {
return numerator / denominator;
}
public int properWhole() {
return numerator / denominator;
}
// Number methods
//-------------------------------------------------------------------
/**
*
* Gets the fraction as an int. This returns the whole number part of the fraction.
*
*
* @return the whole number fraction part
*/
@Override
public int intValue() {
return numerator / denominator;
}
/**
*
* Gets the fraction as a long. This returns the whole number part of the fraction.
*
*
* @return the whole number fraction part
*/
@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 the fraction as a float
*/
@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 the fraction as a double
*/
@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 the greatest common divisor, never zero
*/
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 the product x*y
* @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 the product x*y
* @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 the sum x+y
* @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 the difference x-y
* @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.
*
*
* @param fraction
* 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 fraction to divide by is zero
* @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;
}
}