# 比較 - Javaで分数を表す最良の方法は?

## striptrailingzeros (17)

Specifically : Is there a better way to handle being passed a zero denominator? Setting the denominator to 1 is feels mighty arbitrary. How can I do this right?

I would say throw a ArithmeticException for divide by zero, since that's really what's happening:

``````public Fraction(int numerator, int denominator) {
if(denominator == 0)
throw new ArithmeticException("Divide by zero.");
this.numerator = numerator;
this.denominator = denominator;
}
``````

Instead of "Divide by zero.", you might want to make the message say "Divide by zero: Denominator for Fraction is zero."

https://code.i-harness.com

バージョン8（ hstoerrおかげで）：

• equals（）メソッドはcompareTo（）メソッドと一貫しています
``````final class Fraction extends Number {
private int numerator;
private int denominator;

public Fraction(int numerator, int denominator) {
if(denominator == 0) {
throw new IllegalArgumentException("denominator is zero");
}
if(denominator < 0) {
numerator *= -1;
denominator *= -1;
}
this.numerator = numerator;
this.denominator = denominator;
}

public Fraction(int numerator) {
this.numerator = numerator;
this.denominator = 1;
}

public int getNumerator() {
return this.numerator;
}

public int getDenominator() {
return this.denominator;
}

public byte byteValue() {
return (byte) this.doubleValue();
}

public double doubleValue() {
return ((double) numerator)/((double) denominator);
}

public float floatValue() {
return (float) this.doubleValue();
}

public int intValue() {
return (int) this.doubleValue();
}

public long longValue() {
return (long) this.doubleValue();
}

public short shortValue() {
return (short) this.doubleValue();
}

public boolean equals(Fraction frac) {
return this.compareTo(frac) == 0;
}

public int compareTo(Fraction frac) {
long t = this.getNumerator() * frac.getDenominator();
long f = frac.getNumerator() * this.getDenominator();
int result = 0;
if(t>f) {
result = 1;
}
else if(f>t) {
result = -1;
}
return result;
}
}
``````

• デイブレイ
• cletus
• duffymo
• James
• Milhous
• オスカー・レイエス
• ジェイソンS
• Francisco Canedo
• アウトロープログラマー
• Beska

I will need to order them from smallest to largest, so eventually I will need to represent them as a double also

Not strictly necessary. (In fact if you want to handle equality correctly, don't rely on double to work properly.) If b*d is positive, a/b < c/d if ad < bc. If there are negative integers involved, that can be handled appropriately...

I might rewrite as:

``````public int compareTo(Fraction frac)
{
// we are comparing this=a/b with frac=c/d
// by multiplying both sides by bd.
// If bd is positive, then a/b < c/d <=> ad < bc.
// If bd is negative, then a/b < c/d <=> ad > bc.
// If bd is 0, then you've got other problems (either b=0 or d=0)
int d = frac.getDenominator();
long ad = (long)this.numerator * d;
long bc = (long)this.denominator * frac.getNumerator();
return (diff > 0 ? 1 : (diff < 0 ? -1 : 0));
}
``````

The use of `long` here is to ensure there's not an overflow if you multiply two large `int` s. handle If you can guarantee that the denominator is always nonnegative (if it's negative, just negate both numerator and denominator), then you can get rid of having to check whether b*d is positive and save a few steps. I'm not sure what behavior you're looking for with zero denominator.

Not sure how performance compares to using doubles to compare. (that is, if you care about performance that much) Here's a test method I used to check. (Appears to work properly.)

``````public static void main(String[] args)
{
int a = Integer.parseInt(args[0]);
int b = Integer.parseInt(args[1]);
int c = Integer.parseInt(args[2]);
int d = Integer.parseInt(args[3]);
Fraction f1 = new Fraction(a,b);
Fraction f2 = new Fraction(c,d);
int rel = f1.compareTo(f2);
String relstr = "<=>";
System.out.println(a+"/"+b+" "+relstr.charAt(rel+1)+" "+c+"/"+d);
}
``````

(ps you might consider restructuring to implement `Comparable` or `Comparator` for your class.)

A clean up practice that I like is to only have only one return.

`````` public int compareTo(Fraction frac) {
int result = 0
double t = this.doubleValue();
double f = frac.doubleValue();
if(t>f)
result = 1;
else if(f>t)
result -1;
return result;
}
``````

Even though you have the methods compareTo(), if you want to make use of utilities like Collections.sort(), then you should also implement Comparable.

``````public class Fraction extends Number implements Comparable<Fraction> {
...
}
``````

Also, for pretty display I recommend overriding toString()

``````public String toString() {
return this.getNumerator() + "/" + this.getDenominator();
}
``````

And finally, I'd make the class public so that you can use it from different packages.

I cleaned up cletus' answer :

• Added checks for method preconditions.
• Replaced custom parsing in `valueOf(String)` with the `BigInteger(String)` which is both more flexible and faster.
``````import com.google.common.base.Splitter;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.math.RoundingMode;
import java.util.List;
import java.util.Objects;
import org.bitbucket.cowwoc.preconditions.Preconditions;

/**
* A rational fraction, represented by {@code numerator / denominator}.
* <p>
* This implementation is based on <a
* href="https://.com/a/474577/14731">https://.com/a/474577/14731</a>
* <p>
* @author Gili Tzabari
*/
public final class BigRational extends Number implements Comparable<BigRational>
{
private static final long serialVersionUID = 0L;
public static final BigRational ZERO = new BigRational(BigInteger.ZERO, BigInteger.ONE);
public static final BigRational ONE = new BigRational(BigInteger.ONE, BigInteger.ONE);

/**
* Ensures the fraction the denominator is positive and optionally divides the numerator and
* denominator by the greatest common factor.
* <p>
* @param numerator   a numerator
* @param denominator a denominator
* @param checkGcd    true if the numerator and denominator should be divided by the greatest
*                    common factor
* @return the canonical representation of the rational fraction
*/
private static BigRational canonical(BigInteger numerator, BigInteger denominator,
boolean checkGcd)
{
assert (numerator != null);
assert (denominator != null);
if (denominator.signum() == 0)
throw new IllegalArgumentException("denominator is zero");
if (numerator.signum() == 0)
return ZERO;
BigInteger newNumerator = numerator;
BigInteger newDenominator = denominator;
if (newDenominator.signum() < 0)
{
newNumerator = newNumerator.negate();
newDenominator = newDenominator.negate();
}
if (checkGcd)
{
BigInteger gcd = newNumerator.gcd(newDenominator);
if (!gcd.equals(BigInteger.ONE))
{
newNumerator = newNumerator.divide(gcd);
newDenominator = newDenominator.divide(gcd);
}
}
return new BigRational(newNumerator, newDenominator);
}

/**
* @param numerator   a numerator
* @param denominator a denominator
* @return a BigRational having value {@code numerator / denominator}
* @throws NullPointerException if numerator or denominator are null
*/
public static BigRational valueOf(BigInteger numerator, BigInteger denominator)
{
Preconditions.requireThat(numerator, "numerator").isNotNull();
Preconditions.requireThat(denominator, "denominator").isNotNull();
return canonical(numerator, denominator, true);
}

/**
* @param numerator   a numerator
* @param denominator a denominator
* @return a BigRational having value {@code numerator / denominator}
*/
public static BigRational valueOf(long numerator, long denominator)
{
BigInteger bigNumerator = BigInteger.valueOf(numerator);
BigInteger bigDenominator = BigInteger.valueOf(denominator);
return canonical(bigNumerator, bigDenominator, true);
}

/**
* @param value the parameter value
* @param name  the parameter name
* @return the BigInteger representation of the parameter
* @throws NumberFormatException if value is not a valid representation of BigInteger
*/
private static BigInteger requireBigInteger(String value, String name)
throws NumberFormatException
{
try
{
return new BigInteger(value);
}
catch (NumberFormatException e)
{
throw (NumberFormatException) new NumberFormatException("Invalid " + name + ": " + value).
initCause(e);
}
}

/**
* @param numerator   a numerator
* @param denominator a denominator
* @return a BigRational having value {@code numerator / denominator}
* @throws NullPointerException     if numerator or denominator are null
* @throws IllegalArgumentException if numerator or denominator are empty
* @throws NumberFormatException    if numerator or denominator are not a valid representation of
*                                  BigDecimal
*/
public static BigRational valueOf(String numerator, String denominator)
throws NullPointerException, IllegalArgumentException, NumberFormatException
{
Preconditions.requireThat(numerator, "numerator").isNotNull().isNotEmpty();
Preconditions.requireThat(denominator, "denominator").isNotNull().isNotEmpty();
BigInteger bigNumerator = requireBigInteger(numerator, "numerator");
BigInteger bigDenominator = requireBigInteger(denominator, "denominator");
return canonical(bigNumerator, bigDenominator, true);
}

/**
* @param value a string representation of a rational fraction (e.g. "12.34e5" or "3/4")
* @return a BigRational representation of the String
* @throws NullPointerException     if value is null
* @throws IllegalArgumentException if value is empty
* @throws NumberFormatException    if numerator or denominator are not a valid representation of
*                                  BigDecimal
*/
public static BigRational valueOf(String value)
throws NullPointerException, IllegalArgumentException, NumberFormatException
{
Preconditions.requireThat(value, "value").isNotNull().isNotEmpty();
List<String> fractionParts = Splitter.on('/').splitToList(value);
if (fractionParts.size() == 1)
return valueOfRational(value);
if (fractionParts.size() == 2)
return BigRational.valueOf(fractionParts.get(0), fractionParts.get(1));
throw new IllegalArgumentException("Too many slashes: " + value);
}

/**
* @param value a string representation of a rational fraction (e.g. "12.34e5")
* @return a BigRational representation of the String
* @throws NullPointerException     if value is null
* @throws IllegalArgumentException if value is empty
* @throws NumberFormatException    if numerator or denominator are not a valid representation of
*                                  BigDecimal
*/
private static BigRational valueOfRational(String value)
throws NullPointerException, IllegalArgumentException, NumberFormatException
{
Preconditions.requireThat(value, "value").isNotNull().isNotEmpty();
BigDecimal bigDecimal = new BigDecimal(value);
int scale = bigDecimal.scale();
BigInteger numerator = bigDecimal.unscaledValue();
BigInteger denominator;
if (scale > 0)
denominator = BigInteger.TEN.pow(scale);
else
{
numerator = numerator.multiply(BigInteger.TEN.pow(-scale));
denominator = BigInteger.ONE;
}

return canonical(numerator, denominator, true);
}

private final BigInteger numerator;
private final BigInteger denominator;

/**
* @param numerator   the numerator
* @param denominator the denominator
* @throws NullPointerException if numerator or denominator are null
*/
private BigRational(BigInteger numerator, BigInteger denominator)
{
Preconditions.requireThat(numerator, "numerator").isNotNull();
Preconditions.requireThat(denominator, "denominator").isNotNull();
this.numerator = numerator;
this.denominator = denominator;
}

/**
* @return the numerator
*/
public BigInteger getNumerator()
{
return numerator;
}

/**
* @return the denominator
*/
public BigInteger getDenominator()
{
return denominator;
}

@Override
@SuppressWarnings("AccessingNonPublicFieldOfAnotherObject")
public int compareTo(BigRational other)
{
Preconditions.requireThat(other, "other").isNotNull();

// canonical() ensures denominator is positive
if (numerator.signum() != other.numerator.signum())
return numerator.signum() - other.numerator.signum();

// Set the denominator to a common multiple before comparing the numerators
BigInteger first = numerator.multiply(other.denominator);
BigInteger second = other.numerator.multiply(denominator);
return first.compareTo(second);
}

/**
* @param other another rational fraction
* @return the result of adding this object to {@code other}
* @throws NullPointerException if other is null
*/
@SuppressWarnings("AccessingNonPublicFieldOfAnotherObject")
{
Preconditions.requireThat(other, "other").isNotNull();
if (other.numerator.signum() == 0)
return this;
if (numerator.signum() == 0)
return other;
if (denominator.equals(other.denominator))
return canonical(numerator.multiply(other.denominator).
denominator.multiply(other.denominator), true);
}

/**
* @param other another rational fraction
* @return the result of subtracting {@code other} from this object
* @throws NullPointerException if other is null
*/
@SuppressWarnings("AccessingNonPublicFieldOfAnotherObject")
public BigRational subtract(BigRational other)
{
}

/**
* @param other another rational fraction
* @return the result of multiplying this object by {@code other}
* @throws NullPointerException if other is null
*/
@SuppressWarnings("AccessingNonPublicFieldOfAnotherObject")
public BigRational multiply(BigRational other)
{
Preconditions.requireThat(other, "other").isNotNull();
if (numerator.signum() == 0 || other.numerator.signum() == 0)
return ZERO;
if (numerator.equals(other.denominator))
return canonical(other.numerator, denominator, true);
if (other.numerator.equals(denominator))
return canonical(numerator, other.denominator, true);
if (numerator.negate().equals(other.denominator))
return canonical(other.numerator.negate(), denominator, true);
if (other.numerator.negate().equals(denominator))
return canonical(numerator.negate(), other.denominator, true);
return canonical(numerator.multiply(other.numerator), denominator.multiply(other.denominator),
true);
}

/**
* @param other another rational fraction
* @return the result of dividing this object by {@code other}
* @throws NullPointerException if other is null
*/
public BigRational divide(BigRational other)
{
return multiply(other.invert());
}

/**
* @return true if the object is a whole number
*/
public boolean isInteger()
{
return numerator.signum() == 0 || denominator.equals(BigInteger.ONE);
}

/**
* Returns a BigRational whose value is (-this).
* <p>
* @return -this
*/
public BigRational negate()
{
return new BigRational(numerator.negate(), denominator);
}

/**
* @return a rational fraction with the numerator and denominator swapped
*/
public BigRational invert()
{
return canonical(denominator, numerator, false);
}

/**
* @return the absolute value of this {@code BigRational}
*/
public BigRational abs()
{
if (numerator.signum() < 0)
return negate();
return this;
}

/**
* @param exponent exponent to which both numerator and denominator is to be raised.
* @return a BigRational whose value is (this<sup>exponent</sup>).
*/
public BigRational pow(int exponent)
{
return canonical(numerator.pow(exponent), denominator.pow(exponent), true);
}

/**
* @param other another rational fraction
* @return the minimum of this object and the other fraction
*/
public BigRational min(BigRational other)
{
if (compareTo(other) <= 0)
return this;
return other;
}

/**
* @param other another rational fraction
* @return the maximum of this object and the other fraction
*/
public BigRational max(BigRational other)
{
if (compareTo(other) >= 0)
return this;
return other;
}

/**
* @param scale        scale of the BigDecimal quotient to be returned
* @param roundingMode the rounding mode to apply
* @return a BigDecimal representation of this object
* @throws NullPointerException if roundingMode is null
*/
public BigDecimal toBigDecimal(int scale, RoundingMode roundingMode)
{
Preconditions.requireThat(roundingMode, "roundingMode").isNotNull();
if (isInteger())
return new BigDecimal(numerator);
return new BigDecimal(numerator).divide(new BigDecimal(denominator), scale, roundingMode);
}

@Override
public int intValue()
{
return (int) longValue();
}

@Override
public long longValue()
{
if (isInteger())
return numerator.longValue();
return numerator.divide(denominator).longValue();
}

@Override
public float floatValue()
{
return (float) doubleValue();
}

@Override
public double doubleValue()
{
if (isInteger())
return numerator.doubleValue();
return numerator.doubleValue() / denominator.doubleValue();
}

@Override
@SuppressWarnings("AccessingNonPublicFieldOfAnotherObject")
public boolean equals(Object o)
{
if (this == o)
return true;
if (!(o instanceof BigRational))
return false;
BigRational other = (BigRational) o;

return numerator.equals(other.denominator) && Objects.equals(denominator, other.denominator);
}

@Override
public int hashCode()
{
return Objects.hash(numerator, denominator);
}

/**
* Returns the String representation: {@code numerator / denominator}.
*/
@Override
public String toString()
{
if (isInteger())
return String.format("%,d", numerator);
return String.format("%,d / %,d", numerator, denominator);
}
}
``````

I'll third or fifth or whatever the recommendation for making your fraction immutable. I'd also recommend that you have it extend the Number class. I'd probably look at the Double class, since you're probably going to want to implement many of the same methods.

You should probably also implement Comparable<T> and Serializable since this behavior will probably be expected. Thus, you will need to implement compareTo(). You will also need to override equals() and I cannot stress strongly enough that you also override hashCode(). This might be one of the few cases though where you don't want compareTo() and equals() to be consistent since fractions reducable to each other are not necessarily equal.

Initial remark:

Never write this:

``````if ( condition ) statement;
``````

This is much better

``````if ( condition ) { statement };
``````

Just create to create a good habit.

By making the class immutable as suggested, you can also take advantage of the double to perform the equals and hashCode and compareTo operations

Here's my quick dirty version:

``````public final class Fraction implements Comparable {

private final int numerator;
private final int denominator;
private final Double internal;

public static Fraction createFraction( int numerator, int denominator ) {
return new Fraction( numerator, denominator );
}

private Fraction(int numerator, int denominator) {
this.numerator   = numerator;
this.denominator = denominator;
this.internal = ((double) numerator)/((double) denominator);
}

public int getNumerator() {
return this.numerator;
}

public int getDenominator() {
return this.denominator;
}

private double doubleValue() {
return internal;
}

public int compareTo( Object o ) {
if ( o instanceof Fraction ) {
return internal.compareTo( ((Fraction)o).internal );
}
return 1;
}

public boolean equals( Object o ) {
if ( o instanceof Fraction ) {
return this.internal.equals( ((Fraction)o).internal );
}
return false;
}

public int hashCode() {
return internal.hashCode();
}

public String toString() {
return String.format("%d/%d", numerator, denominator );
}

public static void main( String [] args ) {
System.out.println( Fraction.createFraction( 1 , 2 ) ) ;
System.out.println( Fraction.createFraction( 1 , 2 ).hashCode() ) ;
System.out.println( Fraction.createFraction( 1 , 2 ).compareTo( Fraction.createFraction(2,4) ) ) ;
System.out.println( Fraction.createFraction( 1 , 2 ).equals( Fraction.createFraction(4,8) ) ) ;
System.out.println( Fraction.createFraction( 3 , 9 ).equals( Fraction.createFraction(1,3) ) ) ;
}

}
``````

About the static factory method, it may be useful later, if you subclass the Fraction to handle more complex things, or if you decide to use a pool for the most frequently used objects.

It may not be the case, I just wanted to point it out. :)

See Effective Java first item.

Once you've created a fraction object why would you want to allow other objects to set the numerator or the denominator? I would think these should be read only. It makes the object immutable...

Also...setting the denominator to zero should throw an invalid argument exception (I don't know what it is in Java)

One very minor improvement could potentially be to save the double value that you're computing so that you only compute it on the first access. This won't be a big win unless you're accessing this number a lot, but it's not overly difficult to do, either.

One additional point might be the error checking you do in the denominator...you automatically change 0 to 1. Not sure if this is correct for your particular application, but in general if someone is trying to divide by 0, something is very wrong. I'd let this throw an exception (a specialized exception if you feel it's needed) rather than change the value in a seemingly arbitrary way that isn't known to the user.

In constrast with some other comments, about adding methods to add subtract, etc...since you didn't mention needing them, I'm assuming you don't. And unless you're building a library that is really going to be used in many places or by other people, go with YAGNI (you ain't going to need it, so it shouldn't be there.)

This function simplify using the eucledian algorithm is quite useful when defining fractions

`````` public Fraction simplify(){

int safe;
int h= Math.max(numerator, denominator);
int h2 = Math.min(denominator, numerator);

if (h == 0){

return new Fraction(1,1);
}

while (h>h2 && h2>0){

h = h - h2;
if (h>h2){

safe = h;
h = h2;
h2 = safe;

}

}

return new Fraction(numerator/h,denominator/h);

}
``````

Timothy Budd has a fine implementation of a Rational class in his "Data Structures in C++". Different language, of course, but it ports over to Java very nicely.

I'd recommend more constructors. A default constructor would have numerator 0, denominator 1. A single arg constructor would assume a denominator of 1. Think how your users might use this class.

No check for zero denominator? Programming by contract would have you add it.

You have a compareTo function already ... I would implement the Comparable interface.

May not really matter for whatever you're going to do with it though.

how I would improve that code:

1. a constructor based on String Fraction(String s) //expect "number/number"
2. a copy constructor Fraction(Fraction copy)
3. override the clone method
4. implements the equals, toString and hashcode methods
5. implements the interface java.io.Serializable, Comparable
6. a method "double getDoubleValue()"
8. I would make that class as immutable (no setters)

それを不変のタイプにしてください！ 端数の値は変更されません。たとえば、半分は3分の1になりません。 setDenominatorの代わりに、withDenominatorを使用して、同じ分子を持ち、指定された分母を持つ新しい分数を返すことができます。

equalsとhashcodeをオーバーライドすることも賢明です。そのため、マップやセットで使用できます。 Outlaw算術演算子や文字列の書式化についてのプログラマーの点も優れています。

まあ、1つは、私はセッターを取り除き、分数を不変にします。

おそらく、さまざまなString形式で表現を取得するための方法を追加したり、減算したりする方法が必要になるでしょう。

``````public class BigRational extends Number implements Comparable<BigRational>, Serializable {
public final static BigRational ZERO = new BigRational(BigInteger.ZERO, BigInteger.ONE);
private final static long serialVersionUID = 1099377265582986378L;

private final BigInteger numerator, denominator;

private BigRational(BigInteger numerator, BigInteger denominator) {
this.numerator = numerator;
this.denominator = denominator;
}

private static BigRational canonical(BigInteger numerator, BigInteger denominator, boolean checkGcd) {
if (denominator.signum() == 0) {
throw new IllegalArgumentException("denominator is zero");
}
if (numerator.signum() == 0) {
return ZERO;
}
if (denominator.signum() < 0) {
numerator = numerator.negate();
denominator = denominator.negate();
}
if (checkGcd) {
BigInteger gcd = numerator.gcd(denominator);
if (!gcd.equals(BigInteger.ONE)) {
numerator = numerator.divide(gcd);
denominator = denominator.divide(gcd);
}
}
return new BigRational(numerator, denominator);
}

public static BigRational getInstance(BigInteger numerator, BigInteger denominator) {
return canonical(numerator, denominator, true);
}

public static BigRational getInstance(long numerator, long denominator) {
return canonical(new BigInteger("" + numerator), new BigInteger("" + denominator), true);
}

public static BigRational getInstance(String numerator, String denominator) {
return canonical(new BigInteger(numerator), new BigInteger(denominator), true);
}

public static BigRational valueOf(String s) {
Pattern p = Pattern.compile("(-?\\d+)(?:.(\\d+)?)?0*(?:e(-?\\d+))?");
Matcher m = p.matcher(s);
if (!m.matches()) {
throw new IllegalArgumentException("Unknown format '" + s + "'");
}

// this translates 23.123e5 to 25,123 / 1000 * 10^5 = 2,512,300 / 1 (GCD)
String whole = m.group(1);
String decimal = m.group(2);
String exponent = m.group(3);
String n = whole;

// 23.123 => 23123
if (decimal != null) {
n += decimal;
}
BigInteger numerator = new BigInteger(n);

// exponent is an int because BigInteger.pow() takes an int argument
// it gets more difficult if exponent needs to be outside {-2 billion,2 billion}
int exp = exponent == null ? 0 : Integer.valueOf(exponent);
int decimalPlaces = decimal == null ? 0 : decimal.length();
exp -= decimalPlaces;
BigInteger denominator;
if (exp < 0) {
denominator = BigInteger.TEN.pow(-exp);
} else {
numerator = numerator.multiply(BigInteger.TEN.pow(exp));
denominator = BigInteger.ONE;
}

// done
return canonical(numerator, denominator, true);
}

// Comparable
public int compareTo(BigRational o) {
// note: this is a bit of cheat, relying on BigInteger.compareTo() returning
// -1, 0 or 1.  For the more general contract of compareTo(), you'd need to do
// more checking
if (numerator.signum() != o.numerator.signum()) {
return numerator.signum() - o.numerator.signum();
} else {
// oddly BigInteger has gcd() but no lcm()
BigInteger i1 = numerator.multiply(o.denominator);
BigInteger i2 = o.numerator.multiply(denominator);
return i1.compareTo(i2); // expensive!
}
}

if (o.numerator.signum() == 0) {
return this;
} else if (numerator.signum() == 0) {
return o;
} else if (denominator.equals(o.denominator)) {
} else {
}
}

public BigRational multiply(BigRational o) {
if (numerator.signum() == 0 || o.numerator.signum( )== 0) {
return ZERO;
} else if (numerator.equals(o.denominator)) {
return canonical(o.numerator, denominator, true);
} else if (o.numerator.equals(denominator)) {
return canonical(numerator, o.denominator, true);
} else if (numerator.negate().equals(o.denominator)) {
return canonical(o.numerator.negate(), denominator, true);
} else if (o.numerator.negate().equals(denominator)) {
return canonical(numerator.negate(), o.denominator, true);
} else {
return canonical(numerator.multiply(o.numerator), denominator.multiply(o.denominator), true);
}
}

public BigInteger getNumerator() { return numerator; }
public BigInteger getDenominator() { return denominator; }
public boolean isInteger() { return numerator.signum() == 0 || denominator.equals(BigInteger.ONE); }
public BigRational negate() { return new BigRational(numerator.negate(), denominator); }
public BigRational invert() { return canonical(denominator, numerator, false); }
public BigRational abs() { return numerator.signum() < 0 ? negate() : this; }
public BigRational pow(int exp) { return canonical(numerator.pow(exp), denominator.pow(exp), true); }
public BigRational subtract(BigRational o) { return add(o.negate()); }
public BigRational divide(BigRational o) { return multiply(o.invert()); }
public BigRational min(BigRational o) { return compareTo(o) <= 0 ? this : o; }
public BigRational max(BigRational o) { return compareTo(o) >= 0 ? this : o; }

public BigDecimal toBigDecimal(int scale, RoundingMode roundingMode) {
return isInteger() ? new BigDecimal(numerator) : new BigDecimal(numerator).divide(new BigDecimal(denominator), scale, roundingMode);
}

// Number
public int intValue() { return isInteger() ? numerator.intValue() : numerator.divide(denominator).intValue(); }
public long longValue() { return isInteger() ? numerator.longValue() : numerator.divide(denominator).longValue(); }
public float floatValue() { return (float)doubleValue(); }
public double doubleValue() { return isInteger() ? numerator.doubleValue() : numerator.doubleValue() / denominator.doubleValue(); }

@Override
public String toString() { return isInteger() ? String.format("%,d", numerator) : String.format("%,d / %,d", numerator, denominator); }

@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;

BigRational that = (BigRational) o;

if (denominator != null ? !denominator.equals(that.denominator) : that.denominator != null) return false;
if (numerator != null ? !numerator.equals(that.numerator) : that.numerator != null) return false;

return true;
}

@Override
public int hashCode() {
int result = numerator != null ? numerator.hashCode() : 0;
result = 31 * result + (denominator != null ? denominator.hashCode() : 0);
return result;
}

public static void main(String args[]) {
BigRational r1 = BigRational.valueOf("3.14e4");
BigRational r2 = BigRational.getInstance(111, 7);
dump("r1", r1);
dump("r2", r2);
dump("r1 - r2", r1.subtract(r2));
dump("r1 * r2", r1.multiply(r2));
dump("r1 / r2", r1.divide(r2));
dump("r2 ^ 2", r2.pow(2));
}

public static void dump(String name, BigRational r) {
System.out.printf("%s = %s%n", name, r);
System.out.printf("%s.negate() = %s%n", name, r.negate());
System.out.printf("%s.invert() = %s%n", name, r.invert());
System.out.printf("%s.intValue() = %,d%n", name, r.intValue());
System.out.printf("%s.longValue() = %,d%n", name, r.longValue());
System.out.printf("%s.floatValue() = %,f%n", name, r.floatValue());
System.out.printf("%s.doubleValue() = %,f%n", name, r.doubleValue());
System.out.println();
}
}
``````

``````r1 = 31,400
r1.negate() = -31,400
r1.invert() = 1 / 31,400
r1.intValue() = 31,400
r1.longValue() = 31,400
r1.floatValue() = 31,400.000000
r1.doubleValue() = 31,400.000000

r2 = 111 / 7
r2.negate() = -111 / 7
r2.invert() = 7 / 111
r2.intValue() = 15
r2.longValue() = 15
r2.floatValue() = 15.857142
r2.doubleValue() = 15.857143

r1 + r2 = 219,911 / 7
r1 + r2.negate() = -219,911 / 7
r1 + r2.invert() = 7 / 219,911
r1 + r2.intValue() = 31,415
r1 + r2.longValue() = 31,415
r1 + r2.floatValue() = 31,415.857422
r1 + r2.doubleValue() = 31,415.857143

r1 - r2 = 219,689 / 7
r1 - r2.negate() = -219,689 / 7
r1 - r2.invert() = 7 / 219,689
r1 - r2.intValue() = 31,384
r1 - r2.longValue() = 31,384
r1 - r2.floatValue() = 31,384.142578
r1 - r2.doubleValue() = 31,384.142857

r1 * r2 = 3,485,400 / 7
r1 * r2.negate() = -3,485,400 / 7
r1 * r2.invert() = 7 / 3,485,400
r1 * r2.intValue() = 497,914
r1 * r2.longValue() = 497,914
r1 * r2.floatValue() = 497,914.281250
r1 * r2.doubleValue() = 497,914.285714

r1 / r2 = 219,800 / 111
r1 / r2.negate() = -219,800 / 111
r1 / r2.invert() = 111 / 219,800
r1 / r2.intValue() = 1,980
r1 / r2.longValue() = 1,980
r1 / r2.floatValue() = 1,980.180176
r1 / r2.doubleValue() = 1,980.180180

r2 ^ 2 = 12,321 / 49
r2 ^ 2.negate() = -12,321 / 49
r2 ^ 2.invert() = 49 / 12,321
r2 ^ 2.intValue() = 251
r2 ^ 2.longValue() = 251
r2 ^ 2.floatValue() = 251.448975
r2 ^ 2.doubleValue() = 251.448980
``````