commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From t.@apache.org
Subject [25/82] [partial] [math] Update for next development iteration: commons-math4
Date Mon, 16 Feb 2015 22:39:55 GMT
http://git-wip-us.apache.org/repos/asf/commons-math/blob/a7b4803f/src/main/java/org/apache/commons/math3/fitting/leastsquares/OptimumImpl.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math3/fitting/leastsquares/OptimumImpl.java b/src/main/java/org/apache/commons/math3/fitting/leastsquares/OptimumImpl.java
deleted file mode 100644
index 698f86c..0000000
--- a/src/main/java/org/apache/commons/math3/fitting/leastsquares/OptimumImpl.java
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.commons.math3.fitting.leastsquares;
-
-import org.apache.commons.math3.fitting.leastsquares.LeastSquaresOptimizer.Optimum;
-import org.apache.commons.math3.fitting.leastsquares.LeastSquaresProblem.Evaluation;
-import org.apache.commons.math3.linear.RealMatrix;
-import org.apache.commons.math3.linear.RealVector;
-
-/**
- * A pedantic implementation of {@link Optimum}.
- *
- * @since 3.3
- */
-class OptimumImpl implements Optimum {
-
-    /** abscissa and ordinate */
-    private final Evaluation value;
-    /** number of evaluations to compute this optimum */
-    private final int evaluations;
-    /** number of iterations to compute this optimum */
-    private final int iterations;
-
-    /**
-     * Construct an optimum from an evaluation and the values of the counters.
-     *
-     * @param value       the function value
-     * @param evaluations number of times the function was evaluated
-     * @param iterations  number of iterations of the algorithm
-     */
-    OptimumImpl(final Evaluation value, final int evaluations, final int iterations) {
-        this.value = value;
-        this.evaluations = evaluations;
-        this.iterations = iterations;
-    }
-
-    /* auto-generated implementations */
-
-    /** {@inheritDoc} */
-    public int getEvaluations() {
-        return evaluations;
-    }
-
-    /** {@inheritDoc} */
-    public int getIterations() {
-        return iterations;
-    }
-
-    /** {@inheritDoc} */
-    public RealMatrix getCovariances(double threshold) {
-        return value.getCovariances(threshold);
-    }
-
-    /** {@inheritDoc} */
-    public RealVector getSigma(double covarianceSingularityThreshold) {
-        return value.getSigma(covarianceSingularityThreshold);
-    }
-
-    /** {@inheritDoc} */
-    public double getRMS() {
-        return value.getRMS();
-    }
-
-    /** {@inheritDoc} */
-    public RealMatrix getJacobian() {
-        return value.getJacobian();
-    }
-
-    /** {@inheritDoc} */
-    public double getCost() {
-        return value.getCost();
-    }
-
-    /** {@inheritDoc} */
-    public RealVector getResiduals() {
-        return value.getResiduals();
-    }
-
-    /** {@inheritDoc} */
-    public RealVector getPoint() {
-        return value.getPoint();
-    }
-}

http://git-wip-us.apache.org/repos/asf/commons-math/blob/a7b4803f/src/main/java/org/apache/commons/math3/fitting/leastsquares/ParameterValidator.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math3/fitting/leastsquares/ParameterValidator.java b/src/main/java/org/apache/commons/math3/fitting/leastsquares/ParameterValidator.java
deleted file mode 100644
index d5b8529..0000000
--- a/src/main/java/org/apache/commons/math3/fitting/leastsquares/ParameterValidator.java
+++ /dev/null
@@ -1,34 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.commons.math3.fitting.leastsquares;
-
-import org.apache.commons.math3.linear.RealVector;
-
-/**
- * Interface for validating a set of model parameters.
- *
- * @since 3.4
- */
-public interface ParameterValidator {
-    /**
-     * Validates the set of parameters.
-     *
-     * @param params Input parameters.
-     * @return the validated values.
-     */
-    RealVector validate(RealVector params);
-}

http://git-wip-us.apache.org/repos/asf/commons-math/blob/a7b4803f/src/main/java/org/apache/commons/math3/fitting/leastsquares/ValueAndJacobianFunction.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math3/fitting/leastsquares/ValueAndJacobianFunction.java b/src/main/java/org/apache/commons/math3/fitting/leastsquares/ValueAndJacobianFunction.java
deleted file mode 100644
index 180e328..0000000
--- a/src/main/java/org/apache/commons/math3/fitting/leastsquares/ValueAndJacobianFunction.java
+++ /dev/null
@@ -1,44 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.commons.math3.fitting.leastsquares;
-
-import org.apache.commons.math3.linear.RealMatrix;
-import org.apache.commons.math3.linear.RealVector;
-
-/**
- * A interface for functions that compute a vector of values and can compute their
- * derivatives (Jacobian).
- *
- * @since 3.4
- */
-public interface ValueAndJacobianFunction extends MultivariateJacobianFunction {
-    /**
-     * Compute the value.
-     *
-     * @param params Point.
-     * @return the value at the given point.
-     */
-    RealVector computeValue(final double[] params);
-
-    /**
-     * Compute the Jacobian.
-     *
-     * @param params Point.
-     * @return the Jacobian at the given point.
-     */
-    RealMatrix computeJacobian(final double[] params);
-}

http://git-wip-us.apache.org/repos/asf/commons-math/blob/a7b4803f/src/main/java/org/apache/commons/math3/fitting/leastsquares/package-info.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math3/fitting/leastsquares/package-info.java b/src/main/java/org/apache/commons/math3/fitting/leastsquares/package-info.java
deleted file mode 100644
index 98623b5..0000000
--- a/src/main/java/org/apache/commons/math3/fitting/leastsquares/package-info.java
+++ /dev/null
@@ -1,39 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/**
- * This package provides algorithms that minimize the residuals
- * between observations and model values.
- * The {@link org.apache.commons.math3.fitting.leastsquares.LeastSquaresOptimizer
- * least-squares optimizers} minimize the distance (called
- * <em>cost</em> or <em>&chi;<sup>2</sup></em>) between model and
- * observations.
- *
- * <br/>
- * Algorithms in this category need access to a <em>problem</em>
- * (represented by a {@link org.apache.commons.math3.fitting.leastsquares.LeastSquaresProblem
- * LeastSquaresProblem}).
- * Such a model predicts a set of values which the algorithm tries to match
- * with a set of given set of observed values.
- * <br/>
- * The problem can be created progressively using a {@link
- * org.apache.commons.math3.fitting.leastsquares.LeastSquaresBuilder builder} or it can
- * be created at once using a {@link org.apache.commons.math3.fitting.leastsquares.LeastSquaresFactory
- * factory}.
- * @since 3.3
- */
-package org.apache.commons.math3.fitting.leastsquares;

http://git-wip-us.apache.org/repos/asf/commons-math/blob/a7b4803f/src/main/java/org/apache/commons/math3/fitting/package-info.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math3/fitting/package-info.java b/src/main/java/org/apache/commons/math3/fitting/package-info.java
deleted file mode 100644
index 460e3f7..0000000
--- a/src/main/java/org/apache/commons/math3/fitting/package-info.java
+++ /dev/null
@@ -1,26 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-/**
- * Classes to perform curve fitting.
- *
- * Curve fitting is a special case of a least-squares problem
- * where the parameters are the coefficients of a function \( f \)
- * whose graph \( y = f(x) \) should pass through sample points, and
- * were the objective function is the squared sum of the residuals
- * \( f(x_i) - y_i \) for observed points \( (x_i, y_i) \).
- */
-package org.apache.commons.math3.fitting;

http://git-wip-us.apache.org/repos/asf/commons-math/blob/a7b4803f/src/main/java/org/apache/commons/math3/fraction/AbstractFormat.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math3/fraction/AbstractFormat.java b/src/main/java/org/apache/commons/math3/fraction/AbstractFormat.java
deleted file mode 100644
index fcb9d41..0000000
--- a/src/main/java/org/apache/commons/math3/fraction/AbstractFormat.java
+++ /dev/null
@@ -1,209 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.apache.commons.math3.fraction;
-
-import java.io.Serializable;
-import java.text.FieldPosition;
-import java.text.NumberFormat;
-import java.text.ParsePosition;
-import java.util.Locale;
-
-import org.apache.commons.math3.exception.NullArgumentException;
-import org.apache.commons.math3.exception.util.LocalizedFormats;
-
-/**
- * Common part shared by both {@link FractionFormat} and {@link BigFractionFormat}.
- * @since 2.0
- */
-public abstract class AbstractFormat extends NumberFormat implements Serializable {
-
-    /** Serializable version identifier. */
-    private static final long serialVersionUID = -6981118387974191891L;
-
-    /** The format used for the denominator. */
-    private NumberFormat denominatorFormat;
-
-    /** The format used for the numerator. */
-    private NumberFormat numeratorFormat;
-
-    /**
-     * Create an improper formatting instance with the default number format
-     * for the numerator and denominator.
-     */
-    protected AbstractFormat() {
-        this(getDefaultNumberFormat());
-    }
-
-    /**
-     * Create an improper formatting instance with a custom number format for
-     * both the numerator and denominator.
-     * @param format the custom format for both the numerator and denominator.
-     */
-    protected AbstractFormat(final NumberFormat format) {
-        this(format, (NumberFormat) format.clone());
-    }
-
-    /**
-     * Create an improper formatting instance with a custom number format for
-     * the numerator and a custom number format for the denominator.
-     * @param numeratorFormat the custom format for the numerator.
-     * @param denominatorFormat the custom format for the denominator.
-     */
-    protected AbstractFormat(final NumberFormat numeratorFormat,
-                             final NumberFormat denominatorFormat) {
-        this.numeratorFormat   = numeratorFormat;
-        this.denominatorFormat = denominatorFormat;
-    }
-
-    /**
-     * Create a default number format.  The default number format is based on
-     * {@link NumberFormat#getNumberInstance(java.util.Locale)}. The only
-     * customization is the maximum number of BigFraction digits, which is set to 0.
-     * @return the default number format.
-     */
-    protected static NumberFormat getDefaultNumberFormat() {
-        return getDefaultNumberFormat(Locale.getDefault());
-    }
-
-    /**
-     * Create a default number format.  The default number format is based on
-     * {@link NumberFormat#getNumberInstance(java.util.Locale)}. The only
-     * customization is the maximum number of BigFraction digits, which is set to 0.
-     * @param locale the specific locale used by the format.
-     * @return the default number format specific to the given locale.
-     */
-    protected static NumberFormat getDefaultNumberFormat(final Locale locale) {
-        final NumberFormat nf = NumberFormat.getNumberInstance(locale);
-        nf.setMaximumFractionDigits(0);
-        nf.setParseIntegerOnly(true);
-        return nf;
-    }
-
-    /**
-     * Access the denominator format.
-     * @return the denominator format.
-     */
-    public NumberFormat getDenominatorFormat() {
-        return denominatorFormat;
-    }
-
-    /**
-     * Access the numerator format.
-     * @return the numerator format.
-     */
-    public NumberFormat getNumeratorFormat() {
-        return numeratorFormat;
-    }
-
-    /**
-     * Modify the denominator format.
-     * @param format the new denominator format value.
-     * @throws NullArgumentException if {@code format} is {@code null}.
-     */
-    public void setDenominatorFormat(final NumberFormat format) {
-        if (format == null) {
-            throw new NullArgumentException(LocalizedFormats.DENOMINATOR_FORMAT);
-        }
-        this.denominatorFormat = format;
-    }
-
-    /**
-     * Modify the numerator format.
-     * @param format the new numerator format value.
-     * @throws NullArgumentException if {@code format} is {@code null}.
-     */
-    public void setNumeratorFormat(final NumberFormat format) {
-        if (format == null) {
-            throw new NullArgumentException(LocalizedFormats.NUMERATOR_FORMAT);
-        }
-        this.numeratorFormat = format;
-    }
-
-    /**
-     * Parses <code>source</code> until a non-whitespace character is found.
-     * @param source the string to parse
-     * @param pos input/output parsing parameter.  On output, <code>pos</code>
-     *        holds the index of the next non-whitespace character.
-     */
-    protected static void parseAndIgnoreWhitespace(final String source,
-                                                   final ParsePosition pos) {
-        parseNextCharacter(source, pos);
-        pos.setIndex(pos.getIndex() - 1);
-    }
-
-    /**
-     * Parses <code>source</code> until a non-whitespace character is found.
-     * @param source the string to parse
-     * @param pos input/output parsing parameter.
-     * @return the first non-whitespace character.
-     */
-    protected static char parseNextCharacter(final String source,
-                                             final ParsePosition pos) {
-         int index = pos.getIndex();
-         final int n = source.length();
-         char ret = 0;
-
-         if (index < n) {
-             char c;
-             do {
-                 c = source.charAt(index++);
-             } while (Character.isWhitespace(c) && index < n);
-             pos.setIndex(index);
-
-             if (index < n) {
-                 ret = c;
-             }
-         }
-
-         return ret;
-    }
-
-    /**
-     * Formats a double value as a fraction and appends the result to a StringBuffer.
-     *
-     * @param value the double value to format
-     * @param buffer StringBuffer to append to
-     * @param position On input: an alignment field, if desired. On output: the
-     *            offsets of the alignment field
-     * @return a reference to the appended buffer
-     * @see #format(Object, StringBuffer, FieldPosition)
-     */
-    @Override
-    public StringBuffer format(final double value,
-                               final StringBuffer buffer, final FieldPosition position) {
-        return format(Double.valueOf(value), buffer, position);
-    }
-
-
-    /**
-     * Formats a long value as a fraction and appends the result to a StringBuffer.
-     *
-     * @param value the long value to format
-     * @param buffer StringBuffer to append to
-     * @param position On input: an alignment field, if desired. On output: the
-     *            offsets of the alignment field
-     * @return a reference to the appended buffer
-     * @see #format(Object, StringBuffer, FieldPosition)
-     */
-    @Override
-    public StringBuffer format(final long value,
-                               final StringBuffer buffer, final FieldPosition position) {
-        return format(Long.valueOf(value), buffer, position);
-    }
-
-}

http://git-wip-us.apache.org/repos/asf/commons-math/blob/a7b4803f/src/main/java/org/apache/commons/math3/fraction/BigFraction.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math3/fraction/BigFraction.java b/src/main/java/org/apache/commons/math3/fraction/BigFraction.java
deleted file mode 100644
index e16c593..0000000
--- a/src/main/java/org/apache/commons/math3/fraction/BigFraction.java
+++ /dev/null
@@ -1,1147 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package org.apache.commons.math3.fraction;
-
-import java.io.Serializable;
-import java.math.BigDecimal;
-import java.math.BigInteger;
-
-import org.apache.commons.math3.FieldElement;
-import org.apache.commons.math3.exception.MathArithmeticException;
-import org.apache.commons.math3.exception.MathIllegalArgumentException;
-import org.apache.commons.math3.exception.NullArgumentException;
-import org.apache.commons.math3.exception.ZeroException;
-import org.apache.commons.math3.exception.util.LocalizedFormats;
-import org.apache.commons.math3.util.ArithmeticUtils;
-import org.apache.commons.math3.util.FastMath;
-import org.apache.commons.math3.util.MathUtils;
-
-/**
- * Representation of a rational number without any overflow. This class is
- * immutable.
- *
- * @since 2.0
- */
-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);
-
-    /** 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 ZeroException if the denominator is zero.
-     * @throws NullArgumentException if either of the arguments is null
-     */
-    public BigFraction(BigInteger num, BigInteger den) {
-        MathUtils.checkNotNull(num, LocalizedFormats.NUMERATOR);
-        MathUtils.checkNotNull(den, LocalizedFormats.DENOMINATOR);
-        if (BigInteger.ZERO.equals(den)) {
-            throw new ZeroException(LocalizedFormats.ZERO_DENOMINATOR);
-        }
-        if (BigInteger.ZERO.equals(num)) {
-            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 (BigInteger.ZERO.compareTo(den) > 0) {
-                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(LocalizedFormats.NAN_VALUE_CONVERSION);
-        }
-        if (Double.isInfinite(value)) {
-            throw new MathIllegalArgumentException(LocalizedFormats.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:
-     * <ul>
-     * <li><a href="http://mathworld.wolfram.com/ContinuedFraction.html">
-     * Continued Fraction</a> equations (11) and (22)-(26)</li>
-     * </ul>
-     * </p>
-     *
-     * @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 FractionConversionException
-     *             if the continued fraction failed to converge.
-     * @see #BigFraction(double)
-     */
-    public BigFraction(final double value, final double epsilon,
-                       final int maxIterations)
-        throws FractionConversionException {
-        this(value, epsilon, Integer.MAX_VALUE, maxIterations);
-    }
-
-    /**
-     * Create a fraction given the double value and either the maximum error
-     * allowed or the maximum number of denominator digits.
-     * <p>
-     *
-     * NOTE: This constructor is called with EITHER - a valid epsilon value and
-     * the maxDenominator set to Integer.MAX_VALUE (that way the maxDenominator
-     * has no effect). OR - a valid maxDenominator value and the epsilon value
-     * set to zero (that way epsilon only has effect if there is an exact match
-     * before the maxDenominator value is reached).
-     * </p>
-     * <p>
-     *
-     * It has been done this way so that the same code can be (re)used for both
-     * scenarios. However this could be confusing to users if it were part of
-     * the public API and this constructor should therefore remain PRIVATE.
-     * </p>
-     *
-     * See JIRA issue ticket MATH-181 for more details:
-     *
-     * https://issues.apache.org/jira/browse/MATH-181
-     *
-     * @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 maxDenominator
-     *            maximum denominator value allowed.
-     * @param maxIterations
-     *            maximum number of convergents.
-     * @throws FractionConversionException
-     *             if the continued fraction failed to converge.
-     */
-    private BigFraction(final double value, final double epsilon,
-                        final int maxDenominator, int maxIterations)
-        throws FractionConversionException {
-        long overflow = Integer.MAX_VALUE;
-        double r0 = value;
-        long a0 = (long) FastMath.floor(r0);
-
-        if (FastMath.abs(a0) > overflow) {
-            throw new FractionConversionException(value, a0, 1l);
-        }
-
-        // check for (almost) integer arguments, which should not go
-        // to iterations.
-        if (FastMath.abs(a0 - value) < epsilon) {
-            numerator = BigInteger.valueOf(a0);
-            denominator = BigInteger.ONE;
-            return;
-        }
-
-        long p0 = 1;
-        long q0 = 0;
-        long p1 = a0;
-        long q1 = 1;
-
-        long p2 = 0;
-        long q2 = 1;
-
-        int n = 0;
-        boolean stop = false;
-        do {
-            ++n;
-            final double r1 = 1.0 / (r0 - a0);
-            final long a1 = (long) FastMath.floor(r1);
-            p2 = (a1 * p1) + p0;
-            q2 = (a1 * q1) + q0;
-            if ((p2 > overflow) || (q2 > overflow)) {
-                // in maxDenominator mode, if the last fraction was very close to the actual value
-                // q2 may overflow in the next iteration; in this case return the last one.
-                if (epsilon == 0.0 && FastMath.abs(q1) < maxDenominator) {
-                    break;
-                }
-                throw new FractionConversionException(value, p2, q2);
-            }
-
-            final double convergent = (double) p2 / (double) q2;
-            if ((n < maxIterations) &&
-                (FastMath.abs(convergent - value) > epsilon) &&
-                (q2 < maxDenominator)) {
-                p0 = p1;
-                p1 = p2;
-                q0 = q1;
-                q1 = q2;
-                a0 = a1;
-                r0 = r1;
-            } else {
-                stop = true;
-            }
-        } while (!stop);
-
-        if (n >= maxIterations) {
-            throw new FractionConversionException(value, maxIterations);
-        }
-
-        if (q2 < maxDenominator) {
-            numerator   = BigInteger.valueOf(p2);
-            denominator = BigInteger.valueOf(q2);
-        } else {
-            numerator   = BigInteger.valueOf(p1);
-            denominator = BigInteger.valueOf(q1);
-        }
-    }
-
-    /**
-     * Create a fraction given the double value and maximum denominator.
-     * <p>
-     * References:
-     * <ul>
-     * <li><a href="http://mathworld.wolfram.com/ContinuedFraction.html">
-     * Continued Fraction</a> equations (11) and (22)-(26)</li>
-     * </ul>
-     * </p>
-     *
-     * @param value
-     *            the double value to convert to a fraction.
-     * @param maxDenominator
-     *            The maximum allowed value for denominator.
-     * @throws FractionConversionException
-     *             if the continued fraction failed to converge.
-     */
-    public BigFraction(final double value, final int maxDenominator)
-        throws FractionConversionException {
-        this(value, 0, maxDenominator, 100);
-    }
-
-    /**
-     * <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));
-    }
-
-    /**
-     * <p>
-     * Creates a <code>BigFraction</code> 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 (BigInteger.ZERO.compareTo(numerator) <= 0) ? this : negate();
-    }
-
-    /**
-     * <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</code> 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);
-        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</code> 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</code> 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}.
-     */
-    public BigFraction add(final BigFraction fraction) {
-        if (fraction == null) {
-            throw new NullArgumentException(LocalizedFormats.FRACTION);
-        }
-        if (ZERO.equals(fraction)) {
-            return this;
-        }
-
-        BigInteger num = null;
-        BigInteger den = null;
-
-        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);
-        }
-        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 int 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 int 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)
-     */
-    public int compareTo(final BigFraction object) {
-        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 MathArithmeticException if the fraction to divide by is zero
-     */
-    public BigFraction divide(final BigInteger bg) {
-        if (bg == null) {
-            throw new NullArgumentException(LocalizedFormats.FRACTION);
-        }
-        if (BigInteger.ZERO.equals(bg)) {
-            throw new MathArithmeticException(LocalizedFormats.ZERO_DENOMINATOR);
-        }
-        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 MathArithmeticException 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 MathArithmeticException 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 MathArithmeticException if the fraction to divide by is zero
-     */
-    public BigFraction divide(final BigFraction fraction) {
-        if (fraction == null) {
-            throw new NullArgumentException(LocalizedFormats.FRACTION);
-        }
-        if (BigInteger.ZERO.equals(fraction.numerator)) {
-            throw new MathArithmeticException(LocalizedFormats.ZERO_DENOMINATOR);
-        }
-
-        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.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).reduce();
-            BigFraction thisOne = this.reduce();
-            ret = thisOne.numerator.equals(rhs.numerator) && thisOne.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;
-    }
-
-    /**
-     * <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) {
-        if (bg == null) {
-            throw new NullArgumentException();
-        }
-        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.
-     */
-    public BigFraction multiply(final int i) {
-        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) {
-        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}.
-     */
-    public BigFraction multiply(final BigFraction fraction) {
-        if (fraction == null) {
-            throw new NullArgumentException(LocalizedFormats.FRACTION);
-        }
-        if (numerator.equals(BigInteger.ZERO) ||
-            fraction.numerator.equals(BigInteger.ZERO)) {
-            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.
-     */
-    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 <tt>this<sup>exponent</sup></tt>.
-     */
-    public BigFraction pow(final int exponent) {
-        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</code> whose value is
-     * <tt>(this<sup>exponent</sup>)</tt>, returning the result in reduced form.
-     * </p>
-     *
-     * @param exponent
-     *            exponent to which this <code>BigFraction</code> is to be raised.
-     * @return <tt>this<sup>exponent</sup></tt> as a <code>BigFraction</code>.
-     */
-    public BigFraction pow(final long exponent) {
-        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</code> whose value is
-     * <tt>(this<sup>exponent</sup>)</tt>, returning the result in reduced form.
-     * </p>
-     *
-     * @param exponent
-     *            exponent to which this <code>BigFraction</code> is to be raised.
-     * @return <tt>this<sup>exponent</sup></tt> as a <code>BigFraction</code>.
-     */
-    public BigFraction pow(final BigInteger exponent) {
-        if (exponent.compareTo(BigInteger.ZERO) < 0) {
-            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
-     * <tt>(this<sup>exponent</sup>)</tt>, returning the result in reduced form.
-     * </p>
-     *
-     * @param exponent
-     *            exponent to which this <code>BigFraction</code> is to be raised.
-     * @return <tt>this<sup>exponent</sup></tt>.
-     */
-    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.
-     */
-    public BigFraction reciprocal() {
-        return new BigFraction(denominator, numerator);
-    }
-
-    /**
-     * <p>
-     * Reduce this <code>BigFraction</code> to its lowest terms.
-     * </p>
-     *
-     * @return the reduced <code>BigFraction</code>. It doesn't change anything if
-     *         the fraction can be reduced.
-     */
-    public BigFraction reduce() {
-        final BigInteger gcd = numerator.gcd(denominator);
-        return new BigFraction(numerator.divide(gcd), denominator.divide(gcd));
-    }
-
-    /**
-     * <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) {
-        if (bg == null) {
-            throw new NullArgumentException();
-        }
-        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}.
-     */
-    public BigFraction subtract(final BigFraction fraction) {
-        if (fraction == null) {
-            throw new NullArgumentException(LocalizedFormats.FRACTION);
-        }
-        if (ZERO.equals(fraction)) {
-            return this;
-        }
-
-        BigInteger num = null;
-        BigInteger den = null;
-        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() {
-        String str = null;
-        if (BigInteger.ONE.equals(denominator)) {
-            str = numerator.toString();
-        } else if (BigInteger.ZERO.equals(numerator)) {
-            str = "0";
-        } else {
-            str = numerator + " / " + denominator;
-        }
-        return str;
-    }
-
-    /** {@inheritDoc} */
-    public BigFractionField getField() {
-        return BigFractionField.getInstance();
-    }
-
-}

http://git-wip-us.apache.org/repos/asf/commons-math/blob/a7b4803f/src/main/java/org/apache/commons/math3/fraction/BigFractionField.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math3/fraction/BigFractionField.java b/src/main/java/org/apache/commons/math3/fraction/BigFractionField.java
deleted file mode 100644
index 81170f8..0000000
--- a/src/main/java/org/apache/commons/math3/fraction/BigFractionField.java
+++ /dev/null
@@ -1,82 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.apache.commons.math3.fraction;
-
-import java.io.Serializable;
-
-import org.apache.commons.math3.Field;
-import org.apache.commons.math3.FieldElement;
-
-/**
- * Representation of the fractional numbers  without any overflow field.
- * <p>
- * This class is a singleton.
- * </p>
- * @see Fraction
- * @since 2.0
- */
-public class BigFractionField implements Field<BigFraction>, Serializable  {
-
-    /** Serializable version identifier */
-    private static final long serialVersionUID = -1699294557189741703L;
-
-    /** Private constructor for the singleton.
-     */
-    private BigFractionField() {
-    }
-
-    /** Get the unique instance.
-     * @return the unique instance
-     */
-    public static BigFractionField getInstance() {
-        return LazyHolder.INSTANCE;
-    }
-
-    /** {@inheritDoc} */
-    public BigFraction getOne() {
-        return BigFraction.ONE;
-    }
-
-    /** {@inheritDoc} */
-    public BigFraction getZero() {
-        return BigFraction.ZERO;
-    }
-
-    /** {@inheritDoc} */
-    public Class<? extends FieldElement<BigFraction>> getRuntimeClass() {
-        return BigFraction.class;
-    }
-    // CHECKSTYLE: stop HideUtilityClassConstructor
-    /** Holder for the instance.
-     * <p>We use here the Initialization On Demand Holder Idiom.</p>
-     */
-    private static class LazyHolder {
-        /** Cached field instance. */
-        private static final BigFractionField INSTANCE = new BigFractionField();
-    }
-    // CHECKSTYLE: resume HideUtilityClassConstructor
-
-    /** Handle deserialization of the singleton.
-     * @return the singleton instance
-     */
-    private Object readResolve() {
-        // return the singleton instance
-        return LazyHolder.INSTANCE;
-    }
-
-}

http://git-wip-us.apache.org/repos/asf/commons-math/blob/a7b4803f/src/main/java/org/apache/commons/math3/fraction/BigFractionFormat.java
----------------------------------------------------------------------
diff --git a/src/main/java/org/apache/commons/math3/fraction/BigFractionFormat.java b/src/main/java/org/apache/commons/math3/fraction/BigFractionFormat.java
deleted file mode 100644
index 196dcd5..0000000
--- a/src/main/java/org/apache/commons/math3/fraction/BigFractionFormat.java
+++ /dev/null
@@ -1,287 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements.  See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You under the Apache License, Version 2.0
- * (the "License"); you may not use this file except in compliance with
- * the License.  You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.apache.commons.math3.fraction;
-
-import java.io.Serializable;
-import java.math.BigInteger;
-import java.text.FieldPosition;
-import java.text.NumberFormat;
-import java.text.ParsePosition;
-import java.util.Locale;
-
-import org.apache.commons.math3.exception.MathIllegalArgumentException;
-import org.apache.commons.math3.exception.MathParseException;
-import org.apache.commons.math3.exception.util.LocalizedFormats;
-
-/**
- * Formats a BigFraction number in proper format or improper format.
- * <p>
- * The number format for each of the whole number, numerator and,
- * denominator can be configured.
- * </p>
- *
- * @since 2.0
- */
-public class BigFractionFormat extends AbstractFormat implements Serializable {
-
-    /** Serializable version identifier */
-    private static final long serialVersionUID = -2932167925527338976L;
-
-    /**
-     * Create an improper formatting instance with the default number format
-     * for the numerator and denominator.
-     */
-    public BigFractionFormat() {
-    }
-
-    /**
-     * Create an improper formatting instance with a custom number format for
-     * both the numerator and denominator.
-     * @param format the custom format for both the numerator and denominator.
-     */
-    public BigFractionFormat(final NumberFormat format) {
-        super(format);
-    }
-
-    /**
-     * Create an improper formatting instance with a custom number format for
-     * the numerator and a custom number format for the denominator.
-     * @param numeratorFormat the custom format for the numerator.
-     * @param denominatorFormat the custom format for the denominator.
-     */
-    public BigFractionFormat(final NumberFormat numeratorFormat,
-                             final NumberFormat denominatorFormat) {
-        super(numeratorFormat, denominatorFormat);
-    }
-
-    /**
-     * Get the set of locales for which complex formats are available.  This
-     * is the same set as the {@link NumberFormat} set.
-     * @return available complex format locales.
-     */
-    public static Locale[] getAvailableLocales() {
-        return NumberFormat.getAvailableLocales();
-    }
-
-    /**
-     * This static method calls formatBigFraction() on a default instance of
-     * BigFractionFormat.
-     *
-     * @param f BigFraction object to format
-     * @return A formatted BigFraction in proper form.
-     */
-    public static String formatBigFraction(final BigFraction f) {
-        return getImproperInstance().format(f);
-    }
-
-    /**
-     * Returns the default complex format for the current locale.
-     * @return the default complex format.
-     */
-    public static BigFractionFormat getImproperInstance() {
-        return getImproperInstance(Locale.getDefault());
-    }
-
-    /**
-     * Returns the default complex format for the given locale.
-     * @param locale the specific locale used by the format.
-     * @return the complex format specific to the given locale.
-     */
-    public static BigFractionFormat getImproperInstance(final Locale locale) {
-        return new BigFractionFormat(getDefaultNumberFormat(locale));
-    }
-
-    /**
-     * Returns the default complex format for the current locale.
-     * @return the default complex format.
-     */
-    public static BigFractionFormat getProperInstance() {
-        return getProperInstance(Locale.getDefault());
-    }
-
-    /**
-     * Returns the default complex format for the given locale.
-     * @param locale the specific locale used by the format.
-     * @return the complex format specific to the given locale.
-     */
-    public static BigFractionFormat getProperInstance(final Locale locale) {
-        return new ProperBigFractionFormat(getDefaultNumberFormat(locale));
-    }
-
-    /**
-     * Formats a {@link BigFraction} object to produce a string.  The BigFraction is
-     * output in improper format.
-     *
-     * @param BigFraction the object to format.
-     * @param toAppendTo where the text is to be appended
-     * @param pos On input: an alignment field, if desired. On output: the
-     *            offsets of the alignment field
-     * @return the value passed in as toAppendTo.
-     */
-    public StringBuffer format(final BigFraction BigFraction,
-                               final StringBuffer toAppendTo, final FieldPosition pos) {
-
-        pos.setBeginIndex(0);
-        pos.setEndIndex(0);
-
-        getNumeratorFormat().format(BigFraction.getNumerator(), toAppendTo, pos);
-        toAppendTo.append(" / ");
-        getDenominatorFormat().format(BigFraction.getDenominator(), toAppendTo, pos);
-
-        return toAppendTo;
-    }
-
-    /**
-     * Formats an object and appends the result to a StringBuffer.
-     * <code>obj</code> must be either a  {@link BigFraction} object or a
-     * {@link BigInteger} object or a {@link Number} object. Any other type of
-     * object will result in an {@link IllegalArgumentException} being thrown.
-     *
-     * @param obj the object to format.
-     * @param toAppendTo where the text is to be appended
-     * @param pos On input: an alignment field, if desired. On output: the
-     *            offsets of the alignment field
-     * @return the value passed in as toAppendTo.
-     * @see java.text.Format#format(java.lang.Object, java.lang.StringBuffer, java.text.FieldPosition)
-     * @throws MathIllegalArgumentException if <code>obj</code> is not a valid type.
-     */
-    @Override
-    public StringBuffer format(final Object obj,
-                               final StringBuffer toAppendTo, final FieldPosition pos) {
-
-        final StringBuffer ret;
-        if (obj instanceof BigFraction) {
-            ret = format((BigFraction) obj, toAppendTo, pos);
-        } else if (obj instanceof BigInteger) {
-            ret = format(new BigFraction((BigInteger) obj), toAppendTo, pos);
-        } else if (obj instanceof Number) {
-            ret = format(new BigFraction(((Number) obj).doubleValue()),
-                         toAppendTo, pos);
-        } else {
-            throw new MathIllegalArgumentException(LocalizedFormats.CANNOT_FORMAT_OBJECT_TO_FRACTION);
-        }
-
-        return ret;
-    }
-
-    /**
-     * Parses a string to produce a {@link BigFraction} object.
-     * @param source the string to parse
-     * @return the parsed {@link BigFraction} object.
-     * @exception MathParseException if the beginning of the specified string
-     *            cannot be parsed.
-     */
-    @Override
-    public BigFraction parse(final String source) throws MathParseException {
-        final ParsePosition parsePosition = new ParsePosition(0);
-        final BigFraction result = parse(source, parsePosition);
-        if (parsePosition.getIndex() == 0) {
-            throw new MathParseException(source, parsePosition.getErrorIndex(), BigFraction.class);
-        }
-        return result;
-    }
-
-    /**
-     * Parses a string to produce a {@link BigFraction} object.
-     * This method expects the string to be formatted as an improper BigFraction.
-     * @param source the string to parse
-     * @param pos input/output parsing parameter.
-     * @return the parsed {@link BigFraction} object.
-     */
-    @Override
-    public BigFraction parse(final String source, final ParsePosition pos) {
-        final int initialIndex = pos.getIndex();
-
-        // parse whitespace
-        parseAndIgnoreWhitespace(source, pos);
-
-        // parse numerator
-        final BigInteger num = parseNextBigInteger(source, pos);
-        if (num == null) {
-            // invalid integer number
-            // set index back to initial, error index should already be set
-            // character examined.
-            pos.setIndex(initialIndex);
-            return null;
-        }
-
-        // parse '/'
-        final int startIndex = pos.getIndex();
-        final char c = parseNextCharacter(source, pos);
-        switch (c) {
-        case 0 :
-            // no '/'
-            // return num as a BigFraction
-            return new BigFraction(num);
-        case '/' :
-            // found '/', continue parsing denominator
-            break;
-        default :
-            // invalid '/'
-            // set index back to initial, error index should be the last
-            // character examined.
-            pos.setIndex(initialIndex);
-            pos.setErrorIndex(startIndex);
-            return null;
-        }
-
-        // parse whitespace
-        parseAndIgnoreWhitespace(source, pos);
-
-        // parse denominator
-        final BigInteger den = parseNextBigInteger(source, pos);
-        if (den == null) {
-            // invalid integer number
-            // set index back to initial, error index should already be set
-            // character examined.
-            pos.setIndex(initialIndex);
-            return null;
-        }
-
-        return new BigFraction(num, den);
-    }
-
-    /**
-     * Parses a string to produce a <code>BigInteger</code>.
-     * @param source the string to parse
-     * @param pos input/output parsing parameter.
-     * @return a parsed <code>BigInteger</code> or null if string does not
-     * contain a BigInteger at the specified position
-     */
-    protected BigInteger parseNextBigInteger(final String source,
-                                             final ParsePosition pos) {
-
-        final int start = pos.getIndex();
-         int end = (source.charAt(start) == '-') ? (start + 1) : start;
-         while((end < source.length()) &&
-               Character.isDigit(source.charAt(end))) {
-             ++end;
-         }
-
-         try {
-             BigInteger n = new BigInteger(source.substring(start, end));
-             pos.setIndex(end);
-             return n;
-         } catch (NumberFormatException nfe) {
-             pos.setErrorIndex(start);
-             return null;
-         }
-
-    }
-
-}


Mime
View raw message