/*
    * 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
    *
    *      https://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.
   */
  
  /*
   * This is not the original file distributed by the Apache Software Foundation
   * It has been modified by the Hipparchus project
   */
  package org.hipparchus.fraction;
  
  import java.io.Serializable;
  import java.math.BigDecimal;
  import java.math.BigInteger;
  import java.math.RoundingMode;
  import java.util.function.Function;
  import java.util.stream.Stream;
  
  import org.hipparchus.FieldElement;
  import org.hipparchus.exception.LocalizedCoreFormats;
  import org.hipparchus.exception.MathIllegalArgumentException;
  import org.hipparchus.exception.MathIllegalStateException;
  import org.hipparchus.exception.MathRuntimeException;
  import org.hipparchus.exception.NullArgumentException;
  import org.hipparchus.fraction.ConvergentsIterator.ConvergenceStep;
  import org.hipparchus.util.ArithmeticUtils;
  import org.hipparchus.util.FastMath;
  import org.hipparchus.util.MathUtils;
  import org.hipparchus.util.Pair;
  import org.hipparchus.util.Precision;
  
  /**
   * Representation of a rational number without any overflow. This class is
   * immutable.
   *
   */
  public class BigFraction
      extends Number
      implements FieldElement<BigFraction>, Comparable<BigFraction>, Serializable {
  
      /** A fraction representing "2 / 1". */
      public static final BigFraction TWO = new BigFraction(2);
  
      /** A fraction representing "1". */
      public static final BigFraction ONE = new BigFraction(1);
  
      /** A fraction representing "0". */
      public static final BigFraction ZERO = new BigFraction(0);
  
      /** A fraction representing "-1 / 1". */
      public static final BigFraction MINUS_ONE = new BigFraction(-1);
  
      /** A fraction representing "4/5". */
      public static final BigFraction FOUR_FIFTHS = new BigFraction(4, 5);
  
      /** A fraction representing "1/5". */
      public static final BigFraction ONE_FIFTH = new BigFraction(1, 5);
  
      /** A fraction representing "1/2". */
      public static final BigFraction ONE_HALF = new BigFraction(1, 2);
  
      /** A fraction representing "1/4". */
      public static final BigFraction ONE_QUARTER = new BigFraction(1, 4);
  
      /** A fraction representing "1/3". */
      public static final BigFraction ONE_THIRD = new BigFraction(1, 3);
  
      /** A fraction representing "3/5". */
      public static final BigFraction THREE_FIFTHS = new BigFraction(3, 5);
  
      /** A fraction representing "3/4". */
      public static final BigFraction THREE_QUARTERS = new BigFraction(3, 4);
  
      /** A fraction representing "2/5". */
      public static final BigFraction TWO_FIFTHS = new BigFraction(2, 5);
  
      /** A fraction representing "2/4". */
      public static final BigFraction TWO_QUARTERS = new BigFraction(2, 4);
  
      /** A fraction representing "2/3". */
      public static final BigFraction TWO_THIRDS = new BigFraction(2, 3);
  
      /** Serializable version identifier. */
      private static final long serialVersionUID = -5630213147331578515L;
  
      /** <code>BigInteger</code> representation of 100. */
      private static final BigInteger ONE_HUNDRED = BigInteger.valueOf(100);
 
     /** Convert a convergence step to the corresponding double fraction. */
     private static final Function<ConvergenceStep, BigFraction> STEP_TO_FRACTION = //
             s -> new BigFraction(s.getNumerator(), s.getDenominator());
 
     /** The numerator. */
     private final BigInteger numerator;
 
     /** The denominator. */
     private final BigInteger denominator;
 
     /**
      * <p>
      * Create a {@link BigFraction} equivalent to the passed {@code BigInteger}, ie
      * "num / 1".
      * </p>
      *
      * @param num
      *            the numerator.
      */
     public BigFraction(final BigInteger num) {
         this(num, BigInteger.ONE);
     }
 
     /**
      * Create a {@link BigFraction} given the numerator and denominator as
      * {@code BigInteger}. The {@link BigFraction} is reduced to lowest terms.
      *
      * @param num the numerator, must not be {@code null}.
      * @param den the denominator, must not be {@code null}.
      * @throws MathIllegalArgumentException if the denominator is zero.
      * @throws NullArgumentException if either of the arguments is null
      */
     public BigFraction(BigInteger num, BigInteger den) {
         MathUtils.checkNotNull(num, LocalizedCoreFormats.NUMERATOR);
         MathUtils.checkNotNull(den, LocalizedCoreFormats.DENOMINATOR);
         if (den.signum() == 0) {
             throw new MathIllegalArgumentException(LocalizedCoreFormats.ZERO_DENOMINATOR);
         }
         if (num.signum() == 0) {
             numerator   = BigInteger.ZERO;
             denominator = BigInteger.ONE;
         } else {
 
             // reduce numerator and denominator by greatest common denominator
             final BigInteger gcd = num.gcd(den);
             if (BigInteger.ONE.compareTo(gcd) < 0) {
                 num = num.divide(gcd);
                 den = den.divide(gcd);
             }
 
             // move sign to numerator
             if (den.signum() == -1) {
                 num = num.negate();
                 den = den.negate();
             }
 
             // store the values in the final fields
             numerator   = num;
             denominator = den;
 
         }
     }
 
     /**
      * Create a fraction given the double value.
      * <p>
      * This constructor behaves <em>differently</em> from
      * {@link #BigFraction(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.
      * </p>
      * <p>
      * Since this conversion is exact and since double numbers are sometimes
      * approximated, the fraction created may seem strange in some cases. For example,
      * calling <code>new BigFraction(1.0 / 3.0)</code> does <em>not</em> create
      * the fraction 1/3, but the fraction 6004799503160661 / 18014398509481984
      * because the double number passed to the constructor is not exactly 1/3
      * (this number cannot be stored exactly in IEEE754).
      * </p>
      * @see #BigFraction(double, double, int)
      * @param value the double value to convert to a fraction.
      * @exception MathIllegalArgumentException if value is NaN or infinite
      */
     public BigFraction(final double value) throws MathIllegalArgumentException {
         if (Double.isNaN(value)) {
             throw new MathIllegalArgumentException(LocalizedCoreFormats.NAN_VALUE_CONVERSION);
         }
         if (Double.isInfinite(value)) {
             throw new MathIllegalArgumentException(LocalizedCoreFormats.INFINITE_VALUE_CONVERSION);
         }
 
         // compute m and k such that value = m * 2^k
         final long bits     = Double.doubleToLongBits(value);
         final long sign     = bits & 0x8000000000000000L;
         final long exponent = bits & 0x7ff0000000000000L;
         long m              = bits & 0x000fffffffffffffL;
         if (exponent != 0) {
             // this was a normalized number, add the implicit most significant bit
             m |= 0x0010000000000000L;
         }
         if (sign != 0) {
             m = -m;
         }
         int k = ((int) (exponent >> 52)) - 1075;
         while (((m & 0x001ffffffffffffeL) != 0) && ((m & 0x1) == 0)) {
             m >>= 1;
             ++k;
         }
 
         if (k < 0) {
             numerator   = BigInteger.valueOf(m);
             denominator = BigInteger.ZERO.flipBit(-k);
         } else {
             numerator   = BigInteger.valueOf(m).multiply(BigInteger.ZERO.flipBit(k));
             denominator = BigInteger.ONE;
         }
 
     }
 
     /**
      * Create a fraction given the double value and maximum error allowed.
      * <p>* References:</p>
      * <ul>
      * <li><a href="http://mathworld.wolfram.com/ContinuedFraction.html">
      * Continued Fraction</a> equations (11) and (22)-(26)</li>
      * </ul>
      *
      * @param value
      *            the double value to convert to a fraction.
      * @param epsilon
      *            maximum error allowed. The resulting fraction is within
      *            <code>epsilon</code> of <code>value</code>, in absolute terms.
      * @param maxIterations
      *            maximum number of convergents.
      * @throws MathIllegalStateException
      *             if the continued fraction failed to converge.
      * @see #BigFraction(double)
      */
     public BigFraction(final double value, final double epsilon,
                        final int maxIterations)
         throws MathIllegalStateException {
         ConvergenceStep converged = ConvergentsIterator.convergent(value, maxIterations, s -> {
             final double quotient = s.getFractionValue();
             return Precision.equals(quotient, value, 1) || FastMath.abs(quotient - value) < epsilon;
         }).getKey();
         if (FastMath.abs(converged.getFractionValue() - value) < epsilon) {
             this.numerator = BigInteger.valueOf(converged.getNumerator());
             this.denominator = BigInteger.valueOf(converged.getDenominator());
         } else {
             throw new MathIllegalStateException(LocalizedCoreFormats.FAILED_FRACTION_CONVERSION,
                                                 value, maxIterations);
         }
     }
 
     /**
      * Create a fraction given the double value and maximum denominator.
      * <p>* References:</p>
      * <ul>
      * <li><a href="http://mathworld.wolfram.com/ContinuedFraction.html">
      * Continued Fraction</a> equations (11) and (22)-(26)</li>
      * </ul>
      *
      * @param value
      *            the double value to convert to a fraction.
      * @param maxDenominator
      *            The maximum allowed value for denominator.
      * @throws MathIllegalStateException
      *             if the continued fraction failed to converge.
      */
     public BigFraction(final double value, final long maxDenominator)
         throws MathIllegalStateException {
         final int maxIterations = 100;
         ConvergenceStep[] lastValid = new ConvergenceStep[1];
         ConvergentsIterator.convergent(value, maxIterations, s -> {
             if (s.getDenominator() < maxDenominator) {
                 lastValid[0] = s;
             }
             return Precision.equals(s.getFractionValue(), value, 1);
         });
         if (lastValid[0] != null) {
             this.numerator   = BigInteger.valueOf(lastValid[0].getNumerator());
             this.denominator = BigInteger.valueOf(lastValid[0].getDenominator());
         } else {
             throw new MathIllegalStateException(LocalizedCoreFormats.FAILED_FRACTION_CONVERSION,
                                                 value, maxIterations);
         }
     }
 
     /**
      * <p>
      * Create a {@link BigFraction} equivalent to the passed {@code int}, ie
      * "num / 1".
      * </p>
      *
      * @param num
      *            the numerator.
      */
     public BigFraction(final int num) {
         this(BigInteger.valueOf(num), BigInteger.ONE);
     }
 
     /**
      * <p>
      * Create a {@link BigFraction} given the numerator and denominator as simple
      * {@code int}. The {@link BigFraction} is reduced to lowest terms.
      * </p>
      *
      * @param num
      *            the numerator.
      * @param den
      *            the denominator.
      */
     public BigFraction(final int num, final int den) {
         this(BigInteger.valueOf(num), BigInteger.valueOf(den));
     }
 
     /**
      * <p>
      * Create a {@link BigFraction} equivalent to the passed long, ie "num / 1".
      * </p>
      *
      * @param num
      *            the numerator.
      */
     public BigFraction(final long num) {
         this(BigInteger.valueOf(num), BigInteger.ONE);
     }
 
     /**
      * <p>
      * Create a {@link BigFraction} given the numerator and denominator as simple
      * {@code long}. The {@link BigFraction} is reduced to lowest terms.
      * </p>
      *
      * @param num
      *            the numerator.
      * @param den
      *            the denominator.
      */
     public BigFraction(final long num, final long den) {
         this(BigInteger.valueOf(num), BigInteger.valueOf(den));
     }
 
     /**
      * A test to determine if a series of fractions has converged.
      */
     @FunctionalInterface
     public interface ConvergenceTest {
         /**
          * Evaluates if the fraction formed by {@code numerator/denominator} satisfies
          * this convergence test.
          *
          * @param numerator   the numerator
          * @param denominator the denominator
          * @return if this convergence test is satisfied
          */
         boolean test(long numerator, long denominator); // NOPMD - this is not a Junit test, PMD false positive here
     }
 
     /** Generate a {@link Stream stream} of convergents from a real number.
      * @param value value to approximate
      * @param maxConvergents maximum number of convergents.
      * @return stream of {@link BigFraction} convergents approximating  {@code value}
      * @since 2.1
      */
     public static Stream<BigFraction> convergents(final double value, final int maxConvergents) {
         return ConvergentsIterator.convergents(value, maxConvergents).map(STEP_TO_FRACTION);
     }
 
     /**
      * Returns the last element of the series of convergent-steps to approximate the
      * given value.
      * <p>
      * The series terminates either at the first step that satisfies the given
      * {@code convergenceTest} or after at most {@code maxConvergents} elements. The
      * returned Pair consists of that terminal {@link BigFraction} and a
      * {@link Boolean} that indicates if it satisfies the given convergence tests.
      * If the returned pair's value is {@code false} the element at position
      * {@code maxConvergents} was examined but failed to satisfy the
      * {@code convergenceTest}. A caller can then decide to accept the result
      * nevertheless or to discard it. This method is usually faster than
      * {@link #convergents(double, int)} if only the terminal element is of
      * interest.
      *
      * @param value           value to approximate
      * @param maxConvergents  maximum number of convergents to examine
      * @param convergenceTest the test if the series has converged at a step
      * @return the pair of last element of the series of convergents and a boolean
      *         indicating if that element satisfies the specified convergent test
      */
     public static Pair<BigFraction, Boolean> convergent(double value, int maxConvergents,
             ConvergenceTest convergenceTest) {
         Pair<ConvergenceStep, Boolean> converged = ConvergentsIterator.convergent(value, maxConvergents,
                 s -> convergenceTest.test(s.getNumerator(), s.getDenominator()));
         return Pair.create(STEP_TO_FRACTION.apply(converged.getKey()), converged.getValue());
     }
 
     /** {@inheritDoc} */
     @Override
     public double getReal() {
         return doubleValue();
     }
 
     /**
      * <p>
      * Creates a {@code BigFraction} instance with the 2 parts of a fraction
      * Y/Z.
      * </p>
      *
      * <p>
      * Any negative signs are resolved to be on the numerator.
      * </p>
      *
      * @param numerator
      *            the numerator, for example the three in 'three sevenths'.
      * @param denominator
      *            the denominator, for example the seven in 'three sevenths'.
      * @return a new fraction instance, with the numerator and denominator
      *         reduced.
      * @throws ArithmeticException
      *             if the denominator is <code>zero</code>.
      */
     public static BigFraction getReducedFraction(final int numerator,
                                                  final int denominator) {
         if (numerator == 0) {
             return ZERO; // normalize zero.
         }
 
         return new BigFraction(numerator, denominator);
     }
 
     /**
      * <p>
      * Returns the absolute value of this {@link BigFraction}.
      * </p>
      *
      * @return the absolute value as a {@link BigFraction}.
      */
     public BigFraction abs() {
         return (numerator.signum() == 1) ? this : negate();
     }
 
     /** Check if a fraction is an integer.
      * @return true of fraction is an integer
      */
     public boolean isInteger() {
         return denominator.equals(BigInteger.ONE);
     }
 
     /** Returns the signum function of this {@link BigFraction}.
      * <p>
      * The return value is -1 if the specified value is negative;
      * 0 if the specified value is zero; and 1 if the specified value is positive.
      * </p>
      * @return the signum function of this {@link BigFraction}
      * @since 1.7
      */
     public int signum() {
         return numerator.signum();
     }
 
     /**
      * <p>
      * Adds the value of this fraction to the passed {@link BigInteger},
      * returning the result in reduced form.
      * </p>
      *
      * @param bg
      *            the {@link BigInteger} to add, must'nt be <code>null</code>.
      * @return a {@code BigFraction} instance with the resulting values.
      * @throws NullArgumentException
      *             if the {@link BigInteger} is <code>null</code>.
      */
     public BigFraction add(final BigInteger bg) throws NullArgumentException {
         MathUtils.checkNotNull(bg);
 
         if (numerator.signum() == 0) {
             return new BigFraction(bg);
         }
         if (bg.signum() == 0) {
             return this;
         }
 
         return new BigFraction(numerator.add(denominator.multiply(bg)), denominator);
     }
 
     /**
      * <p>
      * Adds the value of this fraction to the passed {@code integer}, returning
      * the result in reduced form.
      * </p>
      *
      * @param i
      *            the {@code integer} to add.
      * @return a {@code BigFraction} instance with the resulting values.
      */
     public BigFraction add(final int i) {
         return add(BigInteger.valueOf(i));
     }
 
     /**
      * <p>
      * Adds the value of this fraction to the passed {@code long}, returning
      * the result in reduced form.
      * </p>
      *
      * @param l
      *            the {@code long} to add.
      * @return a {@code BigFraction} instance with the resulting values.
      */
     public BigFraction add(final long l) {
         return add(BigInteger.valueOf(l));
     }
 
     /**
      * <p>
      * Adds the value of this fraction to another, returning the result in
      * reduced form.
      * </p>
      *
      * @param fraction
      *            the {@link BigFraction} to add, must not be <code>null</code>.
      * @return a {@link BigFraction} instance with the resulting values.
      * @throws NullArgumentException if the {@link BigFraction} is {@code null}.
      */
     @Override
     public BigFraction add(final BigFraction fraction) {
         MathUtils.checkNotNull(fraction, LocalizedCoreFormats.FRACTION);
         if (fraction.numerator.signum() == 0) {
             return this;
         }
         if (numerator.signum() == 0) {
             return fraction;
         }
 
         BigInteger num;
         BigInteger den;
         if (denominator.equals(fraction.denominator)) {
             num = numerator.add(fraction.numerator);
             den = denominator;
         } else {
             num = (numerator.multiply(fraction.denominator)).add((fraction.numerator).multiply(denominator));
             den = denominator.multiply(fraction.denominator);
         }
 
         if (num.signum() == 0) {
             return ZERO;
         }
 
         return new BigFraction(num, den);
 
     }
 
     /**
      * <p>
      * Gets the fraction as a <code>BigDecimal</code>. This calculates the
      * fraction as the numerator divided by denominator.
      * </p>
      *
      * @return the fraction as a <code>BigDecimal</code>.
      * @throws ArithmeticException
      *             if the exact quotient does not have a terminating decimal
      *             expansion.
      * @see BigDecimal
      */
     public BigDecimal bigDecimalValue() {
         return new BigDecimal(numerator).divide(new BigDecimal(denominator));
     }
 
     /**
      * <p>
      * Gets the fraction as a <code>BigDecimal</code> following the passed
      * rounding mode. This calculates the fraction as the numerator divided by
      * denominator.
      * </p>
      *
      * @param roundingMode
      *            rounding mode to apply. see {@link BigDecimal} constants.
      * @return the fraction as a <code>BigDecimal</code>.
      * @throws IllegalArgumentException
      *             if {@code roundingMode} does not represent a valid rounding
      *             mode.
      * @see BigDecimal
      */
     public BigDecimal bigDecimalValue(final RoundingMode roundingMode) {
         return new BigDecimal(numerator).divide(new BigDecimal(denominator), roundingMode);
     }
 
     /**
      * <p>
      * Gets the fraction as a <code>BigDecimal</code> following the passed scale
      * and rounding mode. This calculates the fraction as the numerator divided
      * by denominator.
      * </p>
      *
      * @param scale
      *            scale of the <code>BigDecimal</code> quotient to be returned.
      *            see {@link BigDecimal} for more information.
      * @param roundingMode
      *            rounding mode to apply. see {@link BigDecimal} constants.
      * @return the fraction as a <code>BigDecimal</code>.
      * @see BigDecimal
      */
     public BigDecimal bigDecimalValue(final int scale, final RoundingMode roundingMode) {
         return new BigDecimal(numerator).divide(new BigDecimal(denominator), scale, roundingMode);
     }
 
     /**
      * <p>
      * Compares this object to another based on size.
      * </p>
      *
      * @param object
      *            the object to compare to, must not be <code>null</code>.
      * @return -1 if this is less than {@code object}, +1 if this is greater
      *         than {@code object}, 0 if they are equal.
      * @see java.lang.Comparable#compareTo(java.lang.Object)
      */
     @Override
     public int compareTo(final BigFraction object) {
         int lhsSigNum = numerator.signum();
         int rhsSigNum = object.numerator.signum();
 
         if (lhsSigNum != rhsSigNum) {
             return (lhsSigNum > rhsSigNum) ? 1 : -1;
         }
         if (lhsSigNum == 0) {
             return 0;
         }
 
         BigInteger nOd = numerator.multiply(object.denominator);
         BigInteger dOn = denominator.multiply(object.numerator);
         return nOd.compareTo(dOn);
     }
 
     /**
      * <p>
      * Divide the value of this fraction by the passed {@code BigInteger},
      * ie {@code this * 1 / bg}, returning the result in reduced form.
      * </p>
      *
      * @param bg the {@code BigInteger} to divide by, must not be {@code null}
      * @return a {@link BigFraction} instance with the resulting values
      * @throws NullArgumentException if the {@code BigInteger} is {@code null}
      * @throws MathRuntimeException if the fraction to divide by is zero
      */
     public BigFraction divide(final BigInteger bg) {
         MathUtils.checkNotNull(bg);
         if (bg.signum() == 0) {
             throw new MathRuntimeException(LocalizedCoreFormats.ZERO_DENOMINATOR);
         }
         if (numerator.signum() == 0) {
             return ZERO;
         }
         return new BigFraction(numerator, denominator.multiply(bg));
     }
 
     /**
      * <p>
      * Divide the value of this fraction by the passed {@code int}, ie
      * {@code this * 1 / i}, returning the result in reduced form.
      * </p>
      *
      * @param i the {@code int} to divide by
      * @return a {@link BigFraction} instance with the resulting values
      * @throws MathRuntimeException if the fraction to divide by is zero
      */
     public BigFraction divide(final int i) {
         return divide(BigInteger.valueOf(i));
     }
 
     /**
      * <p>
      * Divide the value of this fraction by the passed {@code long}, ie
      * {@code this * 1 / l}, returning the result in reduced form.
      * </p>
      *
      * @param l the {@code long} to divide by
      * @return a {@link BigFraction} instance with the resulting values
      * @throws MathRuntimeException if the fraction to divide by is zero
      */
     public BigFraction divide(final long l) {
         return divide(BigInteger.valueOf(l));
     }
 
     /**
      * <p>
      * Divide the value of this fraction by another, returning the result in
      * reduced form.
      * </p>
      *
      * @param fraction Fraction to divide by, must not be {@code null}.
      * @return a {@link BigFraction} instance with the resulting values.
      * @throws NullArgumentException if the {@code fraction} is {@code null}.
      * @throws MathRuntimeException if the fraction to divide by is zero
      */
     @Override
     public BigFraction divide(final BigFraction fraction) {
         MathUtils.checkNotNull(fraction, LocalizedCoreFormats.FRACTION);
         if (fraction.numerator.signum() == 0) {
             throw new MathRuntimeException(LocalizedCoreFormats.ZERO_DENOMINATOR);
         }
         if (numerator.signum() == 0) {
             return ZERO;
         }
 
         return multiply(fraction.reciprocal());
     }
 
     /**
      * <p>
      * Gets the fraction as a {@code double}. This calculates the fraction as
      * the numerator divided by denominator.
      * </p>
      *
      * @return the fraction as a {@code double}
      * @see java.lang.Number#doubleValue()
      */
     @Override
     public double doubleValue() {
         double result = numerator.doubleValue() / denominator.doubleValue();
         if (Double.isInfinite(result) || Double.isNaN(result)) {
             // Numerator and/or denominator must be out of range:
             // Calculate how far to shift them to put them in range.
             int shift = FastMath.max(numerator.bitLength(),
                                      denominator.bitLength()) - FastMath.getExponent(Double.MAX_VALUE);
             result = numerator.shiftRight(shift).doubleValue() /
                 denominator.shiftRight(shift).doubleValue();
         }
         return result;
     }
 
     /**
      * <p>
      * 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.
      * </p>
      *
      * @param other
      *            fraction to test for equality to this fraction, can be
      *            <code>null</code>.
      * @return true if two fractions are equal, false if object is
      *         <code>null</code>, not an instance of {@link BigFraction}, or not
      *         equal to this fraction instance.
      * @see java.lang.Object#equals(java.lang.Object)
      */
     @Override
     public boolean equals(final Object other) {
         boolean ret = false;
 
         if (this == other) {
             ret = true;
         } else if (other instanceof BigFraction) {
             BigFraction rhs = (BigFraction) other;
             ret = numerator.equals(rhs.numerator) && denominator.equals(rhs.denominator);
         }
 
         return ret;
     }
 
     /**
      * <p>
      * Gets the fraction as a {@code float}. This calculates the fraction as
      * the numerator divided by denominator.
      * </p>
      *
      * @return the fraction as a {@code float}.
      * @see java.lang.Number#floatValue()
      */
     @Override
     public float floatValue() {
         float result = numerator.floatValue() / denominator.floatValue();
         if (Double.isNaN(result)) {
             // Numerator and/or denominator must be out of range:
             // Calculate how far to shift them to put them in range.
             int shift = FastMath.max(numerator.bitLength(),
                                      denominator.bitLength()) - FastMath.getExponent(Float.MAX_VALUE);
             result = numerator.shiftRight(shift).floatValue() /
                 denominator.shiftRight(shift).floatValue();
         }
         return result;
     }
 
     /**
      * {@link java.math.BigInteger} number least common multiple.
      *
      * @param i0 first number
      * @param i1 second number
      * @return Least Common Multiple of both numbers
      * @since 3.1
      */
     private static BigInteger lcm(final BigInteger i0, final BigInteger i1) {
       if (i0.signum() == 0 && i1.signum() == 0) {
         return BigInteger.ZERO;
       }
       BigInteger a = i0.abs();
       BigInteger b = i1.abs();
       BigInteger gcd = i0.gcd(b);
       return (a.multiply(b)).divide(gcd);
     }
 
     /**
      * Rational number greatest common divisor.
      *
      * @param s fraction.
      * @return gcd(this, s).
      * @since 3.1
      */
     public BigFraction gcd(BigFraction s) {
       if (s.isZero()) {
         return this;
       }
       if (this.isZero()) {
         return s;
       }
       BigInteger p = numerator.gcd(s.numerator);
       BigInteger q = lcm(denominator, s.denominator);
       return new BigFraction(p, q);
     }
 
     /**
      * Rational number least common multiple.
      *
      * @param s fraction.
      * @return lcm(this, s).
      * @since 3.1
      */
     public BigFraction lcm(BigFraction s) {
       if (s.isZero()) {
         return ZERO;
       }
       if (this.isZero()) {
         return ZERO;
       }
       return new BigFraction(lcm(numerator, s.numerator), denominator.gcd(s.denominator));
     }
 
     /**
      * <p>
      * Access the denominator as a <code>BigInteger</code>.
      * </p>
      *
      * @return the denominator as a <code>BigInteger</code>.
      */
     public BigInteger getDenominator() {
         return denominator;
     }
 
     /**
      * <p>
      * Access the denominator as a {@code int}.
      * </p>
      *
      * @return the denominator as a {@code int}.
      */
     public int getDenominatorAsInt() {
         return denominator.intValue();
     }
 
     /**
      * <p>
      * Access the denominator as a {@code long}.
      * </p>
      *
      * @return the denominator as a {@code long}.
      */
     public long getDenominatorAsLong() {
         return denominator.longValue();
     }
 
     /**
      * <p>
      * Access the numerator as a <code>BigInteger</code>.
      * </p>
      *
      * @return the numerator as a <code>BigInteger</code>.
      */
     public BigInteger getNumerator() {
         return numerator;
     }
 
     /**
      * <p>
      * Access the numerator as a {@code int}.
      * </p>
      *
      * @return the numerator as a {@code int}.
      */
     public int getNumeratorAsInt() {
         return numerator.intValue();
     }
 
     /**
      * <p>
      * Access the numerator as a {@code long}.
      * </p>
      *
      * @return the numerator as a {@code long}.
      */
     public long getNumeratorAsLong() {
         return numerator.longValue();
     }
 
     /**
      * <p>
      * Gets a hashCode for the fraction.
      * </p>
      *
      * @return a hash code value for this object.
      * @see java.lang.Object#hashCode()
      */
     @Override
     public int hashCode() {
         return 37 * (37 * 17 + numerator.hashCode()) + denominator.hashCode();
     }
 
     /**
      * <p>
      * Gets the fraction as an {@code int}. This returns the whole number part
      * of the fraction.
      * </p>
      *
      * @return the whole number fraction part.
      * @see java.lang.Number#intValue()
      */
     @Override
     public int intValue() {
         return numerator.divide(denominator).intValue();
     }
 
     /**
      * <p>
      * Gets the fraction as a {@code long}. This returns the whole number part
      * of the fraction.
      * </p>
      *
      * @return the whole number fraction part.
      * @see java.lang.Number#longValue()
      */
     @Override
     public long longValue() {
         return numerator.divide(denominator).longValue();
     }
 
     /**
      * <p>
      * Multiplies the value of this fraction by the passed
      * <code>BigInteger</code>, returning the result in reduced form.
      * </p>
      *
      * @param bg the {@code BigInteger} to multiply by.
      * @return a {@code BigFraction} instance with the resulting values.
      * @throws NullArgumentException if {@code bg} is {@code null}.
      */
     public BigFraction multiply(final BigInteger bg) {
         MathUtils.checkNotNull(bg);
         if (numerator.signum() == 0 || bg.signum() == 0) {
             return ZERO;
         }
         return new BigFraction(bg.multiply(numerator), denominator);
     }
 
     /**
      * <p>
      * Multiply the value of this fraction by the passed {@code int}, returning
      * the result in reduced form.
      * </p>
      *
      * @param i
      *            the {@code int} to multiply by.
      * @return a {@link BigFraction} instance with the resulting values.
      */
     @Override
     public BigFraction multiply(final int i) {
         if (i == 0 || numerator.signum() == 0) {
             return ZERO;
         }
 
         return multiply(BigInteger.valueOf(i));
     }
 
     /**
      * <p>
      * Multiply the value of this fraction by the passed {@code long},
      * returning the result in reduced form.
      * </p>
      *
      * @param l
      *            the {@code long} to multiply by.
      * @return a {@link BigFraction} instance with the resulting values.
      */
     public BigFraction multiply(final long l) {
         if (l == 0 || numerator.signum() == 0) {
             return ZERO;
         }
 
         return multiply(BigInteger.valueOf(l));
     }
 
     /**
      * <p>
      * Multiplies the value of this fraction by another, returning the result in
      * reduced form.
      * </p>
      *
      * @param fraction Fraction to multiply by, must not be {@code null}.
      * @return a {@link BigFraction} instance with the resulting values.
      * @throws NullArgumentException if {@code fraction} is {@code null}.
      */
     @Override
     public BigFraction multiply(final BigFraction fraction) {
         MathUtils.checkNotNull(fraction, LocalizedCoreFormats.FRACTION);
         if (numerator.signum() == 0 ||
             fraction.numerator.signum() == 0) {
             return ZERO;
         }
         return new BigFraction(numerator.multiply(fraction.numerator),
                                denominator.multiply(fraction.denominator));
     }
 
     /**
      * <p>
      * Return the additive inverse of this fraction, returning the result in
      * reduced form.
      * </p>
      *
      * @return the negation of this fraction.
      */
     @Override
     public BigFraction negate() {
         return new BigFraction(numerator.negate(), denominator);
     }
 
     /**
      * <p>
      * Gets the fraction percentage as a {@code double}. This calculates the
      * fraction as the numerator divided by denominator multiplied by 100.
      * </p>
      *
      * @return the fraction percentage as a {@code double}.
      */
     public double percentageValue() {
         return multiply(ONE_HUNDRED).doubleValue();
     }
 
     /**
      * <p>
      * Returns a {@code BigFraction} whose value is
      * {@code (this<sup>exponent</sup>)}, returning the result in reduced form.
      * </p>
      *
      * @param exponent
      *            exponent to which this {@code BigFraction} is to be
      *            raised.
      * @return this<sup>exponent</sup>
      */
     public BigFraction pow(final int exponent) {
         if (exponent == 0) {
             return ONE;
         }
         if (numerator.signum() == 0) {
             return this;
         }
 
         if (exponent < 0) {
             return new BigFraction(denominator.pow(-exponent), numerator.pow(-exponent));
         }
         return new BigFraction(numerator.pow(exponent), denominator.pow(exponent));
     }
 
     /**
      * <p>
      * Returns a {@code BigFraction} whose value is
      * this<sup>exponent</sup>, returning the result in reduced form.
      * </p>
      *
      * @param exponent
      *            exponent to which this {@code BigFraction} is to be raised.
      * @return this<sup>exponent</sup> as a {@code BigFraction}.
      */
     public BigFraction pow(final long exponent) {
         if (exponent == 0) {
             return ONE;
         }
         if (numerator.signum() == 0) {
             return this;
         }
 
         if (exponent < 0) {
             return new BigFraction(ArithmeticUtils.pow(denominator, -exponent),
                                    ArithmeticUtils.pow(numerator,   -exponent));
         }
         return new BigFraction(ArithmeticUtils.pow(numerator,   exponent),
                                ArithmeticUtils.pow(denominator, exponent));
     }
 
     /**
      * <p>
      * Returns a {@code BigFraction} whose value is
      * this<sup>exponent</sup>, returning the result in reduced form.
      * </p>
      *
      * @param exponent
      *            exponent to which this {@code BigFraction} is to be raised.
      * @return this<sup>exponent</sup> as a {@code BigFraction}.
      */
     public BigFraction pow(final BigInteger exponent) {
         if (exponent.signum() == 0) {
             return ONE;
         }
         if (numerator.signum() == 0) {
             return this;
         }
 
         if (exponent.signum() == -1) {
             final BigInteger eNeg = exponent.negate();
             return new BigFraction(ArithmeticUtils.pow(denominator, eNeg),
                                    ArithmeticUtils.pow(numerator,   eNeg));
         }
         return new BigFraction(ArithmeticUtils.pow(numerator,   exponent),
                                ArithmeticUtils.pow(denominator, exponent));
     }
 
     /**
      * <p>
      * Returns a <code>double</code> whose value is
      * this<sup>exponent</sup>, returning the result in reduced form.
      * </p>
      *
      * @param exponent
      *            exponent to which this {@code BigFraction} is to be raised.
      * @return this<sup>exponent</sup>
      */
     public double pow(final double exponent) {
         return FastMath.pow(numerator.doubleValue(),   exponent) /
                FastMath.pow(denominator.doubleValue(), exponent);
     }
 
     /**
      * <p>
      * Return the multiplicative inverse of this fraction.
      * </p>
      *
      * @return the reciprocal fraction.
      */
     @Override
     public BigFraction reciprocal() {
         return new BigFraction(denominator, numerator);
     }
 
     /**
      * <p>
      * Reduce this {@code BigFraction} to its lowest terms.
      * </p>
      *
      * @return the reduced {@code BigFraction}. It doesn't change anything if
      *         the fraction can be reduced.
      */
     public BigFraction reduce() {
         final BigInteger gcd = numerator.gcd(denominator);
 
         if (BigInteger.ONE.compareTo(gcd) < 0) {
             return new BigFraction(numerator.divide(gcd), denominator.divide(gcd));
         } else {
             return this;
         }
     }
 
     /**
      * <p>
      * Subtracts the value of an {@link BigInteger} from the value of this
      * {@code BigFraction}, returning the result in reduced form.
      * </p>
      *
      * @param bg the {@link BigInteger} to subtract, cannot be {@code null}.
      * @return a {@code BigFraction} instance with the resulting values.
      * @throws NullArgumentException if the {@link BigInteger} is {@code null}.
      */
     public BigFraction subtract(final BigInteger bg) {
         MathUtils.checkNotNull(bg);
         if (bg.signum() == 0) {
             return this;
         }
         if (numerator.signum() == 0) {
             return new BigFraction(bg.negate());
         }
 
         return new BigFraction(numerator.subtract(denominator.multiply(bg)), denominator);
     }
 
     /**
      * <p>
      * Subtracts the value of an {@code integer} from the value of this
      * {@code BigFraction}, returning the result in reduced form.
      * </p>
      *
      * @param i the {@code integer} to subtract.
      * @return a {@code BigFraction} instance with the resulting values.
      */
     public BigFraction subtract(final int i) {
         return subtract(BigInteger.valueOf(i));
     }
 
     /**
      * <p>
      * Subtracts the value of a {@code long} from the value of this
      * {@code BigFraction}, returning the result in reduced form.
      * </p>
      *
      * @param l the {@code long} to subtract.
      * @return a {@code BigFraction} instance with the resulting values.
      */
     public BigFraction subtract(final long l) {
         return subtract(BigInteger.valueOf(l));
     }
 
     /**
      * <p>
      * Subtracts the value of another fraction from the value of this one,
      * returning the result in reduced form.
      * </p>
      *
      * @param fraction {@link BigFraction} to subtract, must not be {@code null}.
      * @return a {@link BigFraction} instance with the resulting values
      * @throws NullArgumentException if the {@code fraction} is {@code null}.
      */
     @Override
     public BigFraction subtract(final BigFraction fraction) {
         MathUtils.checkNotNull(fraction, LocalizedCoreFormats.FRACTION);
         if (fraction.numerator.signum() == 0) {
             return this;
         }
         if (numerator.signum() == 0) {
             return fraction.negate();
         }
 
         BigInteger num;
         BigInteger den;
         if (denominator.equals(fraction.denominator)) {
             num = numerator.subtract(fraction.numerator);
             den = denominator;
         } else {
             num = (numerator.multiply(fraction.denominator)).subtract((fraction.numerator).multiply(denominator));
             den = denominator.multiply(fraction.denominator);
         }
         return new BigFraction(num, den);
 
     }
 
     /**
      * <p>
      * Returns the <code>String</code> representing this fraction, ie
      * "num / dem" or just "num" if the denominator is one.
      * </p>
      *
      * @return a string representation of the fraction.
      * @see java.lang.Object#toString()
      */
     @Override
     public String toString() {
         if (BigInteger.ONE.equals(denominator)) {
             return numerator.toString();
         } else if (BigInteger.ZERO.equals(numerator)) {
             return "0";
         } else {
             return numerator + " / " + denominator;
         }
     }
 
     /** {@inheritDoc} */
     @Override
     public BigFractionField getField() {
         return BigFractionField.getInstance();
     }
 
 }