BigFraction (Apache Commons Numbers Fraction 1.0-beta1 API)

java.lang.Object
- java.lang.Number
- - org.apache.commons.numbers.fraction.BigFraction

All Implemented Interfaces:

Serializable, Comparable<BigFraction>, Addition<BigFraction>, Multiplication<BigFraction>, NativeOperators<BigFraction>
```
public final class BigFraction
extends Number
implements Comparable<BigFraction>, NativeOperators<BigFraction>, Serializable
```
Representation of a rational number without any overflow. This class is immutable.

See Also:

Serialized Form

Field Summary

Fields
Modifier and Type Field and Description

static BigFraction ONE
A fraction representing "1".

static BigFraction ZERO
A fraction representing "0".

Fields
Modifier and Type	Field and Description
`static BigFraction`	`ONE` A fraction representing "1".
`static BigFraction`	`ZERO` A fraction representing "0".

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`BigFraction`	`abs()` Returns the absolute value of this `BigFraction`.
`BigFraction`	`add(BigFraction fraction)` Adds the value of this fraction to another, returning the result in reduced form.
`BigFraction`	`add(BigInteger bg)` Adds the value of this fraction to the passed `BigInteger`, returning the result in reduced form.
`BigFraction`	`add(int i)` Adds the value of this fraction to the passed `integer`, returning the result in reduced form.
`BigFraction`	`add(long l)` Adds the value of this fraction to the passed `long`, returning the result in reduced form.
`BigDecimal`	`bigDecimalValue()` Gets the fraction as a `BigDecimal`.
`BigDecimal`	`bigDecimalValue(int scale, RoundingMode roundingMode)` Gets the fraction as a `BigDecimal` following the passed scale and rounding mode.
`BigDecimal`	`bigDecimalValue(RoundingMode roundingMode)` Gets the fraction as a `BigDecimal` following the passed rounding mode.
`int`	`compareTo(BigFraction other)` Compares this object to another based on size.
`BigFraction`	`divide(BigFraction fraction)` Divide the value of this fraction by another, returning the result in reduced form.
`BigFraction`	`divide(BigInteger bg)` Divide the value of this fraction by the passed `BigInteger`, ie `this * 1 / bg`, returning the result in reduced form.
`BigFraction`	`divide(int i)` Divide the value of this fraction by the passed `int`, ie `this * 1 / i`, returning the result in reduced form.
`BigFraction`	`divide(long l)` Divide the value of this fraction by the passed `long`, ie `this * 1 / l`, returning the result in reduced form.
`double`	`doubleValue()` Gets the fraction as a `double`.
`boolean`	`equals(Object other)` Test for the equality of two fractions.
`float`	`floatValue()` Gets the fraction as a `float`.
`static BigFraction`	`from(double value)` Create a fraction given the double value.
`static BigFraction`	`from(double value, double epsilon, int maxIterations)` Create a fraction given the double value and maximum error allowed.
`static BigFraction`	`from(double value, int maxDenominator)` Create a fraction given the double value and maximum denominator.
`BigInteger`	`getDenominator()` Access the denominator as a `BigInteger`.
`int`	`getDenominatorAsInt()` Access the denominator as a `int`.
`long`	`getDenominatorAsLong()` Access the denominator as a `long`.
`BigInteger`	`getNumerator()` Access the numerator as a `BigInteger`.
`int`	`getNumeratorAsInt()` Access the numerator as a `int`.
`long`	`getNumeratorAsLong()` Access the numerator as a `long`.
`int`	`hashCode()` Gets a hashCode for the fraction.
`int`	`intValue()` Gets the fraction as an `int`.
`long`	`longValue()` Gets the fraction as a `long`.
`BigFraction`	`multiply(BigFraction fraction)` Multiplies the value of this fraction by another, returning the result in reduced form.
`BigFraction`	`multiply(BigInteger bg)` Multiplies the value of this fraction by the passed `BigInteger`, returning the result in reduced form.
`BigFraction`	`multiply(int i)` Multiply the value of this fraction by the passed `int`, returning the result in reduced form.
`BigFraction`	`multiply(long l)` Multiply the value of this fraction by the passed `long`, returning the result in reduced form.
`BigFraction`	`negate()` Return the additive inverse of this fraction, returning the result in reduced form.
`static BigFraction`	`of(BigInteger num)` Create a `BigFraction` equivalent to the passed `BigInteger`, ie "num / 1".
`static BigFraction`	`of(BigInteger num, BigInteger den)` Create a `BigFraction` given the numerator and denominator as `BigInteger`.
`static BigFraction`	`of(int num)` Create a `BigFraction` equivalent to the passed `int`, ie "num / 1".
`static BigFraction`	`of(int num, int den)` Create a `BigFraction` given the numerator and denominator as simple `int`.
`static BigFraction`	`of(long num)` Create a `BigFraction` equivalent to the passed long, ie "num / 1".
`static BigFraction`	`of(long num, long den)` Create a `BigFraction` given the numerator and denominator as simple `long`.
`BigFraction`	`one()`
`static BigFraction`	`parse(String s)` Parses a string that would be produced by `toString()` and instantiates the corresponding object.
`BigFraction`	`pow(BigInteger exponent)` Returns a `BigFraction` whose value is \(\mathit{this}^{\mathit{exponent}}\), returning the result in reduced form.
`double`	`pow(double exponent)` Returns a `double` whose value is \(\mathit{this}^{\mathit{exponent}}\), returning the result in reduced form.
`BigFraction`	`pow(int exponent)` Returns a `BigFraction` whose value is `(this<sup>exponent</sup>)`, returning the result in reduced form.
`BigFraction`	`pow(long exponent)` Returns a `BigFraction` whose value is \(\mathit{this}^{\mathit{exponent}}\), returning the result in reduced form.
`BigFraction`	`reciprocal()` Return the multiplicative inverse of this fraction.
`int`	`signum()` Retrieves the sign of this fraction.
`BigFraction`	`subtract(BigFraction fraction)` Subtracts the value of another fraction from the value of this one, returning the result in reduced form.
`BigFraction`	`subtract(BigInteger bg)` Subtracts the value of an `BigInteger` from the value of this `BigFraction`, returning the result in reduced form.
`BigFraction`	`subtract(int i)` Subtracts the value of an `integer` from the value of this `BigFraction`, returning the result in reduced form.
`BigFraction`	`subtract(long l)` Subtracts the value of a `long` from the value of this `BigFraction`, returning the result in reduced form.
`String`	`toString()` Returns the `String` representing this fraction, ie "num / dem" or just "num" if the denominator is one.
`BigFraction`	`zero()`

Methods inherited from class java.lang.Number
byteValue, shortValue

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - ZERO
```
public static final BigFraction ZERO
```
    A fraction representing "0".
  - ONE
```
public static final BigFraction ONE
```
    A fraction representing "1".
- Method Detail
  - of
```
public static BigFraction of(BigInteger num)
```
    Create a BigFraction equivalent to the passed BigInteger, ie "num / 1".
    
    Parameters:
    
    num - the numerator.
    
    Returns:
    
    a new instance.
  - of
```
public static BigFraction of(BigInteger num,
                             BigInteger den)
```
    Create a BigFraction given the numerator and denominator as BigInteger. The BigFraction is reduced to lowest terms.
    
    Parameters:
    
    num - the numerator, must not be null.
    
    den - the denominator, must not be null.
    
    Returns:
    
    a new instance.
    
    Throws:
    
    ArithmeticException - if the denominator is zero.
  - from
```
public static BigFraction from(double value)
```
    Create a fraction given the double value.
    This factory method behaves differently from from(double, double, int). It converts the double value exactly, considering its internal bits representation. This works for all values except NaN and infinities and does not requires any loop or convergence threshold.
    
    Since this conversion is exact and since double numbers are sometimes approximated, the fraction created may seem strange in some cases. For example, calling from(1.0 / 3.0) does not create the fraction \( \frac{1}{3} \), but the fraction \( \frac{6004799503160661}{18014398509481984} \) because the double number passed to the method is not exactly \( \frac{1}{3} \) (which cannot be represented exactly in IEEE754).
    
    Parameters:
    
    value - Value to convert to a fraction.
    
    Returns:
    
    a new instance.
    
    Throws:
    
    IllegalArgumentException - if the given value is NaN or infinite.
    
    See Also:
    
    from(double,double,int)
  - from
```
public static BigFraction from(double value,
                               double epsilon,
                               int maxIterations)
```
    Create a fraction given the double value and maximum error allowed.
    References:
    - Continued Fraction equations (11) and (22)-(26)
    Parameters:
    
    value - Value to convert to a fraction.
    
    epsilon - Maximum error allowed. The resulting fraction is within epsilon of value, in absolute terms.
    
    maxIterations - Maximum number of convergents.
    
    Returns:
    
    a new instance.
    
    Throws:
    
    ArithmeticException - if the continued fraction failed to converge.
    
    See Also:
    
    from(double,int)
  - from
```
public static BigFraction from(double value,
                               int maxDenominator)
```
    Create a fraction given the double value and maximum denominator.
    References:
    - Continued Fraction equations (11) and (22)-(26)
    Parameters:
    
    value - Value to convert to a fraction.
    
    maxDenominator - Maximum allowed value for denominator.
    
    Returns:
    
    a new instance.
    
    Throws:
    
    ArithmeticException - if the continued fraction failed to converge.
    
    See Also:
    
    from(double,double,int)
  - of
```
public static BigFraction of(int num)
```
    Create a BigFraction equivalent to the passed int, ie "num / 1".
    
    Parameters:
    
    num - the numerator.
    
    Returns:
    
    a new instance.
  - of
```
public static BigFraction of(int num,
                             int den)
```
    Create a BigFraction given the numerator and denominator as simple int. The BigFraction is reduced to lowest terms.
    
    Parameters:
    
    num - the numerator.
    
    den - the denominator.
    
    Returns:
    
    a new instance.
    
    Throws:
    
    ArithmeticException - if den is zero.
  - of
```
public static BigFraction of(long num)
```
    Create a BigFraction equivalent to the passed long, ie "num / 1".
    
    Parameters:
    
    num - the numerator.
    
    Returns:
    
    a new instance.
  - of
```
public static BigFraction of(long num,
                             long den)
```
    Create a BigFraction given the numerator and denominator as simple long. The BigFraction is reduced to lowest terms.
    
    Parameters:
    
    num - the numerator.
    
    den - the denominator.
    
    Returns:
    
    a new instance.
    
    Throws:
    
    ArithmeticException - if den is zero.
  - abs
```
public BigFraction abs()
```
    Returns the absolute value of this BigFraction.
    
    Returns:
    
    the absolute value as a BigFraction.
  - add
```
public BigFraction add(BigInteger bg)
```
    Adds the value of this fraction to the passed BigInteger, returning the result in reduced form.
    
    Parameters:
    
    bg - the BigInteger to add, must'nt be null.
    
    Returns:
    
    a BigFraction instance with the resulting values.
  - add
```
public BigFraction add(int i)
```
    Adds the value of this fraction to the passed integer, returning the result in reduced form.
    
    Parameters:
    
    i - the integer to add.
    
    Returns:
    
    a BigFraction instance with the resulting values.
  - add
```
public BigFraction add(long l)
```
    Adds the value of this fraction to the passed long, returning the result in reduced form.
    
    Parameters:
    
    l - the long to add.
    
    Returns:
    
    a BigFraction instance with the resulting values.
  - add
```
public BigFraction add(BigFraction fraction)
```
    Adds the value of this fraction to another, returning the result in reduced form.
    
    Specified by:
    
    add in interface Addition<BigFraction>
    
    Parameters:
    
    fraction - the BigFraction to add, must not be null.
    
    Returns:
    
    a BigFraction instance with the resulting values.
  - bigDecimalValue
```
public BigDecimal bigDecimalValue()
```
    Gets the fraction as a BigDecimal. This calculates the fraction as the numerator divided by denominator.
    
    Returns:
    
    the fraction as a BigDecimal.
    
    Throws:
    
    ArithmeticException - if the exact quotient does not have a terminating decimal expansion.
    
    See Also:
    
    BigDecimal
  - bigDecimalValue
```
public BigDecimal bigDecimalValue(RoundingMode roundingMode)
```
    Gets the fraction as a BigDecimal following the passed rounding mode. This calculates the fraction as the numerator divided by denominator.
    
    Parameters:
    
    roundingMode - Rounding mode to apply.
    
    Returns:
    
    the fraction as a BigDecimal.
    
    See Also:
    
    BigDecimal
  - bigDecimalValue
```
public BigDecimal bigDecimalValue(int scale,
                                  RoundingMode roundingMode)
```
    Gets the fraction as a BigDecimal following the passed scale and rounding mode. This calculates the fraction as the numerator divided by denominator.
    
    Parameters:
    
    scale - scale of the BigDecimal quotient to be returned. see BigDecimal for more information.
    
    roundingMode - Rounding mode to apply.
    
    Returns:
    
    the fraction as a BigDecimal.
    
    Throws:
    
    ArithmeticException - if roundingMode == RoundingMode.UNNECESSARY and the specified scale is insufficient to represent the result of the division exactly.
    
    See Also:
    
    BigDecimal
  - compareTo
```
public int compareTo(BigFraction other)
```
    Compares this object to another based on size.
    
    Specified by:
    
    compareTo in interface Comparable<BigFraction>
    
    Parameters:
    
    other - Object to compare to, must not be null.
    
    Returns:
    
    -1 if this is less than object, +1 if this is greater than object, 0 if they are equal.
    
    See Also:
    
    Comparable.compareTo(Object)
  - divide
```
public BigFraction divide(BigInteger bg)
```
    Divide the value of this fraction by the passed BigInteger, ie this * 1 / bg, returning the result in reduced form.
    
    Parameters:
    
    bg - the BigInteger to divide by, must not be null
    
    Returns:
    
    a BigFraction instance with the resulting values
    
    Throws:
    
    ArithmeticException - if the value to divide by is zero
  - divide
```
public BigFraction divide(int i)
```
    Divide the value of this fraction by the passed int, ie this * 1 / i, returning the result in reduced form.
    
    Parameters:
    
    i - the int to divide by
    
    Returns:
    
    a BigFraction instance with the resulting values
    
    Throws:
    
    ArithmeticException - if the value to divide by is zero
  - divide
```
public BigFraction divide(long l)
```
    Divide the value of this fraction by the passed long, ie this * 1 / l, returning the result in reduced form.
    
    Parameters:
    
    l - the long to divide by
    
    Returns:
    
    a BigFraction instance with the resulting values
    
    Throws:
    
    ArithmeticException - if the value to divide by is zero
  - divide
```
public BigFraction divide(BigFraction fraction)
```
    Divide the value of this fraction by another, returning the result in reduced form.
    
    Specified by:
    
    divide in interface NativeOperators<BigFraction>
    
    Parameters:
    
    fraction - Fraction to divide by, must not be null.
    
    Returns:
    
    a BigFraction instance with the resulting values.
    
    Throws:
    
    ArithmeticException - if the fraction to divide by is zero
  - doubleValue
```
public double doubleValue()
```
    Gets the fraction as a double. This calculates the fraction as the numerator divided by denominator.
    
    Specified by:
    
    doubleValue in class Number
    
    Returns:
    
    the fraction as a double
    
    See Also:
    
    Number.doubleValue()
  - equals
```
public boolean equals(Object other)
```
    Test for the equality of two fractions. If the lowest term numerator and denominators are the same for both fractions, the two fractions are considered to be equal.
    
    Overrides:
    
    equals in class Object
    
    Parameters:
    
    other - fraction to test for equality to this fraction, can be null.
    
    Returns:
    
    true if two fractions are equal, false if object is null, not an instance of BigFraction, or not equal to this fraction instance.
    
    See Also:
    
    Object.equals(java.lang.Object)
  - floatValue
```
public float floatValue()
```
    Gets the fraction as a float. This calculates the fraction as the numerator divided by denominator.
    
    Specified by:
    
    floatValue in class Number
    
    Returns:
    
    the fraction as a float.
    
    See Also:
    
    Number.floatValue()
  - getDenominator
```
public BigInteger getDenominator()
```
    Access the denominator as a BigInteger.
    
    Returns:
    
    the denominator as a BigInteger.
  - getDenominatorAsInt
```
public int getDenominatorAsInt()
```
    Access the denominator as a int.
    
    Returns:
    
    the denominator as a int.
  - getDenominatorAsLong
```
public long getDenominatorAsLong()
```
    Access the denominator as a long.
    
    Returns:
    
    the denominator as a long.
  - getNumerator
```
public BigInteger getNumerator()
```
    Access the numerator as a BigInteger.
    
    Returns:
    
    the numerator as a BigInteger.
  - getNumeratorAsInt
```
public int getNumeratorAsInt()
```
    Access the numerator as a int.
    
    Returns:
    
    the numerator as a int.
  - getNumeratorAsLong
```
public long getNumeratorAsLong()
```
    Access the numerator as a long.
    
    Returns:
    
    the numerator as a long.
  - hashCode
```
public int hashCode()
```
    Gets a hashCode for the fraction.
    
    Overrides:
    
    hashCode in class Object
    
    Returns:
    
    a hash code value for this object.
    
    See Also:
    
    Object.hashCode()
  - intValue
```
public int intValue()
```
    Gets the fraction as an int. This returns the whole number part of the fraction.
    
    Specified by:
    
    intValue in class Number
    
    Returns:
    
    the whole number fraction part.
    
    See Also:
    
    Number.intValue()
  - longValue
```
public long longValue()
```
    Gets the fraction as a long. This returns the whole number part of the fraction.
    
    Specified by:
    
    longValue in class Number
    
    Returns:
    
    the whole number fraction part.
    
    See Also:
    
    Number.longValue()
  - multiply
```
public BigFraction multiply(BigInteger bg)
```
    Multiplies the value of this fraction by the passed BigInteger, returning the result in reduced form.
    
    Parameters:
    
    bg - the BigInteger to multiply by.
    
    Returns:
    
    a BigFraction instance with the resulting values.
  - multiply
```
public BigFraction multiply(int i)
```
    Multiply the value of this fraction by the passed int, returning the result in reduced form.
    
    Specified by:
    
    multiply in interface NativeOperators<BigFraction>
    
    Parameters:
    
    i - the int to multiply by.
    
    Returns:
    
    a BigFraction instance with the resulting values.
  - multiply
```
public BigFraction multiply(long l)
```
    Multiply the value of this fraction by the passed long, returning the result in reduced form.
    
    Parameters:
    
    l - the long to multiply by.
    
    Returns:
    
    a BigFraction instance with the resulting values.
  - multiply
```
public BigFraction multiply(BigFraction fraction)
```
    Multiplies the value of this fraction by another, returning the result in reduced form.
    
    Specified by:
    
    multiply in interface Multiplication<BigFraction>
    
    Parameters:
    
    fraction - Fraction to multiply by, must not be null.
    
    Returns:
    
    a BigFraction instance with the resulting values.
  - signum
```
public int signum()
```
    Retrieves the sign of this fraction.
    
    Returns:
    
    -1 if the value is strictly negative, 1 if it is strictly positive, 0 if it is 0.
  - negate
```
public BigFraction negate()
```
    Return the additive inverse of this fraction, returning the result in reduced form.
    
    Specified by:
    
    negate in interface Addition<BigFraction>
    
    Returns:
    
    the negation of this fraction.
  - pow
```
public BigFraction pow(int exponent)
```
    Returns a BigFraction whose value is (this<sup>exponent</sup>), returning the result in reduced form.
    
    Specified by:
    
    pow in interface NativeOperators<BigFraction>
    
    Parameters:
    
    exponent - exponent to which this BigFraction is to be raised.
    
    Returns:
    
    \(\mathit{this}^{\mathit{exponent}}\).
  - pow
```
public BigFraction pow(long exponent)
```
    Returns a BigFraction whose value is \(\mathit{this}^{\mathit{exponent}}\), returning the result in reduced form.
    
    Parameters:
    
    exponent - exponent to which this BigFraction is to be raised.
    
    Returns:
    
    \(\mathit{this}^{\mathit{exponent}}\) as a BigFraction.
  - pow
```
public BigFraction pow(BigInteger exponent)
```
    Returns a BigFraction whose value is \(\mathit{this}^{\mathit{exponent}}\), returning the result in reduced form.
    
    Parameters:
    
    exponent - exponent to which this BigFraction is to be raised.
    
    Returns:
    
    \(\mathit{this}^{\mathit{exponent}}\) as a BigFraction.
  - pow
```
public double pow(double exponent)
```
    Returns a double whose value is \(\mathit{this}^{\mathit{exponent}}\), returning the result in reduced form.
    
    Parameters:
    
    exponent - exponent to which this BigFraction is to be raised.
    
    Returns:
    
    \(\mathit{this}^{\mathit{exponent}}\).
  - reciprocal
```
public BigFraction reciprocal()
```
    Return the multiplicative inverse of this fraction.
    
    Specified by:
    
    reciprocal in interface Multiplication<BigFraction>
    
    Returns:
    
    the reciprocal fraction.
  - subtract
```
public BigFraction subtract(BigInteger bg)
```
    Subtracts the value of an BigInteger from the value of this BigFraction, returning the result in reduced form.
    
    Parameters:
    
    bg - the BigInteger to subtract, cannot be null.
    
    Returns:
    
    a BigFraction instance with the resulting values.
  - subtract
```
public BigFraction subtract(int i)
```
    Subtracts the value of an integer from the value of this BigFraction, returning the result in reduced form.
    
    Parameters:
    
    i - the integer to subtract.
    
    Returns:
    
    a BigFraction instance with the resulting values.
  - subtract
```
public BigFraction subtract(long l)
```
    Subtracts the value of a long from the value of this BigFraction, returning the result in reduced form.
    
    Parameters:
    
    l - the long to subtract.
    
    Returns:
    
    a BigFraction instance with the resulting values.
  - subtract
```
public BigFraction subtract(BigFraction fraction)
```
    Subtracts the value of another fraction from the value of this one, returning the result in reduced form.
    
    Specified by:
    
    subtract in interface NativeOperators<BigFraction>
    
    Parameters:
    
    fraction - BigFraction to subtract, must not be null.
    
    Returns:
    
    a BigFraction instance with the resulting values
  - toString
```
public String toString()
```
    Returns the String representing this fraction, ie "num / dem" or just "num" if the denominator is one.
    
    Overrides:
    
    toString in class Object
    
    Returns:
    
    a string representation of the fraction.
    
    See Also:
    
    Object.toString()
  - zero
```
public BigFraction zero()
```
    Specified by:
    
    zero in interface Addition<BigFraction>
  - one
```
public BigFraction one()
```
    Specified by:
    
    one in interface Multiplication<BigFraction>
  - parse
```
public static BigFraction parse(String s)
```
    Parses a string that would be produced by toString() and instantiates the corresponding object.
    
    Parameters:
    
    s - String representation.
    
    Returns:
    
    an instance.
    
    Throws:
    
    NumberFormatException - if the string does not conform to the specification.

Class BigFraction

Field Summary

Method Summary

Methods inherited from class java.lang.Number

Methods inherited from class java.lang.Object

Field Detail

ZERO

ONE

Method Detail

of

of

from

from

from

of

of

of

of

abs

add

add

add

add

bigDecimalValue

bigDecimalValue

bigDecimalValue

compareTo

divide

divide

divide

divide

doubleValue

equals

floatValue

getDenominator

getDenominatorAsInt

getDenominatorAsLong

getNumerator

getNumeratorAsInt

getNumeratorAsLong

hashCode

intValue

longValue

multiply

multiply

multiply

multiply

signum

negate

pow

pow

pow

pow

reciprocal

subtract

subtract

subtract

subtract

toString

zero

one

parse