commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From raydeca...@apache.org
Subject [01/13] commons-numbers git commit: NUMBERS-6: Create structure for fraction module within commons-numbers.
Date Mon, 06 Feb 2017 12:52:22 GMT
Repository: commons-numbers
Updated Branches:
  refs/heads/master 237697268 -> 39b5119cc


http://git-wip-us.apache.org/repos/asf/commons-numbers/blob/ca71f355/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/FractionFormatTest.java
----------------------------------------------------------------------
diff --git a/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/FractionFormatTest.java
b/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/FractionFormatTest.java
new file mode 100644
index 0000000..2c9a398
--- /dev/null
+++ b/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/FractionFormatTest.java
@@ -0,0 +1,349 @@
+/*
+ * 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.numbers.fraction;
+
+import java.text.NumberFormat;
+import java.util.Locale;
+
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+
+public class FractionFormatTest {
+
+    FractionFormat properFormat = null;
+    FractionFormat improperFormat = null;
+
+    protected Locale getLocale() {
+        return Locale.getDefault();
+    }
+
+    @Before
+    public void setUp() {
+        properFormat = FractionFormat.getProperInstance(getLocale());
+        improperFormat = FractionFormat.getImproperInstance(getLocale());
+    }
+
+    @Test
+    public void testFormat() {
+        Fraction c = new Fraction(1, 2);
+        String expected = "1 / 2";
+
+        String actual = properFormat.format(c);
+        Assert.assertEquals(expected, actual);
+
+        actual = improperFormat.format(c);
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void testFormatNegative() {
+        Fraction c = new Fraction(-1, 2);
+        String expected = "-1 / 2";
+
+        String actual = properFormat.format(c);
+        Assert.assertEquals(expected, actual);
+
+        actual = improperFormat.format(c);
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void testFormatZero() {
+        Fraction c = new Fraction(0, 1);
+        String expected = "0 / 1";
+
+        String actual = properFormat.format(c);
+        Assert.assertEquals(expected, actual);
+
+        actual = improperFormat.format(c);
+        Assert.assertEquals(expected, actual);
+    }
+
+    @Test
+    public void testFormatImproper() {
+        Fraction c = new Fraction(5, 3);
+
+        String actual = properFormat.format(c);
+        Assert.assertEquals("1 2 / 3", actual);
+
+        actual = improperFormat.format(c);
+        Assert.assertEquals("5 / 3", actual);
+    }
+
+    @Test
+    public void testFormatImproperNegative() {
+        Fraction c = new Fraction(-5, 3);
+
+        String actual = properFormat.format(c);
+        Assert.assertEquals("-1 2 / 3", actual);
+
+        actual = improperFormat.format(c);
+        Assert.assertEquals("-5 / 3", actual);
+    }
+
+    @Test
+    public void testParse() {
+        String source = "1 / 2";
+
+        try {
+            Fraction c = properFormat.parse(source);
+            Assert.assertNotNull(c);
+            Assert.assertEquals(1, c.getNumerator());
+            Assert.assertEquals(2, c.getDenominator());
+
+            c = improperFormat.parse(source);
+            Assert.assertNotNull(c);
+            Assert.assertEquals(1, c.getNumerator());
+            Assert.assertEquals(2, c.getDenominator());
+        } catch (FractionParseException ex) {
+            Assert.fail(ex.getMessage());
+        }
+    }
+
+    @Test
+    public void testParseInteger() {
+        String source = "10";
+        {
+            Fraction c = properFormat.parse(source);
+            Assert.assertNotNull(c);
+            Assert.assertEquals(10, c.getNumerator());
+            Assert.assertEquals(1, c.getDenominator());
+        }
+        {
+            Fraction c = improperFormat.parse(source);
+            Assert.assertNotNull(c);
+            Assert.assertEquals(10, c.getNumerator());
+            Assert.assertEquals(1, c.getDenominator());
+        }
+    }
+
+    @Test
+    public void testParseOne1() {
+        String source = "1 / 1";
+        Fraction c = properFormat.parse(source);
+        Assert.assertNotNull(c);
+        Assert.assertEquals(1, c.getNumerator());
+        Assert.assertEquals(1, c.getDenominator());
+    }
+
+    @Test
+    public void testParseOne2() {
+        String source = "10 / 10";
+        Fraction c = properFormat.parse(source);
+        Assert.assertNotNull(c);
+        Assert.assertEquals(1, c.getNumerator());
+        Assert.assertEquals(1, c.getDenominator());
+    }
+
+    @Test
+    public void testParseZero1() {
+        String source = "0 / 1";
+        Fraction c = properFormat.parse(source);
+        Assert.assertNotNull(c);
+        Assert.assertEquals(0, c.getNumerator());
+        Assert.assertEquals(1, c.getDenominator());
+    }
+
+    @Test
+    public void testParseZero2() {
+        String source = "-0 / 1";
+        Fraction c = properFormat.parse(source);
+        Assert.assertNotNull(c);
+        Assert.assertEquals(0, c.getNumerator());
+        Assert.assertEquals(1, c.getDenominator());
+        // This test shows that the sign is not preserved.
+        Assert.assertEquals(Double.POSITIVE_INFINITY, 1d / c.doubleValue(), 0);
+    }
+
+    @Test
+    public void testParseInvalid() {
+        String source = "a";
+        String msg = "should not be able to parse '10 / a'.";
+        try {
+            properFormat.parse(source);
+            Assert.fail(msg);
+        } catch (FractionParseException ex) {
+            // success
+        }
+        try {
+            improperFormat.parse(source);
+            Assert.fail(msg);
+        } catch (FractionParseException ex) {
+            // success
+        }
+    }
+
+    @Test
+    public void testParseInvalidDenominator() {
+        String source = "10 / a";
+        String msg = "should not be able to parse '10 / a'.";
+        try {
+            properFormat.parse(source);
+            Assert.fail(msg);
+        } catch (FractionParseException ex) {
+            // success
+        }
+        try {
+            improperFormat.parse(source);
+            Assert.fail(msg);
+        } catch (FractionParseException ex) {
+            // success
+        }
+    }
+
+    @Test
+    public void testParseNegative() {
+
+        {
+            String source = "-1 / 2";
+            Fraction c = properFormat.parse(source);
+            Assert.assertNotNull(c);
+            Assert.assertEquals(-1, c.getNumerator());
+            Assert.assertEquals(2, c.getDenominator());
+
+            c = improperFormat.parse(source);
+            Assert.assertNotNull(c);
+            Assert.assertEquals(-1, c.getNumerator());
+            Assert.assertEquals(2, c.getDenominator());
+
+            source = "1 / -2";
+            c = properFormat.parse(source);
+            Assert.assertNotNull(c);
+            Assert.assertEquals(-1, c.getNumerator());
+            Assert.assertEquals(2, c.getDenominator());
+
+            c = improperFormat.parse(source);
+            Assert.assertNotNull(c);
+            Assert.assertEquals(-1, c.getNumerator());
+            Assert.assertEquals(2, c.getDenominator());
+        }
+    }
+
+    @Test
+    public void testParseProper() {
+        String source = "1 2 / 3";
+
+        {
+            Fraction c = properFormat.parse(source);
+            Assert.assertNotNull(c);
+            Assert.assertEquals(5, c.getNumerator());
+            Assert.assertEquals(3, c.getDenominator());
+        }
+
+        try {
+            improperFormat.parse(source);
+            Assert.fail("invalid improper fraction.");
+        } catch (FractionParseException ex) {
+            // success
+        }
+    }
+
+    @Test
+    public void testParseProperNegative() {
+        String source = "-1 2 / 3";
+        {
+            Fraction c = properFormat.parse(source);
+            Assert.assertNotNull(c);
+            Assert.assertEquals(-5, c.getNumerator());
+            Assert.assertEquals(3, c.getDenominator());
+        }
+
+        try {
+            improperFormat.parse(source);
+            Assert.fail("invalid improper fraction.");
+        } catch (FractionParseException ex) {
+            // success
+        }
+    }
+
+    @Test
+    public void testParseProperInvalidMinus() {
+        String source = "2 -2 / 3";
+        try {
+            properFormat.parse(source);
+            Assert.fail("invalid minus in improper fraction.");
+        } catch (FractionParseException ex) {
+            // expected
+        }
+        source = "2 2 / -3";
+        try {
+            properFormat.parse(source);
+            Assert.fail("invalid minus in improper fraction.");
+        } catch (FractionParseException ex) {
+            // expected
+        }
+    }
+
+    @Test
+    public void testNumeratorFormat() {
+        NumberFormat old = properFormat.getNumeratorFormat();
+        NumberFormat nf = NumberFormat.getInstance();
+        nf.setParseIntegerOnly(true);
+        properFormat.setNumeratorFormat(nf);
+        Assert.assertEquals(nf, properFormat.getNumeratorFormat());
+        properFormat.setNumeratorFormat(old);
+
+        old = improperFormat.getNumeratorFormat();
+        nf = NumberFormat.getInstance();
+        nf.setParseIntegerOnly(true);
+        improperFormat.setNumeratorFormat(nf);
+        Assert.assertEquals(nf, improperFormat.getNumeratorFormat());
+        improperFormat.setNumeratorFormat(old);
+    }
+
+    @Test
+    public void testDenominatorFormat() {
+        NumberFormat old = properFormat.getDenominatorFormat();
+        NumberFormat nf = NumberFormat.getInstance();
+        nf.setParseIntegerOnly(true);
+        properFormat.setDenominatorFormat(nf);
+        Assert.assertEquals(nf, properFormat.getDenominatorFormat());
+        properFormat.setDenominatorFormat(old);
+
+        old = improperFormat.getDenominatorFormat();
+        nf = NumberFormat.getInstance();
+        nf.setParseIntegerOnly(true);
+        improperFormat.setDenominatorFormat(nf);
+        Assert.assertEquals(nf, improperFormat.getDenominatorFormat());
+        improperFormat.setDenominatorFormat(old);
+    }
+
+    @Test
+    public void testWholeFormat() {
+        ProperFractionFormat format = (ProperFractionFormat)properFormat;
+
+        NumberFormat old = format.getWholeFormat();
+        NumberFormat nf = NumberFormat.getInstance();
+        nf.setParseIntegerOnly(true);
+        format.setWholeFormat(nf);
+        Assert.assertEquals(nf, format.getWholeFormat());
+        format.setWholeFormat(old);
+    }
+
+    @Test
+    public void testLongFormat() {
+        Assert.assertEquals("10 / 1", improperFormat.format(10l));
+    }
+
+    @Test
+    public void testDoubleFormat() {
+        Assert.assertEquals("355 / 113", improperFormat.format(Math.PI));
+    }
+}

http://git-wip-us.apache.org/repos/asf/commons-numbers/blob/ca71f355/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/FractionTest.java
----------------------------------------------------------------------
diff --git a/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/FractionTest.java
b/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/FractionTest.java
new file mode 100644
index 0000000..3b2c4cb
--- /dev/null
+++ b/commons-numbers-fraction/src/test/java/org/apache/commons/numbers/fraction/FractionTest.java
@@ -0,0 +1,625 @@
+/*
+ * 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.numbers.fraction;
+
+import org.apache.commons.numbers.core.NumbersArithmeticException;
+import org.apache.commons.numbers.core.TestUtils;
+import org.junit.Assert;
+import org.junit.Test;
+
+
+/**
+ */
+public class FractionTest {
+
+    private void assertFraction(int expectedNumerator, int expectedDenominator, Fraction
actual) {
+        Assert.assertEquals(expectedNumerator, actual.getNumerator());
+        Assert.assertEquals(expectedDenominator, actual.getDenominator());
+    }
+
+    @Test
+    public void testConstructor() {
+        assertFraction(0, 1, new Fraction(0, 1));
+        assertFraction(0, 1, new Fraction(0, 2));
+        assertFraction(0, 1, new Fraction(0, -1));
+        assertFraction(1, 2, new Fraction(1, 2));
+        assertFraction(1, 2, new Fraction(2, 4));
+        assertFraction(-1, 2, new Fraction(-1, 2));
+        assertFraction(-1, 2, new Fraction(1, -2));
+        assertFraction(-1, 2, new Fraction(-2, 4));
+        assertFraction(-1, 2, new Fraction(2, -4));
+
+        // overflow
+        try {
+            new Fraction(Integer.MIN_VALUE, -1);
+            Assert.fail();
+        } catch (NumbersArithmeticException ex) {
+            // success
+        }
+        try {
+            new Fraction(1, Integer.MIN_VALUE);
+            Assert.fail();
+        } catch (NumbersArithmeticException ex) {
+            // success
+        }
+
+        assertFraction(0, 1, new Fraction(0.00000000000001));
+        assertFraction(2, 5, new Fraction(0.40000000000001));
+        assertFraction(15, 1, new Fraction(15.0000000000001));
+    }
+
+    @Test(expected=FractionConversionException.class)
+    public void testGoldenRatio() {
+        // the golden ratio is notoriously a difficult number for continuous fraction
+        new Fraction((1 + Math.sqrt(5)) / 2, 1.0e-12, 25);
+    }
+
+    // MATH-179
+    @Test
+    public void testDoubleConstructor() throws Exception  {
+        assertFraction(1, 2, new Fraction((double)1 / (double)2));
+        assertFraction(1, 3, new Fraction((double)1 / (double)3));
+        assertFraction(2, 3, new Fraction((double)2 / (double)3));
+        assertFraction(1, 4, new Fraction((double)1 / (double)4));
+        assertFraction(3, 4, new Fraction((double)3 / (double)4));
+        assertFraction(1, 5, new Fraction((double)1 / (double)5));
+        assertFraction(2, 5, new Fraction((double)2 / (double)5));
+        assertFraction(3, 5, new Fraction((double)3 / (double)5));
+        assertFraction(4, 5, new Fraction((double)4 / (double)5));
+        assertFraction(1, 6, new Fraction((double)1 / (double)6));
+        assertFraction(5, 6, new Fraction((double)5 / (double)6));
+        assertFraction(1, 7, new Fraction((double)1 / (double)7));
+        assertFraction(2, 7, new Fraction((double)2 / (double)7));
+        assertFraction(3, 7, new Fraction((double)3 / (double)7));
+        assertFraction(4, 7, new Fraction((double)4 / (double)7));
+        assertFraction(5, 7, new Fraction((double)5 / (double)7));
+        assertFraction(6, 7, new Fraction((double)6 / (double)7));
+        assertFraction(1, 8, new Fraction((double)1 / (double)8));
+        assertFraction(3, 8, new Fraction((double)3 / (double)8));
+        assertFraction(5, 8, new Fraction((double)5 / (double)8));
+        assertFraction(7, 8, new Fraction((double)7 / (double)8));
+        assertFraction(1, 9, new Fraction((double)1 / (double)9));
+        assertFraction(2, 9, new Fraction((double)2 / (double)9));
+        assertFraction(4, 9, new Fraction((double)4 / (double)9));
+        assertFraction(5, 9, new Fraction((double)5 / (double)9));
+        assertFraction(7, 9, new Fraction((double)7 / (double)9));
+        assertFraction(8, 9, new Fraction((double)8 / (double)9));
+        assertFraction(1, 10, new Fraction((double)1 / (double)10));
+        assertFraction(3, 10, new Fraction((double)3 / (double)10));
+        assertFraction(7, 10, new Fraction((double)7 / (double)10));
+        assertFraction(9, 10, new Fraction((double)9 / (double)10));
+        assertFraction(1, 11, new Fraction((double)1 / (double)11));
+        assertFraction(2, 11, new Fraction((double)2 / (double)11));
+        assertFraction(3, 11, new Fraction((double)3 / (double)11));
+        assertFraction(4, 11, new Fraction((double)4 / (double)11));
+        assertFraction(5, 11, new Fraction((double)5 / (double)11));
+        assertFraction(6, 11, new Fraction((double)6 / (double)11));
+        assertFraction(7, 11, new Fraction((double)7 / (double)11));
+        assertFraction(8, 11, new Fraction((double)8 / (double)11));
+        assertFraction(9, 11, new Fraction((double)9 / (double)11));
+        assertFraction(10, 11, new Fraction((double)10 / (double)11));
+    }
+
+    // MATH-181
+    @Test
+    public void testDigitLimitConstructor() throws Exception  {
+        assertFraction(2, 5, new Fraction(0.4,   9));
+        assertFraction(2, 5, new Fraction(0.4,  99));
+        assertFraction(2, 5, new Fraction(0.4, 999));
+
+        assertFraction(3, 5,      new Fraction(0.6152,    9));
+        assertFraction(8, 13,     new Fraction(0.6152,   99));
+        assertFraction(510, 829,  new Fraction(0.6152,  999));
+        assertFraction(769, 1250, new Fraction(0.6152, 9999));
+
+        // MATH-996
+        assertFraction(1, 2, new Fraction(0.5000000001, 10));
+    }
+
+    @Test
+    public void testIntegerOverflow() {
+        checkIntegerOverflow(0.75000000001455192);
+        checkIntegerOverflow(1.0e10);
+        checkIntegerOverflow(-1.0e10);
+        checkIntegerOverflow(-43979.60679604749);
+    }
+
+    private void checkIntegerOverflow(double a) {
+        try {
+            @SuppressWarnings("unused")
+            Fraction f = new Fraction(a, 1.0e-12, 1000);
+            //System.out.println(f.getNumerator() + "/" + f.getDenominator());
+            Assert.fail("an exception should have been thrown");
+        } catch (FractionConversionException ce) {
+            // expected behavior
+        }
+    }
+
+    @Test
+    public void testEpsilonLimitConstructor() throws Exception  {
+        assertFraction(2, 5, new Fraction(0.4, 1.0e-5, 100));
+
+        assertFraction(3, 5,      new Fraction(0.6152, 0.02, 100));
+        assertFraction(8, 13,     new Fraction(0.6152, 1.0e-3, 100));
+        assertFraction(251, 408,  new Fraction(0.6152, 1.0e-4, 100));
+        assertFraction(251, 408,  new Fraction(0.6152, 1.0e-5, 100));
+        assertFraction(510, 829,  new Fraction(0.6152, 1.0e-6, 100));
+        assertFraction(769, 1250, new Fraction(0.6152, 1.0e-7, 100));
+    }
+
+    @Test
+    public void testCompareTo() {
+        Fraction first = new Fraction(1, 2);
+        Fraction second = new Fraction(1, 3);
+        Fraction third = new Fraction(1, 2);
+
+        Assert.assertEquals(0, first.compareTo(first));
+        Assert.assertEquals(0, first.compareTo(third));
+        Assert.assertEquals(1, first.compareTo(second));
+        Assert.assertEquals(-1, second.compareTo(first));
+
+        // these two values are different approximations of PI
+        // the first  one is approximately PI - 3.07e-18
+        // the second one is approximately PI + 1.936e-17
+        Fraction pi1 = new Fraction(1068966896, 340262731);
+        Fraction pi2 = new Fraction( 411557987, 131002976);
+        Assert.assertEquals(-1, pi1.compareTo(pi2));
+        Assert.assertEquals( 1, pi2.compareTo(pi1));
+        Assert.assertEquals(0.0, pi1.doubleValue() - pi2.doubleValue(), 1.0e-20);
+    }
+
+    @Test
+    public void testDoubleValue() {
+        Fraction first = new Fraction(1, 2);
+        Fraction second = new Fraction(1, 3);
+
+        Assert.assertEquals(0.5, first.doubleValue(), 0.0);
+        Assert.assertEquals(1.0 / 3.0, second.doubleValue(), 0.0);
+    }
+
+    @Test
+    public void testFloatValue() {
+        Fraction first = new Fraction(1, 2);
+        Fraction second = new Fraction(1, 3);
+
+        Assert.assertEquals(0.5f, first.floatValue(), 0.0f);
+        Assert.assertEquals((float)(1.0 / 3.0), second.floatValue(), 0.0f);
+    }
+
+    @Test
+    public void testIntValue() {
+        Fraction first = new Fraction(1, 2);
+        Fraction second = new Fraction(3, 2);
+
+        Assert.assertEquals(0, first.intValue());
+        Assert.assertEquals(1, second.intValue());
+    }
+
+    @Test
+    public void testLongValue() {
+        Fraction first = new Fraction(1, 2);
+        Fraction second = new Fraction(3, 2);
+
+        Assert.assertEquals(0L, first.longValue());
+        Assert.assertEquals(1L, second.longValue());
+    }
+
+    @Test
+    public void testConstructorDouble() {
+        assertFraction(1, 2, new Fraction(0.5));
+        assertFraction(1, 3, new Fraction(1.0 / 3.0));
+        assertFraction(17, 100, new Fraction(17.0 / 100.0));
+        assertFraction(317, 100, new Fraction(317.0 / 100.0));
+        assertFraction(-1, 2, new Fraction(-0.5));
+        assertFraction(-1, 3, new Fraction(-1.0 / 3.0));
+        assertFraction(-17, 100, new Fraction(17.0 / -100.0));
+        assertFraction(-317, 100, new Fraction(-317.0 / 100.0));
+    }
+
+    @Test
+    public void testAbs() {
+        Fraction a = new Fraction(10, 21);
+        Fraction b = new Fraction(-10, 21);
+        Fraction c = new Fraction(10, -21);
+
+        assertFraction(10, 21, a.abs());
+        assertFraction(10, 21, b.abs());
+        assertFraction(10, 21, c.abs());
+    }
+
+    @Test
+    public void testPercentage() {
+        Assert.assertEquals(50.0, new Fraction(1, 2).percentageValue(), 1.0e-15);
+    }
+
+    @Test
+    public void testMath835() {
+        final int numer = Integer.MAX_VALUE / 99;
+        final int denom = 1;
+        final double percentage = 100 * ((double) numer) / denom;
+        final Fraction frac = new Fraction(numer, denom);
+        // With the implementation that preceded the fix suggested in MATH-835,
+        // this test was failing, due to overflow.
+        Assert.assertEquals(percentage, frac.percentageValue(), Math.ulp(percentage));
+    }
+
+    @Test
+    public void testMath1261() {
+        final Fraction a = new Fraction(Integer.MAX_VALUE, 2);
+        final Fraction b = a.multiply(2);
+        Assert.assertTrue(b.equals(new Fraction(Integer.MAX_VALUE)));
+
+        final Fraction c = new Fraction(2, Integer.MAX_VALUE);
+        final Fraction d = c.divide(2);
+        Assert.assertTrue(d.equals(new Fraction(1, Integer.MAX_VALUE)));
+    }
+
+    @Test
+    public void testReciprocal() {
+        Fraction f = null;
+
+        f = new Fraction(50, 75);
+        f = f.reciprocal();
+        Assert.assertEquals(3, f.getNumerator());
+        Assert.assertEquals(2, f.getDenominator());
+
+        f = new Fraction(4, 3);
+        f = f.reciprocal();
+        Assert.assertEquals(3, f.getNumerator());
+        Assert.assertEquals(4, f.getDenominator());
+
+        f = new Fraction(-15, 47);
+        f = f.reciprocal();
+        Assert.assertEquals(-47, f.getNumerator());
+        Assert.assertEquals(15, f.getDenominator());
+
+        f = new Fraction(0, 3);
+        try {
+            f = f.reciprocal();
+            Assert.fail("expecting ZeroDenominatorException");
+        } catch (ZeroDenominatorException ex) {}
+
+        // large values
+        f = new Fraction(Integer.MAX_VALUE, 1);
+        f = f.reciprocal();
+        Assert.assertEquals(1, f.getNumerator());
+        Assert.assertEquals(Integer.MAX_VALUE, f.getDenominator());
+    }
+
+    @Test
+    public void testNegate() {
+        Fraction f = null;
+
+        f = new Fraction(50, 75);
+        f = f.negate();
+        Assert.assertEquals(-2, f.getNumerator());
+        Assert.assertEquals(3, f.getDenominator());
+
+        f = new Fraction(-50, 75);
+        f = f.negate();
+        Assert.assertEquals(2, f.getNumerator());
+        Assert.assertEquals(3, f.getDenominator());
+
+        // large values
+        f = new Fraction(Integer.MAX_VALUE-1, Integer.MAX_VALUE);
+        f = f.negate();
+        Assert.assertEquals(Integer.MIN_VALUE+2, f.getNumerator());
+        Assert.assertEquals(Integer.MAX_VALUE, f.getDenominator());
+
+        f = new Fraction(Integer.MIN_VALUE, 1);
+        try {
+            f = f.negate();
+            Assert.fail("expecting NumbersArithmeticException");
+        } catch (NumbersArithmeticException ex) {}
+    }
+
+    @Test
+    public void testAdd() {
+        Fraction a = new Fraction(1, 2);
+        Fraction b = new Fraction(2, 3);
+
+        assertFraction(1, 1, a.add(a));
+        assertFraction(7, 6, a.add(b));
+        assertFraction(7, 6, b.add(a));
+        assertFraction(4, 3, b.add(b));
+
+        Fraction f1 = new Fraction(Integer.MAX_VALUE - 1, 1);
+        Fraction f2 = Fraction.ONE;
+        Fraction f = f1.add(f2);
+        Assert.assertEquals(Integer.MAX_VALUE, f.getNumerator());
+        Assert.assertEquals(1, f.getDenominator());
+        f = f1.add(1);
+        Assert.assertEquals(Integer.MAX_VALUE, f.getNumerator());
+        Assert.assertEquals(1, f.getDenominator());
+
+        f1 = new Fraction(-1, 13*13*2*2);
+        f2 = new Fraction(-2, 13*17*2);
+        f = f1.add(f2);
+        Assert.assertEquals(13*13*17*2*2, f.getDenominator());
+        Assert.assertEquals(-17 - 2*13*2, f.getNumerator());
+
+        try {
+            f.add(null);
+            Assert.fail("expecting NullArgumentException");
+        } catch (NullPointerException ex) {}
+
+        // if this fraction is added naively, it will overflow.
+        // check that it doesn't.
+        f1 = new Fraction(1,32768*3);
+        f2 = new Fraction(1,59049);
+        f = f1.add(f2);
+        Assert.assertEquals(52451, f.getNumerator());
+        Assert.assertEquals(1934917632, f.getDenominator());
+
+        f1 = new Fraction(Integer.MIN_VALUE, 3);
+        f2 = new Fraction(1,3);
+        f = f1.add(f2);
+        Assert.assertEquals(Integer.MIN_VALUE+1, f.getNumerator());
+        Assert.assertEquals(3, f.getDenominator());
+
+        f1 = new Fraction(Integer.MAX_VALUE - 1, 1);
+        f2 = Fraction.ONE;
+        f = f1.add(f2);
+        Assert.assertEquals(Integer.MAX_VALUE, f.getNumerator());
+        Assert.assertEquals(1, f.getDenominator());
+
+        try {
+            f = f.add(Fraction.ONE); // should overflow
+            Assert.fail("expecting NumbersArithmeticException but got: " + f.toString());
+        } catch (NumbersArithmeticException ex) {}
+
+        // denominator should not be a multiple of 2 or 3 to trigger overflow
+        f1 = new Fraction(Integer.MIN_VALUE, 5);
+        f2 = new Fraction(-1,5);
+        try {
+            f = f1.add(f2); // should overflow
+            Assert.fail("expecting NumbersArithmeticException but got: " + f.toString());
+        } catch (FractionOverflowException ex) {}
+
+        try {
+            f= new Fraction(-Integer.MAX_VALUE, 1);
+            f = f.add(f);
+            Assert.fail("expecting NumbersArithmeticException");
+        } catch (NumbersArithmeticException ex) {}
+
+        try {
+            f= new Fraction(-Integer.MAX_VALUE, 1);
+            f = f.add(f);
+            Assert.fail("expecting NumbersArithmeticException");
+        } catch (NumbersArithmeticException ex) {}
+
+        f1 = new Fraction(3,327680);
+        f2 = new Fraction(2,59049);
+        try {
+            f = f1.add(f2); // should overflow
+            Assert.fail("expecting NumbersArithmeticException but got: " + f.toString());
+        } catch (NumbersArithmeticException ex) {}
+    }
+
+    @Test
+    public void testDivide() {
+        Fraction a = new Fraction(1, 2);
+        Fraction b = new Fraction(2, 3);
+
+        assertFraction(1, 1, a.divide(a));
+        assertFraction(3, 4, a.divide(b));
+        assertFraction(4, 3, b.divide(a));
+        assertFraction(1, 1, b.divide(b));
+
+        Fraction f1 = new Fraction(3, 5);
+        Fraction f2 = Fraction.ZERO;
+        try {
+            f1.divide(f2);
+            Assert.fail("expecting FractionException");
+        } catch (FractionException ex) {}
+
+        f1 = new Fraction(0, 5);
+        f2 = new Fraction(2, 7);
+        Fraction f = f1.divide(f2);
+        Assert.assertSame(Fraction.ZERO, f);
+
+        f1 = new Fraction(2, 7);
+        f2 = Fraction.ONE;
+        f = f1.divide(f2);
+        Assert.assertEquals(2, f.getNumerator());
+        Assert.assertEquals(7, f.getDenominator());
+
+        f1 = new Fraction(1, Integer.MAX_VALUE);
+        f = f1.divide(f1);
+        Assert.assertEquals(1, f.getNumerator());
+        Assert.assertEquals(1, f.getDenominator());
+
+        f1 = new Fraction(Integer.MIN_VALUE, Integer.MAX_VALUE);
+        f2 = new Fraction(1, Integer.MAX_VALUE);
+        f = f1.divide(f2);
+        Assert.assertEquals(Integer.MIN_VALUE, f.getNumerator());
+        Assert.assertEquals(1, f.getDenominator());
+
+        try {
+            f.divide(null);
+            Assert.fail("NullArgumentException");
+        } catch (NullPointerException ex) {}
+
+        try {
+            f1 = new Fraction(1, Integer.MAX_VALUE);
+            f = f1.divide(f1.reciprocal());  // should overflow
+            Assert.fail("expecting NumbersArithmeticException");
+        } catch (NumbersArithmeticException ex) {}
+        try {
+            f1 = new Fraction(1, -Integer.MAX_VALUE);
+            f = f1.divide(f1.reciprocal());  // should overflow
+            Assert.fail("expecting NumbersArithmeticException");
+        } catch (NumbersArithmeticException ex) {}
+
+        f1 = new Fraction(6, 35);
+        f  = f1.divide(15);
+        Assert.assertEquals(2, f.getNumerator());
+        Assert.assertEquals(175, f.getDenominator());
+
+    }
+
+    @Test
+    public void testMultiply() {
+        Fraction a = new Fraction(1, 2);
+        Fraction b = new Fraction(2, 3);
+
+        assertFraction(1, 4, a.multiply(a));
+        assertFraction(1, 3, a.multiply(b));
+        assertFraction(1, 3, b.multiply(a));
+        assertFraction(4, 9, b.multiply(b));
+
+        Fraction f1 = new Fraction(Integer.MAX_VALUE, 1);
+        Fraction f2 = new Fraction(Integer.MIN_VALUE, Integer.MAX_VALUE);
+        Fraction f = f1.multiply(f2);
+        Assert.assertEquals(Integer.MIN_VALUE, f.getNumerator());
+        Assert.assertEquals(1, f.getDenominator());
+
+        try {
+            f.multiply(null);
+            Assert.fail("expecting NullArgumentException");
+        } catch (NullPointerException ex) {}
+
+        f1 = new Fraction(6, 35);
+        f  = f1.multiply(15);
+        Assert.assertEquals(18, f.getNumerator());
+        Assert.assertEquals(7, f.getDenominator());
+    }
+
+    @Test
+    public void testSubtract() {
+        Fraction a = new Fraction(1, 2);
+        Fraction b = new Fraction(2, 3);
+
+        assertFraction(0, 1, a.subtract(a));
+        assertFraction(-1, 6, a.subtract(b));
+        assertFraction(1, 6, b.subtract(a));
+        assertFraction(0, 1, b.subtract(b));
+
+        Fraction f = new Fraction(1,1);
+        try {
+            f.subtract(null);
+            Assert.fail("expecting NullArgumentException");
+        } catch (NullPointerException ex) {}
+
+        // if this fraction is subtracted naively, it will overflow.
+        // check that it doesn't.
+        Fraction f1 = new Fraction(1,32768*3);
+        Fraction f2 = new Fraction(1,59049);
+        f = f1.subtract(f2);
+        Assert.assertEquals(-13085, f.getNumerator());
+        Assert.assertEquals(1934917632, f.getDenominator());
+
+        f1 = new Fraction(Integer.MIN_VALUE, 3);
+        f2 = new Fraction(1,3).negate();
+        f = f1.subtract(f2);
+        Assert.assertEquals(Integer.MIN_VALUE+1, f.getNumerator());
+        Assert.assertEquals(3, f.getDenominator());
+
+        f1 = new Fraction(Integer.MAX_VALUE, 1);
+        f2 = Fraction.ONE;
+        f = f1.subtract(f2);
+        Assert.assertEquals(Integer.MAX_VALUE-1, f.getNumerator());
+        Assert.assertEquals(1, f.getDenominator());
+        f = f1.subtract(1);
+        Assert.assertEquals(Integer.MAX_VALUE-1, f.getNumerator());
+        Assert.assertEquals(1, f.getDenominator());
+
+        try {
+            f1 = new Fraction(1, Integer.MAX_VALUE);
+            f2 = new Fraction(1, Integer.MAX_VALUE - 1);
+            f = f1.subtract(f2);
+            Assert.fail("expecting NumbersArithmeticException");  //should overflow
+        } catch (NumbersArithmeticException ex) {}
+
+        // denominator should not be a multiple of 2 or 3 to trigger overflow
+        f1 = new Fraction(Integer.MIN_VALUE, 5);
+        f2 = new Fraction(1,5);
+        try {
+            f = f1.subtract(f2); // should overflow
+            Assert.fail("expecting FractionOverflowException but got: " + f.toString());
+        } catch (FractionOverflowException ex) {}
+
+        try {
+            f= new Fraction(Integer.MIN_VALUE, 1);
+            f = f.subtract(Fraction.ONE);
+            Assert.fail("expecting NumbersArithmeticException");
+        } catch (NumbersArithmeticException ex) {}
+
+        try {
+            f= new Fraction(Integer.MAX_VALUE, 1);
+            f = f.subtract(Fraction.ONE.negate());
+            Assert.fail("expecting NumbersArithmeticException");
+        } catch (NumbersArithmeticException ex) {}
+
+        f1 = new Fraction(3,327680);
+        f2 = new Fraction(2,59049);
+        try {
+            f = f1.subtract(f2); // should overflow
+            Assert.fail("expecting NumbersArithmeticException but got: " + f.toString());
+        } catch (NumbersArithmeticException ex) {}
+    }
+
+    @Test
+    public void testEqualsAndHashCode() {
+        Fraction zero  = new Fraction(0,1);
+        Fraction nullFraction = null;
+        Assert.assertTrue( zero.equals(zero));
+        Assert.assertFalse(zero.equals(nullFraction));
+        Assert.assertFalse(zero.equals(Double.valueOf(0)));
+        Fraction zero2 = new Fraction(0,2);
+        Assert.assertTrue(zero.equals(zero2));
+        Assert.assertEquals(zero.hashCode(), zero2.hashCode());
+        Fraction one = new Fraction(1,1);
+        Assert.assertFalse((one.equals(zero) ||zero.equals(one)));
+    }
+
+    @Test
+    public void testGetReducedFraction() {
+        Fraction threeFourths = new Fraction(3, 4);
+        Assert.assertTrue(threeFourths.equals(Fraction.getReducedFraction(6, 8)));
+        Assert.assertTrue(Fraction.ZERO.equals(Fraction.getReducedFraction(0, -1)));
+        try {
+            Fraction.getReducedFraction(1, 0);
+            Assert.fail("expecting ZeroDenominatorException");
+        } catch (ZeroDenominatorException ex) {
+            // expected
+        }
+        Assert.assertEquals(Fraction.getReducedFraction
+                (2, Integer.MIN_VALUE).getNumerator(),-1);
+        Assert.assertEquals(Fraction.getReducedFraction
+                (1, -1).getNumerator(), -1);
+    }
+
+    @Test
+    public void testToString() {
+        Assert.assertEquals("0", new Fraction(0, 3).toString());
+        Assert.assertEquals("3", new Fraction(6, 2).toString());
+        Assert.assertEquals("2 / 3", new Fraction(18, 27).toString());
+    }
+
+    @Test
+    public void testSerial() throws FractionConversionException {
+        Fraction[] fractions = {
+            new Fraction(3, 4), Fraction.ONE, Fraction.ZERO,
+            new Fraction(17), new Fraction(Math.PI, 1000),
+            new Fraction(-5, 2)
+        };
+        for (Fraction fraction : fractions) {
+            Assert.assertEquals(fraction, TestUtils.serializeAndRecover(fraction));
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/commons-numbers/blob/ca71f355/commons-numbers-quaternion/pom.xml
----------------------------------------------------------------------
diff --git a/commons-numbers-quaternion/pom.xml b/commons-numbers-quaternion/pom.xml
index 76a59e3..1817528 100644
--- a/commons-numbers-quaternion/pom.xml
+++ b/commons-numbers-quaternion/pom.xml
@@ -46,7 +46,6 @@
     <dependency>
       <groupId>org.apache.commons</groupId>
       <artifactId>commons-numbers-core</artifactId>
-      <version>1.0-SNAPSHOT</version>
     </dependency>
   </dependencies>
 

http://git-wip-us.apache.org/repos/asf/commons-numbers/blob/ca71f355/pom.xml
----------------------------------------------------------------------
diff --git a/pom.xml b/pom.xml
index 9d683ae..4485994 100644
--- a/pom.xml
+++ b/pom.xml
@@ -68,9 +68,27 @@
   <contributors>
     <contributor>
       <name>Raymond DeCampo</name>
+      <email>ray at decampo dot org</email>
     </contributor>
   </contributors>
 
+  <dependencyManagement>
+    <dependencies>
+    <dependency>
+      <groupId>org.apache.commons</groupId>
+      <artifactId>commons-numbers-core</artifactId>
+      <version>${project.version}</version>
+    </dependency>
+    <dependency>
+      <groupId>org.apache.commons</groupId>
+      <artifactId>commons-numbers-core</artifactId>
+      <version>${project.version}</version>
+      <type>test-jar</type>
+      <scope>test</scope>
+    </dependency>
+    </dependencies>
+  </dependencyManagement>
+
   <dependencies>
     <dependency>
       <groupId>junit</groupId>
@@ -543,7 +561,7 @@
     <module>commons-numbers-core</module>
     <module>commons-numbers-complex</module>
     <module>commons-numbers-quaternion</module>
-    <!-- <module>commons-numbers-fraction</module> -->
+    <module>commons-numbers-fraction</module>
     <!-- <module>commons-numbers-continuedfraction</module> -->
   </modules>
 


Mime
View raw message