diff options
Diffstat (limited to 'src/main/java/org/apache/commons/math/fraction')
11 files changed, 3264 insertions, 0 deletions
diff --git a/src/main/java/org/apache/commons/math/fraction/AbstractFormat.java b/src/main/java/org/apache/commons/math/fraction/AbstractFormat.java new file mode 100644 index 0000000..c409702 --- /dev/null +++ b/src/main/java/org/apache/commons/math/fraction/AbstractFormat.java @@ -0,0 +1,210 @@ +/* + * 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.math.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.math.exception.NullArgumentException; +import org.apache.commons.math.exception.util.LocalizedFormats; + +/** + * Common part shared by both {@link FractionFormat} and {@link BigFractionFormat}. + * @version $Revision: 983921 $ $Date: 2010-08-10 12:46:06 +0200 (mar. 10 août 2010) $ + * @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. */ + protected NumberFormat denominatorFormat; + + /** The format used for the numerator. */ + protected 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)} with the only + * customizing 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)} with the only + * customizing 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/ouput 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/ouput 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); + } + +} diff --git a/src/main/java/org/apache/commons/math/fraction/BigFraction.java b/src/main/java/org/apache/commons/math/fraction/BigFraction.java new file mode 100644 index 0000000..98fa676 --- /dev/null +++ b/src/main/java/org/apache/commons/math/fraction/BigFraction.java @@ -0,0 +1,1129 @@ +/* + * 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.math.fraction; + +import java.io.Serializable; +import java.math.BigDecimal; +import java.math.BigInteger; + +import org.apache.commons.math.FieldElement; +import org.apache.commons.math.MathRuntimeException; +import org.apache.commons.math.exception.util.LocalizedFormats; +import org.apache.commons.math.util.MathUtils; +import org.apache.commons.math.util.FastMath; + +/** + * Representation of a rational number without any overflow. This class is + * immutable. + * + * @version $Revision: 1073687 $ $Date: 2011-02-23 11:39:25 +0100 (mer. 23 févr. 2011) $ + * @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_DOUBLE = BigInteger.valueOf(100); + + /** The numerator. */ + private final BigInteger numerator; + + /** The denominator. */ + private final BigInteger denominator; + + /** + * <p> + * Create a {@link BigFraction} equivalent to the passed <tt>BigInteger</tt>, 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 ArithmeticException if the denominator is zero. + */ + public BigFraction(BigInteger num, BigInteger den) { + if (num == null) { + throw new NullPointerException(LocalizedFormats.NUMERATOR.getSourceString()); + } + if (den == null) { + throw new NullPointerException(LocalizedFormats.DENOMINATOR.getSourceString()); + } + if (BigInteger.ZERO.equals(den)) { + throw MathRuntimeException.createArithmeticException(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 does work 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 IllegalArgumentException if value is NaN or infinite + */ + public BigFraction(final double value) throws IllegalArgumentException { + if (Double.isNaN(value)) { + throw MathRuntimeException.createIllegalArgumentException(LocalizedFormats.NAN_VALUE_CONVERSION); + } + if (Double.isInfinite(value)) { + throw MathRuntimeException.createIllegalArgumentException(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 = 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 (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)) { + 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 <tt>int</tt>, 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 + * <tt>int</tt>. 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 + * <tt>long</tt>. 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 NullPointerException + * if the {@link BigInteger} is <code>null</code>. + */ + public BigFraction add(final BigInteger bg) { + return new BigFraction(numerator.add(denominator.multiply(bg)), denominator); + } + + /** + * <p> + * Adds the value of this fraction to the passed <tt>integer</tt>, returning + * the result in reduced form. + * </p> + * + * @param i + * the <tt>integer</tt> 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 <tt>long</tt>, returning + * the result in reduced form. + * </p> + * + * @param l + * the <tt>long</tt> 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 NullPointerException if the {@link BigFraction} is {@code null}. + */ + public BigFraction add(final BigFraction fraction) { + if (fraction == null) { + throw new NullPointerException(LocalizedFormats.FRACTION.getSourceString()); + } + 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 <tt>roundingMode</tt> 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 <tt>object</tt>, +1 if this is greater + * than <tt>object</tt>, 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</code>, + * ie "this * 1 / bg", returning the result in reduced form. + * </p> + * + * @param bg + * the <code>BigInteger</code> to divide by, must not be + * <code>null</code>. + * @return a {@link BigFraction} instance with the resulting values. + * @throws NullPointerException if the {@code BigInteger} is {@code null}. + * @throws ArithmeticException + * if the fraction to divide by is zero. + */ + public BigFraction divide(final BigInteger bg) { + if (BigInteger.ZERO.equals(bg)) { + throw MathRuntimeException.createArithmeticException(LocalizedFormats.ZERO_DENOMINATOR); + } + return new BigFraction(numerator, denominator.multiply(bg)); + } + + /** + * <p> + * Divide the value of this fraction by the passed <tt>int</tt>, ie + * "this * 1 / i", returning the result in reduced form. + * </p> + * + * @param i + * the <tt>int</tt> to divide by. + * @return a {@link BigFraction} instance with the resulting values. + * @throws ArithmeticException + * 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 <tt>long</tt>, ie + * "this * 1 / l", returning the result in reduced form. + * </p> + * + * @param l + * the <tt>long</tt> to divide by. + * @return a {@link BigFraction} instance with the resulting values. + * @throws ArithmeticException + * 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 NullPointerException if the {@code fraction} is {@code null}. + * @throws ArithmeticException if the fraction to divide by is zero. + */ + public BigFraction divide(final BigFraction fraction) { + if (fraction == null) { + throw new NullPointerException(LocalizedFormats.FRACTION.getSourceString()); + } + if (BigInteger.ZERO.equals(fraction.numerator)) { + throw MathRuntimeException.createArithmeticException(LocalizedFormats.ZERO_DENOMINATOR); + } + + return multiply(fraction.reciprocal()); + } + + /** + * <p> + * Gets the fraction as a <tt>double</tt>. This calculates the fraction as + * the numerator divided by denominator. + * </p> + * + * @return the fraction as a <tt>double</tt> + * @see java.lang.Number#doubleValue() + */ + @Override + public double doubleValue() { + return numerator.doubleValue() / denominator.doubleValue(); + } + + /** + * <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 <tt>float</tt>. This calculates the fraction as + * the numerator divided by denominator. + * </p> + * + * @return the fraction as a <tt>float</tt>. + * @see java.lang.Number#floatValue() + */ + @Override + public float floatValue() { + return numerator.floatValue() / denominator.floatValue(); + } + + /** + * <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 <tt>int</tt>. + * </p> + * + * @return the denominator as a <tt>int</tt>. + */ + public int getDenominatorAsInt() { + return denominator.intValue(); + } + + /** + * <p> + * Access the denominator as a <tt>long</tt>. + * </p> + * + * @return the denominator as a <tt>long</tt>. + */ + 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 <tt>int</tt>. + * </p> + * + * @return the numerator as a <tt>int</tt>. + */ + public int getNumeratorAsInt() { + return numerator.intValue(); + } + + /** + * <p> + * Access the numerator as a <tt>long</tt>. + * </p> + * + * @return the numerator as a <tt>long</tt>. + */ + 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 <tt>int</tt>. 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 <tt>long</tt>. 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 NullPointerException if {@code bg} is {@code null}. + */ + public BigFraction multiply(final BigInteger bg) { + if (bg == null) { + throw new NullPointerException(); + } + return new BigFraction(bg.multiply(numerator), denominator); + } + + /** + * <p> + * Multiply the value of this fraction by the passed <tt>int</tt>, returning + * the result in reduced form. + * </p> + * + * @param i + * the <tt>int</tt> 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 <tt>long</tt>, + * returning the result in reduced form. + * </p> + * + * @param l + * the <tt>long</tt> 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 NullPointerException if {@code fraction} is {@code null}. + */ + public BigFraction multiply(final BigFraction fraction) { + if (fraction == null) { + throw new NullPointerException(LocalizedFormats.FRACTION.getSourceString()); + } + 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 <tt>double</tt>. This calculates the + * fraction as the numerator divided by denominator multiplied by 100. + * </p> + * + * @return the fraction percentage as a <tt>double</tt>. + */ + public double percentageValue() { + return (numerator.divide(denominator)).multiply(ONE_HUNDRED_DOUBLE).doubleValue(); + } + + /** + * <p> + * Returns a <tt>integer</tt> whose value is + * <tt>(this<sup>exponent</sup>)</tt>, returning the result in reduced form. + * </p> + * + * @param exponent + * exponent to which this <code>BigInteger</code> 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(MathUtils.pow(denominator, -exponent), + MathUtils.pow(numerator, -exponent)); + } + return new BigFraction(MathUtils.pow(numerator, exponent), + MathUtils.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(MathUtils.pow(denominator, eNeg), + MathUtils.pow(numerator, eNeg)); + } + return new BigFraction(MathUtils.pow(numerator, exponent), + MathUtils.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 one, + * 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 NullPointerException if the {@link BigInteger} is {@code null}. + */ + public BigFraction subtract(final BigInteger bg) { + if (bg == null) { + throw new NullPointerException(); + } + return new BigFraction(numerator.subtract(denominator.multiply(bg)), denominator); + } + + /** + * <p> + * Subtracts the value of an <tt>integer</tt> from the value of this one, + * returning the result in reduced form. + * </p> + * + * @param i + * the <tt>integer</tt> to subtract. + * @return a <code>BigFraction</code> instance with the resulting values. + */ + public BigFraction subtract(final int i) { + return subtract(BigInteger.valueOf(i)); + } + + /** + * <p> + * Subtracts the value of an <tt>integer</tt> from the value of this one, + * returning the result in reduced form. + * </p> + * + * @param l + * the <tt>long</tt> to subtract. + * @return a <code>BigFraction</code> instance with the resulting values, or + * this object if the <tt>long</tt> is zero. + */ + 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 NullPointerException if the {@code fraction} is {@code null}. + */ + public BigFraction subtract(final BigFraction fraction) { + if (fraction == null) { + throw new NullPointerException(LocalizedFormats.FRACTION.getSourceString()); + } + 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(); + } + +} diff --git a/src/main/java/org/apache/commons/math/fraction/BigFractionField.java b/src/main/java/org/apache/commons/math/fraction/BigFractionField.java new file mode 100644 index 0000000..bc3a7e9 --- /dev/null +++ b/src/main/java/org/apache/commons/math/fraction/BigFractionField.java @@ -0,0 +1,78 @@ +/* + * 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.math.fraction; + +import java.io.Serializable; + +import org.apache.commons.math.Field; + +/** + * Representation of the fractional numbers without any overflow field. + * <p> + * This class is a singleton. + * </p> + * @see Fraction + * @version $Revision: 811827 $ $Date: 2009-09-06 17:32:50 +0200 (dim. 06 sept. 2009) $ + * @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; + } + + // 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; + } + +} diff --git a/src/main/java/org/apache/commons/math/fraction/BigFractionFormat.java b/src/main/java/org/apache/commons/math/fraction/BigFractionFormat.java new file mode 100644 index 0000000..918e5e1 --- /dev/null +++ b/src/main/java/org/apache/commons/math/fraction/BigFractionFormat.java @@ -0,0 +1,291 @@ +/* + * 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.math.fraction; + +import java.io.Serializable; +import java.math.BigInteger; +import java.text.FieldPosition; +import java.text.NumberFormat; +import java.text.ParseException; +import java.text.ParsePosition; +import java.util.Locale; + +import org.apache.commons.math.MathRuntimeException; +import org.apache.commons.math.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 + * @version $Revision: 983921 $ $Date: 2010-08-10 12:46:06 +0200 (mar. 10 août 2010) $ + */ +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 IllegalArgumentException is <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 MathRuntimeException.createIllegalArgumentException( + 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 ParseException if the beginning of the specified string + * cannot be parsed. + */ + @Override + public BigFraction parse(final String source) throws ParseException { + final ParsePosition parsePosition = new ParsePosition(0); + final BigFraction result = parse(source, parsePosition); + if (parsePosition.getIndex() == 0) { + throw MathRuntimeException.createParseException( + parsePosition.getErrorIndex(), + LocalizedFormats.UNPARSEABLE_FRACTION_NUMBER, source); + } + 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/ouput 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/ouput 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; + } + + } + +} diff --git a/src/main/java/org/apache/commons/math/fraction/Fraction.java b/src/main/java/org/apache/commons/math/fraction/Fraction.java new file mode 100644 index 0000000..82ecf63 --- /dev/null +++ b/src/main/java/org/apache/commons/math/fraction/Fraction.java @@ -0,0 +1,655 @@ +/* + * 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.math.fraction; + +import java.io.Serializable; +import java.math.BigInteger; + +import org.apache.commons.math.FieldElement; +import org.apache.commons.math.MathRuntimeException; +import org.apache.commons.math.exception.util.LocalizedFormats; +import org.apache.commons.math.exception.NullArgumentException; +import org.apache.commons.math.util.MathUtils; +import org.apache.commons.math.util.FastMath; + +/** + * Representation of a rational number. + * + * implements Serializable since 2.0 + * + * @since 1.1 + * @version $Revision: 990655 $ $Date: 2010-08-29 23:49:40 +0200 (dim. 29 août 2010) $ + */ +public class Fraction + extends Number + implements FieldElement<Fraction>, Comparable<Fraction>, Serializable { + + /** A fraction representing "2 / 1". */ + public static final Fraction TWO = new Fraction(2, 1); + + /** A fraction representing "1". */ + public static final Fraction ONE = new Fraction(1, 1); + + /** A fraction representing "0". */ + public static final Fraction ZERO = new Fraction(0, 1); + + /** A fraction representing "4/5". */ + public static final Fraction FOUR_FIFTHS = new Fraction(4, 5); + + /** A fraction representing "1/5". */ + public static final Fraction ONE_FIFTH = new Fraction(1, 5); + + /** A fraction representing "1/2". */ + public static final Fraction ONE_HALF = new Fraction(1, 2); + + /** A fraction representing "1/4". */ + public static final Fraction ONE_QUARTER = new Fraction(1, 4); + + /** A fraction representing "1/3". */ + public static final Fraction ONE_THIRD = new Fraction(1, 3); + + /** A fraction representing "3/5". */ + public static final Fraction THREE_FIFTHS = new Fraction(3, 5); + + /** A fraction representing "3/4". */ + public static final Fraction THREE_QUARTERS = new Fraction(3, 4); + + /** A fraction representing "2/5". */ + public static final Fraction TWO_FIFTHS = new Fraction(2, 5); + + /** A fraction representing "2/4". */ + public static final Fraction TWO_QUARTERS = new Fraction(2, 4); + + /** A fraction representing "2/3". */ + public static final Fraction TWO_THIRDS = new Fraction(2, 3); + + /** A fraction representing "-1 / 1". */ + public static final Fraction MINUS_ONE = new Fraction(-1, 1); + + /** Serializable version identifier */ + private static final long serialVersionUID = 3698073679419233275L; + + /** The denominator. */ + private final int denominator; + + /** The numerator. */ + private final int numerator; + + /** + * Create a fraction given the double value. + * @param value the double value to convert to a fraction. + * @throws FractionConversionException if the continued fraction failed to + * converge. + */ + public Fraction(double value) throws FractionConversionException { + this(value, 1.0e-5, 100); + } + + /** + * 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. + */ + public Fraction(double value, double epsilon, int maxIterations) + throws FractionConversionException + { + this(value, epsilon, Integer.MAX_VALUE, maxIterations); + } + + /** + * 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 Fraction(double value, int maxDenominator) + throws FractionConversionException + { + this(value, 0, maxDenominator, 100); + } + + /** + * 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 Fraction(double value, double epsilon, int maxDenominator, int maxIterations) + throws FractionConversionException + { + long overflow = Integer.MAX_VALUE; + double r0 = value; + long a0 = (long)FastMath.floor(r0); + if (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) { + this.numerator = (int) a0; + this.denominator = 1; + 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; + double r1 = 1.0 / (r0 - a0); + long a1 = (long)FastMath.floor(r1); + p2 = (a1 * p1) + p0; + q2 = (a1 * q1) + q0; + if ((p2 > overflow) || (q2 > overflow)) { + throw new FractionConversionException(value, p2, q2); + } + + 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) { + this.numerator = (int) p2; + this.denominator = (int) q2; + } else { + this.numerator = (int) p1; + this.denominator = (int) q1; + } + + } + + /** + * Create a fraction from an int. + * The fraction is num / 1. + * @param num the numerator. + */ + public Fraction(int num) { + this(num, 1); + } + + /** + * Create a fraction given the numerator and denominator. The fraction is + * reduced to lowest terms. + * @param num the numerator. + * @param den the denominator. + * @throws ArithmeticException if the denominator is <code>zero</code> + */ + public Fraction(int num, int den) { + if (den == 0) { + throw MathRuntimeException.createArithmeticException( + LocalizedFormats.ZERO_DENOMINATOR_IN_FRACTION, num, den); + } + if (den < 0) { + if (num == Integer.MIN_VALUE || den == Integer.MIN_VALUE) { + throw MathRuntimeException.createArithmeticException( + LocalizedFormats.OVERFLOW_IN_FRACTION, num, den); + } + num = -num; + den = -den; + } + // reduce numerator and denominator by greatest common denominator. + final int d = MathUtils.gcd(num, den); + if (d > 1) { + num /= d; + den /= d; + } + + // move sign to numerator. + if (den < 0) { + num = -num; + den = -den; + } + this.numerator = num; + this.denominator = den; + } + + /** + * Returns the absolute value of this fraction. + * @return the absolute value. + */ + public Fraction abs() { + Fraction ret; + if (numerator >= 0) { + ret = this; + } else { + ret = negate(); + } + return ret; + } + + /** + * Compares this object to another based on size. + * @param object the object to compare to + * @return -1 if this is less than <tt>object</tt>, +1 if this is greater + * than <tt>object</tt>, 0 if they are equal. + */ + public int compareTo(Fraction object) { + long nOd = ((long) numerator) * object.denominator; + long dOn = ((long) denominator) * object.numerator; + return (nOd < dOn) ? -1 : ((nOd > dOn) ? +1 : 0); + } + + /** + * Gets the fraction as a <tt>double</tt>. This calculates the fraction as + * the numerator divided by denominator. + * @return the fraction as a <tt>double</tt> + */ + @Override + public double doubleValue() { + return (double)numerator / (double)denominator; + } + + /** + * 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. + * @param other fraction to test for equality to this fraction + * @return true if two fractions are equal, false if object is + * <tt>null</tt>, not an instance of {@link Fraction}, or not equal + * to this fraction instance. + */ + @Override + public boolean equals(Object other) { + if (this == other) { + return true; + } + if (other instanceof Fraction) { + // since fractions are always in lowest terms, numerators and + // denominators can be compared directly for equality. + Fraction rhs = (Fraction)other; + return (numerator == rhs.numerator) && + (denominator == rhs.denominator); + } + return false; + } + + /** + * Gets the fraction as a <tt>float</tt>. This calculates the fraction as + * the numerator divided by denominator. + * @return the fraction as a <tt>float</tt> + */ + @Override + public float floatValue() { + return (float)doubleValue(); + } + + /** + * Access the denominator. + * @return the denominator. + */ + public int getDenominator() { + return denominator; + } + + /** + * Access the numerator. + * @return the numerator. + */ + public int getNumerator() { + return numerator; + } + + /** + * Gets a hashCode for the fraction. + * @return a hash code value for this object + */ + @Override + public int hashCode() { + return 37 * (37 * 17 + numerator) + denominator; + } + + /** + * Gets the fraction as an <tt>int</tt>. This returns the whole number part + * of the fraction. + * @return the whole number fraction part + */ + @Override + public int intValue() { + return (int)doubleValue(); + } + + /** + * Gets the fraction as a <tt>long</tt>. This returns the whole number part + * of the fraction. + * @return the whole number fraction part + */ + @Override + public long longValue() { + return (long)doubleValue(); + } + + /** + * Return the additive inverse of this fraction. + * @return the negation of this fraction. + */ + public Fraction negate() { + if (numerator==Integer.MIN_VALUE) { + throw MathRuntimeException.createArithmeticException( + LocalizedFormats.OVERFLOW_IN_FRACTION, numerator, denominator); + } + return new Fraction(-numerator, denominator); + } + + /** + * Return the multiplicative inverse of this fraction. + * @return the reciprocal fraction + */ + public Fraction reciprocal() { + return new Fraction(denominator, numerator); + } + + /** + * <p>Adds the value of this fraction to another, returning the result in reduced form. + * The algorithm follows Knuth, 4.5.1.</p> + * + * @param fraction the fraction to add, must not be <code>null</code> + * @return a <code>Fraction</code> instance with the resulting values + * @throws IllegalArgumentException if the fraction is <code>null</code> + * @throws ArithmeticException if the resulting numerator or denominator exceeds + * <code>Integer.MAX_VALUE</code> + */ + public Fraction add(Fraction fraction) { + return addSub(fraction, true /* add */); + } + + /** + * Add an integer to the fraction. + * @param i the <tt>integer</tt> to add. + * @return this + i + */ + public Fraction add(final int i) { + return new Fraction(numerator + i * denominator, denominator); + } + + /** + * <p>Subtracts the value of another fraction from the value of this one, + * returning the result in reduced form.</p> + * + * @param fraction the fraction to subtract, must not be <code>null</code> + * @return a <code>Fraction</code> instance with the resulting values + * @throws IllegalArgumentException if the fraction is <code>null</code> + * @throws ArithmeticException if the resulting numerator or denominator + * cannot be represented in an <code>int</code>. + */ + public Fraction subtract(Fraction fraction) { + return addSub(fraction, false /* subtract */); + } + + /** + * Subtract an integer from the fraction. + * @param i the <tt>integer</tt> to subtract. + * @return this - i + */ + public Fraction subtract(final int i) { + return new Fraction(numerator - i * denominator, denominator); + } + + /** + * Implement add and subtract using algorithm described in Knuth 4.5.1. + * + * @param fraction the fraction to subtract, must not be <code>null</code> + * @param isAdd true to add, false to subtract + * @return a <code>Fraction</code> instance with the resulting values + * @throws IllegalArgumentException if the fraction is <code>null</code> + * @throws ArithmeticException if the resulting numerator or denominator + * cannot be represented in an <code>int</code>. + */ + private Fraction addSub(Fraction fraction, boolean isAdd) { + if (fraction == null) { + throw new NullArgumentException(LocalizedFormats.FRACTION); + } + // zero is identity for addition. + if (numerator == 0) { + return isAdd ? fraction : fraction.negate(); + } + if (fraction.numerator == 0) { + return this; + } + // if denominators are randomly distributed, d1 will be 1 about 61% + // of the time. + int d1 = MathUtils.gcd(denominator, fraction.denominator); + if (d1==1) { + // result is ( (u*v' +/- u'v) / u'v') + int uvp = MathUtils.mulAndCheck(numerator, fraction.denominator); + int upv = MathUtils.mulAndCheck(fraction.numerator, denominator); + return new Fraction + (isAdd ? MathUtils.addAndCheck(uvp, upv) : + MathUtils.subAndCheck(uvp, upv), + MathUtils.mulAndCheck(denominator, fraction.denominator)); + } + // the quantity 't' requires 65 bits of precision; see knuth 4.5.1 + // exercise 7. we're going to use a BigInteger. + // t = u(v'/d1) +/- v(u'/d1) + BigInteger uvp = BigInteger.valueOf(numerator) + .multiply(BigInteger.valueOf(fraction.denominator/d1)); + BigInteger upv = BigInteger.valueOf(fraction.numerator) + .multiply(BigInteger.valueOf(denominator/d1)); + BigInteger t = isAdd ? uvp.add(upv) : uvp.subtract(upv); + // but d2 doesn't need extra precision because + // d2 = gcd(t,d1) = gcd(t mod d1, d1) + int tmodd1 = t.mod(BigInteger.valueOf(d1)).intValue(); + int d2 = (tmodd1==0)?d1:MathUtils.gcd(tmodd1, d1); + + // result is (t/d2) / (u'/d1)(v'/d2) + BigInteger w = t.divide(BigInteger.valueOf(d2)); + if (w.bitLength() > 31) { + throw MathRuntimeException.createArithmeticException(LocalizedFormats.NUMERATOR_OVERFLOW_AFTER_MULTIPLY, + w); + } + return new Fraction (w.intValue(), + MathUtils.mulAndCheck(denominator/d1, + fraction.denominator/d2)); + } + + /** + * <p>Multiplies the value of this fraction by another, returning the + * result in reduced form.</p> + * + * @param fraction the fraction to multiply by, must not be <code>null</code> + * @return a <code>Fraction</code> instance with the resulting values + * @throws IllegalArgumentException if the fraction is <code>null</code> + * @throws ArithmeticException if the resulting numerator or denominator exceeds + * <code>Integer.MAX_VALUE</code> + */ + public Fraction multiply(Fraction fraction) { + if (fraction == null) { + throw new NullArgumentException(LocalizedFormats.FRACTION); + } + if (numerator == 0 || fraction.numerator == 0) { + return ZERO; + } + // knuth 4.5.1 + // make sure we don't overflow unless the result *must* overflow. + int d1 = MathUtils.gcd(numerator, fraction.denominator); + int d2 = MathUtils.gcd(fraction.numerator, denominator); + return getReducedFraction + (MathUtils.mulAndCheck(numerator/d1, fraction.numerator/d2), + MathUtils.mulAndCheck(denominator/d2, fraction.denominator/d1)); + } + + /** + * Multiply the fraction by an integer. + * @param i the <tt>integer</tt> to multiply by. + * @return this * i + */ + public Fraction multiply(final int i) { + return new Fraction(numerator * i, denominator); + } + + /** + * <p>Divide the value of this fraction by another.</p> + * + * @param fraction the fraction to divide by, must not be <code>null</code> + * @return a <code>Fraction</code> instance with the resulting values + * @throws IllegalArgumentException if the fraction is <code>null</code> + * @throws ArithmeticException if the fraction to divide by is zero + * @throws ArithmeticException if the resulting numerator or denominator exceeds + * <code>Integer.MAX_VALUE</code> + */ + public Fraction divide(Fraction fraction) { + if (fraction == null) { + throw new NullArgumentException(LocalizedFormats.FRACTION); + } + if (fraction.numerator == 0) { + throw MathRuntimeException.createArithmeticException( + LocalizedFormats.ZERO_FRACTION_TO_DIVIDE_BY, + fraction.numerator, fraction.denominator); + } + return multiply(fraction.reciprocal()); + } + + /** + * Divide the fraction by an integer. + * @param i the <tt>integer</tt> to divide by. + * @return this * i + */ + public Fraction divide(final int i) { + return new Fraction(numerator, denominator * i); + } + + /** + * <p>Creates a <code>Fraction</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 Fraction getReducedFraction(int numerator, int denominator) { + if (denominator == 0) { + throw MathRuntimeException.createArithmeticException( + LocalizedFormats.ZERO_DENOMINATOR_IN_FRACTION, numerator, denominator); + } + if (numerator==0) { + return ZERO; // normalize zero. + } + // allow 2^k/-2^31 as a valid fraction (where k>0) + if (denominator==Integer.MIN_VALUE && (numerator&1)==0) { + numerator/=2; denominator/=2; + } + if (denominator < 0) { + if (numerator==Integer.MIN_VALUE || + denominator==Integer.MIN_VALUE) { + throw MathRuntimeException.createArithmeticException( + LocalizedFormats.OVERFLOW_IN_FRACTION, numerator, denominator); + } + numerator = -numerator; + denominator = -denominator; + } + // simplify fraction. + int gcd = MathUtils.gcd(numerator, denominator); + numerator /= gcd; + denominator /= gcd; + return new Fraction(numerator, denominator); + } + + /** + * <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 (denominator == 1) { + str = Integer.toString(numerator); + } else if (numerator == 0) { + str = "0"; + } else { + str = numerator + " / " + denominator; + } + return str; + } + + /** {@inheritDoc} */ + public FractionField getField() { + return FractionField.getInstance(); + } + +} diff --git a/src/main/java/org/apache/commons/math/fraction/FractionConversionException.java b/src/main/java/org/apache/commons/math/fraction/FractionConversionException.java new file mode 100644 index 0000000..9c99fcd --- /dev/null +++ b/src/main/java/org/apache/commons/math/fraction/FractionConversionException.java @@ -0,0 +1,56 @@ +/* + * 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.math.fraction; + +import org.apache.commons.math.ConvergenceException; +import org.apache.commons.math.exception.util.LocalizedFormats; + +/** + * Error thrown when a double value cannot be converted to a fraction + * in the allowed number of iterations. + * + * @version $Revision: 983921 $ $Date: 2010-08-10 12:46:06 +0200 (mar. 10 août 2010) $ + * @since 1.2 + */ +public class FractionConversionException extends ConvergenceException { + + /** Serializable version identifier. */ + private static final long serialVersionUID = -4661812640132576263L; + + /** + * Constructs an exception with specified formatted detail message. + * Message formatting is delegated to {@link java.text.MessageFormat}. + * @param value double value to convert + * @param maxIterations maximal number of iterations allowed + */ + public FractionConversionException(double value, int maxIterations) { + super(LocalizedFormats.FAILED_FRACTION_CONVERSION, value, maxIterations); + } + + /** + * Constructs an exception with specified formatted detail message. + * Message formatting is delegated to {@link java.text.MessageFormat}. + * @param value double value to convert + * @param p current numerator + * @param q current denominator + */ + public FractionConversionException(double value, long p, long q) { + super(LocalizedFormats.FRACTION_CONVERSION_OVERFLOW, value, p, q); + } + +} diff --git a/src/main/java/org/apache/commons/math/fraction/FractionField.java b/src/main/java/org/apache/commons/math/fraction/FractionField.java new file mode 100644 index 0000000..e6d7c47 --- /dev/null +++ b/src/main/java/org/apache/commons/math/fraction/FractionField.java @@ -0,0 +1,78 @@ +/* + * 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.math.fraction; + +import java.io.Serializable; + +import org.apache.commons.math.Field; + +/** + * Representation of the fractional numbers field. + * <p> + * This class is a singleton. + * </p> + * @see Fraction + * @version $Revision: 811827 $ $Date: 2009-09-06 17:32:50 +0200 (dim. 06 sept. 2009) $ + * @since 2.0 + */ +public class FractionField implements Field<Fraction>, Serializable { + + /** Serializable version identifier */ + private static final long serialVersionUID = -1257768487499119313L; + + /** Private constructor for the singleton. + */ + private FractionField() { + } + + /** Get the unique instance. + * @return the unique instance + */ + public static FractionField getInstance() { + return LazyHolder.INSTANCE; + } + + /** {@inheritDoc} */ + public Fraction getOne() { + return Fraction.ONE; + } + + /** {@inheritDoc} */ + public Fraction getZero() { + return Fraction.ZERO; + } + + // 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 FractionField INSTANCE = new FractionField(); + } + // CHECKSTYLE: resume HideUtilityClassConstructor + + /** Handle deserialization of the singleton. + * @return the singleton instance + */ + private Object readResolve() { + // return the singleton instance + return LazyHolder.INSTANCE; + } + +} diff --git a/src/main/java/org/apache/commons/math/fraction/FractionFormat.java b/src/main/java/org/apache/commons/math/fraction/FractionFormat.java new file mode 100644 index 0000000..b84f7cd --- /dev/null +++ b/src/main/java/org/apache/commons/math/fraction/FractionFormat.java @@ -0,0 +1,274 @@ +/* + * 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.math.fraction; + +import java.text.FieldPosition; +import java.text.NumberFormat; +import java.text.ParseException; +import java.text.ParsePosition; +import java.util.Locale; + +import org.apache.commons.math.ConvergenceException; +import org.apache.commons.math.MathRuntimeException; +import org.apache.commons.math.exception.util.LocalizedFormats; + +/** + * Formats a Fraction number in proper format or improper format. The number + * format for each of the whole number, numerator and, denominator can be + * configured. + * + * @since 1.1 + * @version $Revision: 983921 $ $Date: 2010-08-10 12:46:06 +0200 (mar. 10 août 2010) $ + */ +public class FractionFormat extends AbstractFormat { + + /** Serializable version identifier */ + private static final long serialVersionUID = 3008655719530972611L; + + /** + * Create an improper formatting instance with the default number format + * for the numerator and denominator. + */ + public FractionFormat() { + } + + /** + * 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 FractionFormat(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 FractionFormat(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 formatFraction() on a default instance of + * FractionFormat. + * + * @param f Fraction object to format + * @return A formatted fraction in proper form. + */ + public static String formatFraction(Fraction f) { + return getImproperInstance().format(f); + } + + /** + * Returns the default complex format for the current locale. + * @return the default complex format. + */ + public static FractionFormat 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 FractionFormat getImproperInstance(final Locale locale) { + return new FractionFormat(getDefaultNumberFormat(locale)); + } + + /** + * Returns the default complex format for the current locale. + * @return the default complex format. + */ + public static FractionFormat 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 FractionFormat getProperInstance(final Locale locale) { + return new ProperFractionFormat(getDefaultNumberFormat(locale)); + } + + /** + * Create a default number format. The default number format is based on + * {@link NumberFormat#getNumberInstance(java.util.Locale)} with the only + * customizing is the maximum number of fraction digits, which is set to 0. + * @return the default number format. + */ + protected static NumberFormat getDefaultNumberFormat() { + return getDefaultNumberFormat(Locale.getDefault()); + } + + /** + * Formats a {@link Fraction} object to produce a string. The fraction is + * output in improper format. + * + * @param fraction 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 Fraction fraction, + final StringBuffer toAppendTo, final FieldPosition pos) { + + pos.setBeginIndex(0); + pos.setEndIndex(0); + + getNumeratorFormat().format(fraction.getNumerator(), toAppendTo, pos); + toAppendTo.append(" / "); + getDenominatorFormat().format(fraction.getDenominator(), toAppendTo, + pos); + + return toAppendTo; + } + + /** + * Formats an object and appends the result to a StringBuffer. <code>obj</code> must be either a + * {@link Fraction} 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 IllegalArgumentException is <code>obj</code> is not a valid type. + */ + @Override + public StringBuffer format(final Object obj, + final StringBuffer toAppendTo, final FieldPosition pos) { + StringBuffer ret = null; + + if (obj instanceof Fraction) { + ret = format((Fraction) obj, toAppendTo, pos); + } else if (obj instanceof Number) { + try { + ret = format(new Fraction(((Number) obj).doubleValue()), + toAppendTo, pos); + } catch (ConvergenceException ex) { + throw MathRuntimeException.createIllegalArgumentException( + LocalizedFormats.CANNOT_CONVERT_OBJECT_TO_FRACTION, + ex.getLocalizedMessage()); + } + } else { + throw MathRuntimeException.createIllegalArgumentException( + LocalizedFormats.CANNOT_FORMAT_OBJECT_TO_FRACTION); + } + + return ret; + } + + /** + * Parses a string to produce a {@link Fraction} object. + * @param source the string to parse + * @return the parsed {@link Fraction} object. + * @exception ParseException if the beginning of the specified string + * cannot be parsed. + */ + @Override + public Fraction parse(final String source) throws ParseException { + final ParsePosition parsePosition = new ParsePosition(0); + final Fraction result = parse(source, parsePosition); + if (parsePosition.getIndex() == 0) { + throw MathRuntimeException.createParseException( + parsePosition.getErrorIndex(), + LocalizedFormats.UNPARSEABLE_FRACTION_NUMBER, source); + } + return result; + } + + /** + * Parses a string to produce a {@link Fraction} object. This method + * expects the string to be formatted as an improper fraction. + * @param source the string to parse + * @param pos input/ouput parsing parameter. + * @return the parsed {@link Fraction} object. + */ + @Override + public Fraction parse(final String source, final ParsePosition pos) { + final int initialIndex = pos.getIndex(); + + // parse whitespace + parseAndIgnoreWhitespace(source, pos); + + // parse numerator + final Number num = getNumeratorFormat().parse(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 fraction + return new Fraction(num.intValue(), 1); + 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 Number den = getDenominatorFormat().parse(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 Fraction(num.intValue(), den.intValue()); + } + +} diff --git a/src/main/java/org/apache/commons/math/fraction/ProperBigFractionFormat.java b/src/main/java/org/apache/commons/math/fraction/ProperBigFractionFormat.java new file mode 100644 index 0000000..398f565 --- /dev/null +++ b/src/main/java/org/apache/commons/math/fraction/ProperBigFractionFormat.java @@ -0,0 +1,239 @@ +/* + * 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.math.fraction; + +import java.math.BigInteger; +import java.text.FieldPosition; +import java.text.NumberFormat; +import java.text.ParsePosition; + +import org.apache.commons.math.exception.util.LocalizedFormats; +import org.apache.commons.math.exception.NullArgumentException; + +/** + * Formats a BigFraction number in proper format. The number format for each of + * the whole number, numerator and, denominator can be configured. + * <p> + * Minus signs are only allowed in the whole number part - i.e., + * "-3 1/2" is legitimate and denotes -7/2, but "-3 -1/2" is invalid and + * will result in a <code>ParseException</code>.</p> + * + * @since 1.1 + * @version $Revision: 983921 $ $Date: 2010-08-10 12:46:06 +0200 (mar. 10 août 2010) $ + */ +public class ProperBigFractionFormat extends BigFractionFormat { + + /** Serializable version identifier */ + private static final long serialVersionUID = -6337346779577272307L; + + /** The format used for the whole number. */ + private NumberFormat wholeFormat; + + /** + * Create a proper formatting instance with the default number format for + * the whole, numerator, and denominator. + */ + public ProperBigFractionFormat() { + this(getDefaultNumberFormat()); + } + + /** + * Create a proper formatting instance with a custom number format for the + * whole, numerator, and denominator. + * @param format the custom format for the whole, numerator, and + * denominator. + */ + public ProperBigFractionFormat(final NumberFormat format) { + this(format, (NumberFormat)format.clone(), (NumberFormat)format.clone()); + } + + /** + * Create a proper formatting instance with a custom number format for each + * of the whole, numerator, and denominator. + * @param wholeFormat the custom format for the whole. + * @param numeratorFormat the custom format for the numerator. + * @param denominatorFormat the custom format for the denominator. + */ + public ProperBigFractionFormat(final NumberFormat wholeFormat, + final NumberFormat numeratorFormat, + final NumberFormat denominatorFormat) { + super(numeratorFormat, denominatorFormat); + setWholeFormat(wholeFormat); + } + + /** + * Formats a {@link BigFraction} object to produce a string. The BigFraction + * is output in proper format. + * + * @param fraction 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. + */ + @Override + public StringBuffer format(final BigFraction fraction, + final StringBuffer toAppendTo, final FieldPosition pos) { + + pos.setBeginIndex(0); + pos.setEndIndex(0); + + BigInteger num = fraction.getNumerator(); + BigInteger den = fraction.getDenominator(); + BigInteger whole = num.divide(den); + num = num.remainder(den); + + if (!BigInteger.ZERO.equals(whole)) { + getWholeFormat().format(whole, toAppendTo, pos); + toAppendTo.append(' '); + if (num.compareTo(BigInteger.ZERO) < 0) { + num = num.negate(); + } + } + getNumeratorFormat().format(num, toAppendTo, pos); + toAppendTo.append(" / "); + getDenominatorFormat().format(den, toAppendTo, pos); + + return toAppendTo; + } + + /** + * Access the whole format. + * @return the whole format. + */ + public NumberFormat getWholeFormat() { + return wholeFormat; + } + + /** + * Parses a string to produce a {@link BigFraction} object. This method + * expects the string to be formatted as a proper BigFraction. + * <p> + * Minus signs are only allowed in the whole number part - i.e., + * "-3 1/2" is legitimate and denotes -7/2, but "-3 -1/2" is invalid and + * will result in a <code>ParseException</code>.</p> + * + * @param source the string to parse + * @param pos input/ouput parsing parameter. + * @return the parsed {@link BigFraction} object. + */ + @Override + public BigFraction parse(final String source, final ParsePosition pos) { + // try to parse improper BigFraction + BigFraction ret = super.parse(source, pos); + if (ret != null) { + return ret; + } + + final int initialIndex = pos.getIndex(); + + // parse whitespace + parseAndIgnoreWhitespace(source, pos); + + // parse whole + BigInteger whole = parseNextBigInteger(source, pos); + if (whole == null) { + // invalid integer number + // set index back to initial, error index should already be set + // character examined. + pos.setIndex(initialIndex); + return null; + } + + // parse whitespace + parseAndIgnoreWhitespace(source, pos); + + // parse numerator + 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; + } + + if (num.compareTo(BigInteger.ZERO) < 0) { + // minus signs should be leading, invalid expression + 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; + } + + if (den.compareTo(BigInteger.ZERO) < 0) { + // minus signs must be leading, invalid + pos.setIndex(initialIndex); + return null; + } + + boolean wholeIsNeg = whole.compareTo(BigInteger.ZERO) < 0; + if (wholeIsNeg) { + whole = whole.negate(); + } + num = whole.multiply(den).add(num); + if (wholeIsNeg) { + num = num.negate(); + } + + return new BigFraction(num, den); + + } + + /** + * Modify the whole format. + * @param format The new whole format value. + * @throws NullArgumentException if {@code format} is {@code null}. + */ + public void setWholeFormat(final NumberFormat format) { + if (format == null) { + throw new NullArgumentException(LocalizedFormats.WHOLE_FORMAT); + } + this.wholeFormat = format; + } +} diff --git a/src/main/java/org/apache/commons/math/fraction/ProperFractionFormat.java b/src/main/java/org/apache/commons/math/fraction/ProperFractionFormat.java new file mode 100644 index 0000000..a70925d --- /dev/null +++ b/src/main/java/org/apache/commons/math/fraction/ProperFractionFormat.java @@ -0,0 +1,232 @@ +/* + * 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.math.fraction; + +import java.text.FieldPosition; +import java.text.NumberFormat; +import java.text.ParsePosition; + +import org.apache.commons.math.exception.util.LocalizedFormats; +import org.apache.commons.math.exception.NullArgumentException; +import org.apache.commons.math.util.MathUtils; + +/** + * Formats a Fraction number in proper format. The number format for each of + * the whole number, numerator and, denominator can be configured. + * <p> + * Minus signs are only allowed in the whole number part - i.e., + * "-3 1/2" is legitimate and denotes -7/2, but "-3 -1/2" is invalid and + * will result in a <code>ParseException</code>.</p> + * + * @since 1.1 + * @version $Revision: 983921 $ $Date: 2010-08-10 12:46:06 +0200 (mar. 10 août 2010) $ + */ +public class ProperFractionFormat extends FractionFormat { + + /** Serializable version identifier */ + private static final long serialVersionUID = 760934726031766749L; + + /** The format used for the whole number. */ + private NumberFormat wholeFormat; + + /** + * Create a proper formatting instance with the default number format for + * the whole, numerator, and denominator. + */ + public ProperFractionFormat() { + this(getDefaultNumberFormat()); + } + + /** + * Create a proper formatting instance with a custom number format for the + * whole, numerator, and denominator. + * @param format the custom format for the whole, numerator, and + * denominator. + */ + public ProperFractionFormat(NumberFormat format) { + this(format, (NumberFormat)format.clone(), (NumberFormat)format.clone()); + } + + /** + * Create a proper formatting instance with a custom number format for each + * of the whole, numerator, and denominator. + * @param wholeFormat the custom format for the whole. + * @param numeratorFormat the custom format for the numerator. + * @param denominatorFormat the custom format for the denominator. + */ + public ProperFractionFormat(NumberFormat wholeFormat, + NumberFormat numeratorFormat, + NumberFormat denominatorFormat) + { + super(numeratorFormat, denominatorFormat); + setWholeFormat(wholeFormat); + } + + /** + * Formats a {@link Fraction} object to produce a string. The fraction + * is output in proper format. + * + * @param fraction 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. + */ + @Override + public StringBuffer format(Fraction fraction, StringBuffer toAppendTo, + FieldPosition pos) { + + pos.setBeginIndex(0); + pos.setEndIndex(0); + + int num = fraction.getNumerator(); + int den = fraction.getDenominator(); + int whole = num / den; + num = num % den; + + if (whole != 0) { + getWholeFormat().format(whole, toAppendTo, pos); + toAppendTo.append(' '); + num = Math.abs(num); + } + getNumeratorFormat().format(num, toAppendTo, pos); + toAppendTo.append(" / "); + getDenominatorFormat().format(den, toAppendTo, + pos); + + return toAppendTo; + } + + /** + * Access the whole format. + * @return the whole format. + */ + public NumberFormat getWholeFormat() { + return wholeFormat; + } + + /** + * Parses a string to produce a {@link Fraction} object. This method + * expects the string to be formatted as a proper fraction. + * <p> + * Minus signs are only allowed in the whole number part - i.e., + * "-3 1/2" is legitimate and denotes -7/2, but "-3 -1/2" is invalid and + * will result in a <code>ParseException</code>.</p> + * + * @param source the string to parse + * @param pos input/ouput parsing parameter. + * @return the parsed {@link Fraction} object. + */ + @Override + public Fraction parse(String source, ParsePosition pos) { + // try to parse improper fraction + Fraction ret = super.parse(source, pos); + if (ret != null) { + return ret; + } + + int initialIndex = pos.getIndex(); + + // parse whitespace + parseAndIgnoreWhitespace(source, pos); + + // parse whole + Number whole = getWholeFormat().parse(source, pos); + if (whole == null) { + // invalid integer number + // set index back to initial, error index should already be set + // character examined. + pos.setIndex(initialIndex); + return null; + } + + // parse whitespace + parseAndIgnoreWhitespace(source, pos); + + // parse numerator + Number num = getNumeratorFormat().parse(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; + } + + if (num.intValue() < 0) { + // minus signs should be leading, invalid expression + pos.setIndex(initialIndex); + return null; + } + + // parse '/' + int startIndex = pos.getIndex(); + char c = parseNextCharacter(source, pos); + switch (c) { + case 0 : + // no '/' + // return num as a fraction + return new Fraction(num.intValue(), 1); + 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 + Number den = getDenominatorFormat().parse(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; + } + + if (den.intValue() < 0) { + // minus signs must be leading, invalid + pos.setIndex(initialIndex); + return null; + } + + int w = whole.intValue(); + int n = num.intValue(); + int d = den.intValue(); + return new Fraction(((Math.abs(w) * d) + n) * MathUtils.sign(w), d); + } + + /** + * Modify the whole format. + * @param format The new whole format value. + * @throws NullArgumentException if {@code format} is {@code null}. + */ + public void setWholeFormat(NumberFormat format) { + if (format == null) { + throw new NullArgumentException(LocalizedFormats.WHOLE_FORMAT); + } + this.wholeFormat = format; + } +} diff --git a/src/main/java/org/apache/commons/math/fraction/package.html b/src/main/java/org/apache/commons/math/fraction/package.html new file mode 100644 index 0000000..201ae20 --- /dev/null +++ b/src/main/java/org/apache/commons/math/fraction/package.html @@ -0,0 +1,22 @@ +<html> +<!-- + 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. + --> + <!-- $Revision: 811685 $ $Date: 2009-09-05 19:36:48 +0200 (sam. 05 sept. 2009) $ --> + <body> + Fraction number type and fraction number formatting. + </body> +</html> |