You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by lu...@apache.org on 2010/09/05 00:57:31 UTC
svn commit: r992696 [4/4] - in /commons/proper/math/branches/MATH_2_X/src:
main/java/org/apache/commons/math/dfp/ site/xdoc/
test/java/org/apache/commons/math/dfp/
Added: commons/proper/math/branches/MATH_2_X/src/test/java/org/apache/commons/math/dfp/DfpTest.java
URL: http://svn.apache.org/viewvc/commons/proper/math/branches/MATH_2_X/src/test/java/org/apache/commons/math/dfp/DfpTest.java?rev=992696&view=auto
==============================================================================
--- commons/proper/math/branches/MATH_2_X/src/test/java/org/apache/commons/math/dfp/DfpTest.java (added)
+++ commons/proper/math/branches/MATH_2_X/src/test/java/org/apache/commons/math/dfp/DfpTest.java Sat Sep 4 22:57:31 2010
@@ -0,0 +1,1507 @@
+/*
+ * 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.dfp;
+
+import org.junit.After;
+import org.junit.Assert;
+import org.junit.Before;
+import org.junit.Test;
+
+public class DfpTest {
+
+ private DfpField field;
+ private Dfp pinf;
+ private Dfp ninf;
+ private Dfp nan;
+ private Dfp snan;
+ private Dfp qnan;
+
+ @Before
+ public void setUp() {
+ // Some basic setup. Define some constants and clear the status flags
+ field = new DfpField(20);
+ pinf = field.newDfp("1").divide(field.newDfp("0"));
+ ninf = field.newDfp("-1").divide(field.newDfp("0"));
+ nan = field.newDfp("0").divide(field.newDfp("0"));
+ snan = field.newDfp((byte)1, Dfp.SNAN);
+ qnan = field.newDfp((byte)1, Dfp.QNAN);
+ ninf.getField().clearIEEEFlags();
+ }
+
+ @After
+ public void tearDown() {
+ field = null;
+ pinf = null;
+ ninf = null;
+ nan = null;
+ snan = null;
+ qnan = null;
+ }
+
+ // Generic test function. Takes params x and y and tests them for
+ // equality. Then checks the status flags against the flags argument.
+ // If the test fail, it prints the desc string
+ private void test(Dfp x, Dfp y, int flags, String desc)
+ {
+ boolean b = x.equals(y);
+
+ if (!x.equals(y) && !x.unequal(y)) // NaNs involved
+ b = (x.toString().equals(y.toString()));
+
+ if (x.equals(field.newDfp("0"))) // distinguish +/- zero
+ b = (b && (x.toString().equals(y.toString())));
+
+ b = (b && x.getField().getIEEEFlags() == flags);
+
+ if (!b)
+ Assert.assertTrue("assersion failed "+desc+" x = "+x.toString()+" flags = "+x.getField().getIEEEFlags(), b);
+
+ x.getField().clearIEEEFlags();
+ }
+
+ @Test
+ public void testByteConstructor() {
+ Assert.assertEquals("0.", new Dfp(field, (byte) 0).toString());
+ Assert.assertEquals("1.", new Dfp(field, (byte) 1).toString());
+ Assert.assertEquals("-1.", new Dfp(field, (byte) -1).toString());
+ Assert.assertEquals("-128.", new Dfp(field, Byte.MIN_VALUE).toString());
+ Assert.assertEquals("127.", new Dfp(field, Byte.MAX_VALUE).toString());
+ }
+
+ @Test
+ public void testIntConstructor() {
+ Assert.assertEquals("0.", new Dfp(field, 0).toString());
+ Assert.assertEquals("1.", new Dfp(field, 1).toString());
+ Assert.assertEquals("-1.", new Dfp(field, -1).toString());
+ Assert.assertEquals("1234567890.", new Dfp(field, 1234567890).toString());
+ Assert.assertEquals("-1234567890.", new Dfp(field, -1234567890).toString());
+ Assert.assertEquals("-2147483648.", new Dfp(field, Integer.MIN_VALUE).toString());
+ Assert.assertEquals("2147483647.", new Dfp(field, Integer.MAX_VALUE).toString());
+ }
+
+ @Test
+ public void testLongConstructor() {
+ Assert.assertEquals("0.", new Dfp(field, 0l).toString());
+ Assert.assertEquals("1.", new Dfp(field, 1l).toString());
+ Assert.assertEquals("-1.", new Dfp(field, -1l).toString());
+ Assert.assertEquals("1234567890.", new Dfp(field, 1234567890l).toString());
+ Assert.assertEquals("-1234567890.", new Dfp(field, -1234567890l).toString());
+ Assert.assertEquals("-9223372036854775808.", new Dfp(field, Long.MIN_VALUE).toString());
+ Assert.assertEquals("9223372036854775807.", new Dfp(field, Long.MAX_VALUE).toString());
+ }
+
+ /*
+ * Test addition
+ */
+ @Test
+ public void testAdd()
+ {
+ test(field.newDfp("1").add(field.newDfp("1")), // Basic tests 1+1 = 2
+ field.newDfp("2"),
+ 0, "Add #1");
+
+ test(field.newDfp("1").add(field.newDfp("-1")), // 1 + (-1) = 0
+ field.newDfp("0"),
+ 0, "Add #2");
+
+ test(field.newDfp("-1").add(field.newDfp("1")), // (-1) + 1 = 0
+ field.newDfp("0"),
+ 0, "Add #3");
+
+ test(field.newDfp("-1").add(field.newDfp("-1")), // (-1) + (-1) = -2
+ field.newDfp("-2"),
+ 0, "Add #4");
+
+ // rounding mode is round half even
+
+ test(field.newDfp("1").add(field.newDfp("1e-16")), // rounding on add
+ field.newDfp("1.0000000000000001"),
+ 0, "Add #5");
+
+ test(field.newDfp("1").add(field.newDfp("1e-17")), // rounding on add
+ field.newDfp("1"),
+ DfpField.FLAG_INEXACT, "Add #6");
+
+ test(field.newDfp("0.90999999999999999999").add(field.newDfp("0.1")), // rounding on add
+ field.newDfp("1.01"),
+ DfpField.FLAG_INEXACT, "Add #7");
+
+ test(field.newDfp(".10000000000000005000").add(field.newDfp(".9")), // rounding on add
+ field.newDfp("1."),
+ DfpField.FLAG_INEXACT, "Add #8");
+
+ test(field.newDfp(".10000000000000015000").add(field.newDfp(".9")), // rounding on add
+ field.newDfp("1.0000000000000002"),
+ DfpField.FLAG_INEXACT, "Add #9");
+
+ test(field.newDfp(".10000000000000014999").add(field.newDfp(".9")), // rounding on add
+ field.newDfp("1.0000000000000001"),
+ DfpField.FLAG_INEXACT, "Add #10");
+
+ test(field.newDfp(".10000000000000015001").add(field.newDfp(".9")), // rounding on add
+ field.newDfp("1.0000000000000002"),
+ DfpField.FLAG_INEXACT, "Add #11");
+
+ test(field.newDfp(".11111111111111111111").add(field.newDfp("11.1111111111111111")), // rounding on add
+ field.newDfp("11.22222222222222222222"),
+ DfpField.FLAG_INEXACT, "Add #12");
+
+ test(field.newDfp(".11111111111111111111").add(field.newDfp("1111111111111111.1111")), // rounding on add
+ field.newDfp("1111111111111111.2222"),
+ DfpField.FLAG_INEXACT, "Add #13");
+
+ test(field.newDfp(".11111111111111111111").add(field.newDfp("11111111111111111111")), // rounding on add
+ field.newDfp("11111111111111111111"),
+ DfpField.FLAG_INEXACT, "Add #14");
+
+ test(field.newDfp("9.9999999999999999999e131071").add(field.newDfp("-1e131052")), // overflow on add
+ field.newDfp("9.9999999999999999998e131071"),
+ 0, "Add #15");
+
+ test(field.newDfp("9.9999999999999999999e131071").add(field.newDfp("1e131052")), // overflow on add
+ pinf,
+ DfpField.FLAG_OVERFLOW, "Add #16");
+
+ test(field.newDfp("-9.9999999999999999999e131071").add(field.newDfp("-1e131052")), // overflow on add
+ ninf,
+ DfpField.FLAG_OVERFLOW, "Add #17");
+
+ test(field.newDfp("-9.9999999999999999999e131071").add(field.newDfp("1e131052")), // overflow on add
+ field.newDfp("-9.9999999999999999998e131071"),
+ 0, "Add #18");
+
+ test(field.newDfp("1e-131072").add(field.newDfp("1e-131072")), // underflow on add
+ field.newDfp("2e-131072"),
+ 0, "Add #19");
+
+ test(field.newDfp("1.0000000000000001e-131057").add(field.newDfp("-1e-131057")), // underflow on add
+ field.newDfp("1e-131073"),
+ DfpField.FLAG_UNDERFLOW, "Add #20");
+
+ test(field.newDfp("1.1e-131072").add(field.newDfp("-1e-131072")), // underflow on add
+ field.newDfp("1e-131073"),
+ DfpField.FLAG_UNDERFLOW, "Add #21");
+
+ test(field.newDfp("1.0000000000000001e-131072").add(field.newDfp("-1e-131072")), // underflow on add
+ field.newDfp("1e-131088"),
+ DfpField.FLAG_UNDERFLOW, "Add #22");
+
+ test(field.newDfp("1.0000000000000001e-131078").add(field.newDfp("-1e-131078")), // underflow on add
+ field.newDfp("0"),
+ DfpField.FLAG_UNDERFLOW, "Add #23");
+
+ test(field.newDfp("1.0").add(field.newDfp("-1e-20")), // loss of precision on alignment?
+ field.newDfp("0.99999999999999999999"),
+ 0, "Add #23.1");
+
+ test(field.newDfp("-0.99999999999999999999").add(field.newDfp("1")), // proper normalization?
+ field.newDfp("0.00000000000000000001"),
+ 0, "Add #23.2");
+
+ test(field.newDfp("1").add(field.newDfp("0")), // adding zeros
+ field.newDfp("1"),
+ 0, "Add #24");
+
+ test(field.newDfp("0").add(field.newDfp("0")), // adding zeros
+ field.newDfp("0"),
+ 0, "Add #25");
+
+ test(field.newDfp("-0").add(field.newDfp("0")), // adding zeros
+ field.newDfp("0"),
+ 0, "Add #26");
+
+ test(field.newDfp("0").add(field.newDfp("-0")), // adding zeros
+ field.newDfp("0"),
+ 0, "Add #27");
+
+ test(field.newDfp("-0").add(field.newDfp("-0")), // adding zeros
+ field.newDfp("-0"),
+ 0, "Add #28");
+
+ test(field.newDfp("1e-20").add(field.newDfp("0")), // adding zeros
+ field.newDfp("1e-20"),
+ 0, "Add #29");
+
+ test(field.newDfp("1e-40").add(field.newDfp("0")), // adding zeros
+ field.newDfp("1e-40"),
+ 0, "Add #30");
+
+ test(pinf.add(ninf), // adding infinities
+ nan,
+ DfpField.FLAG_INVALID, "Add #31");
+
+ test(ninf.add(pinf), // adding infinities
+ nan,
+ DfpField.FLAG_INVALID, "Add #32");
+
+ test(ninf.add(ninf), // adding infinities
+ ninf,
+ 0, "Add #33");
+
+ test(pinf.add(pinf), // adding infinities
+ pinf,
+ 0, "Add #34");
+
+ test(pinf.add(field.newDfp("0")), // adding infinities
+ pinf,
+ 0, "Add #35");
+
+ test(pinf.add(field.newDfp("-1e131071")), // adding infinities
+ pinf,
+ 0, "Add #36");
+
+ test(pinf.add(field.newDfp("1e131071")), // adding infinities
+ pinf,
+ 0, "Add #37");
+
+ test(field.newDfp("0").add(pinf), // adding infinities
+ pinf,
+ 0, "Add #38");
+
+ test(field.newDfp("-1e131071").add(pinf), // adding infinities
+ pinf,
+ 0, "Add #39");
+
+ test(field.newDfp("1e131071").add(pinf), // adding infinities
+ pinf,
+ 0, "Add #40");
+
+ test(ninf.add(field.newDfp("0")), // adding infinities
+ ninf,
+ 0, "Add #41");
+
+ test(ninf.add(field.newDfp("-1e131071")), // adding infinities
+ ninf,
+ 0, "Add #42");
+
+ test(ninf.add(field.newDfp("1e131071")), // adding infinities
+ ninf,
+ 0, "Add #43");
+
+ test(field.newDfp("0").add(ninf), // adding infinities
+ ninf,
+ 0, "Add #44");
+
+ test(field.newDfp("-1e131071").add(ninf), // adding infinities
+ ninf,
+ 0, "Add #45");
+
+ test(field.newDfp("1e131071").add(ninf), // adding infinities
+ ninf,
+ 0, "Add #46");
+
+ test(field.newDfp("9.9999999999999999999e131071").add(field.newDfp("5e131051")), // overflow
+ pinf,
+ DfpField.FLAG_OVERFLOW, "Add #47");
+
+ test(field.newDfp("9.9999999999999999999e131071").add(field.newDfp("4.9999999999999999999e131051")), // overflow
+ field.newDfp("9.9999999999999999999e131071"),
+ DfpField.FLAG_INEXACT, "Add #48");
+
+ test(nan.add(field.newDfp("1")),
+ nan,
+ 0, "Add #49");
+
+ test(field.newDfp("1").add(nan),
+ nan,
+ 0, "Add #50");
+
+ test(field.newDfp("12345678123456781234").add(field.newDfp("0.12345678123456781234")),
+ field.newDfp("12345678123456781234"),
+ DfpField.FLAG_INEXACT, "Add #51");
+
+ test(field.newDfp("12345678123456781234").add(field.newDfp("123.45678123456781234")),
+ field.newDfp("12345678123456781357"),
+ DfpField.FLAG_INEXACT, "Add #52");
+
+ test(field.newDfp("123.45678123456781234").add(field.newDfp("12345678123456781234")),
+ field.newDfp("12345678123456781357"),
+ DfpField.FLAG_INEXACT, "Add #53");
+
+ test(field.newDfp("12345678123456781234").add(field.newDfp(".00001234567812345678")),
+ field.newDfp("12345678123456781234"),
+ DfpField.FLAG_INEXACT, "Add #54");
+
+ test(field.newDfp("12345678123456781234").add(field.newDfp(".00000000123456781234")),
+ field.newDfp("12345678123456781234"),
+ DfpField.FLAG_INEXACT, "Add #55");
+
+ test(field.newDfp("-0").add(field.newDfp("-0")),
+ field.newDfp("-0"),
+ 0, "Add #56");
+
+ test(field.newDfp("0").add(field.newDfp("-0")),
+ field.newDfp("0"),
+ 0, "Add #57");
+
+ test(field.newDfp("-0").add(field.newDfp("0")),
+ field.newDfp("0"),
+ 0, "Add #58");
+
+ test(field.newDfp("0").add(field.newDfp("0")),
+ field.newDfp("0"),
+ 0, "Add #59");
+ }
+
+ ////////////////////////////////////////////////////////////////////////////////////////////////////////
+
+ // Test comparisons
+
+ // utility function to help test comparisons
+ private void cmptst(Dfp a, Dfp b, String op, boolean result, double num)
+ {
+ if (op == "equal")
+ if (a.equals(b) != result)
+ Assert.fail("assersion failed. "+op+" compare #"+num);
+
+ if (op == "unequal")
+ if (a.unequal(b) != result)
+ Assert.fail("assersion failed. "+op+" compare #"+num);
+
+ if (op == "lessThan")
+ if (a.lessThan(b) != result)
+ Assert.fail("assersion failed. "+op+" compare #"+num);
+
+ if (op == "greaterThan")
+ if (a.greaterThan(b) != result)
+ Assert.fail("assersion failed. "+op+" compare #"+num);
+ }
+
+ @Test
+ public void testCompare()
+ {
+ // test equal() comparison
+ // check zero vs. zero
+ field.clearIEEEFlags();
+
+ cmptst(field.newDfp("0"), field.newDfp("0"), "equal", true, 1); // 0 == 0
+ cmptst(field.newDfp("0"), field.newDfp("-0"), "equal", true, 2); // 0 == -0
+ cmptst(field.newDfp("-0"), field.newDfp("-0"), "equal", true, 3); // -0 == -0
+ cmptst(field.newDfp("-0"), field.newDfp("0"), "equal", true, 4); // -0 == 0
+
+ // check zero vs normal numbers
+
+ cmptst(field.newDfp("0"), field.newDfp("1"), "equal", false, 5); // 0 == 1
+ cmptst(field.newDfp("1"), field.newDfp("0"), "equal", false, 6); // 1 == 0
+ cmptst(field.newDfp("-1"), field.newDfp("0"), "equal", false, 7); // -1 == 0
+ cmptst(field.newDfp("0"), field.newDfp("-1"), "equal", false, 8); // 0 == -1
+ cmptst(field.newDfp("0"), field.newDfp("1e-131072"), "equal", false, 9); // 0 == 1e-131072
+ // check flags
+ if (field.getIEEEFlags() != 0)
+ Assert.fail("assersion failed. compare flags = "+field.getIEEEFlags());
+
+ cmptst(field.newDfp("0"), field.newDfp("1e-131078"), "equal", false, 10); // 0 == 1e-131078
+
+ // check flags -- underflow should be set
+ if (field.getIEEEFlags() != DfpField.FLAG_UNDERFLOW)
+ Assert.fail("assersion failed. compare flags = "+field.getIEEEFlags());
+
+ field.clearIEEEFlags();
+
+ cmptst(field.newDfp("0"), field.newDfp("1e+131071"), "equal", false, 11); // 0 == 1e+131071
+
+ // check zero vs infinities
+
+ cmptst(field.newDfp("0"), pinf, "equal", false, 12); // 0 == pinf
+ cmptst(field.newDfp("0"), ninf, "equal", false, 13); // 0 == ninf
+ cmptst(field.newDfp("-0"), pinf, "equal", false, 14); // -0 == pinf
+ cmptst(field.newDfp("-0"), ninf, "equal", false, 15); // -0 == ninf
+ cmptst(pinf, field.newDfp("0"), "equal", false, 16); // pinf == 0
+ cmptst(ninf, field.newDfp("0"), "equal", false, 17); // ninf == 0
+ cmptst(pinf, field.newDfp("-0"), "equal", false, 18); // pinf == -0
+ cmptst(ninf, field.newDfp("-0"), "equal", false, 19); // ninf == -0
+ cmptst(ninf, pinf, "equal", false, 19.10); // ninf == pinf
+ cmptst(pinf, ninf, "equal", false, 19.11); // pinf == ninf
+ cmptst(pinf, pinf, "equal", true, 19.12); // pinf == pinf
+ cmptst(ninf, ninf, "equal", true, 19.13); // ninf == ninf
+
+ // check some normal numbers
+ cmptst(field.newDfp("1"), field.newDfp("1"), "equal", true, 20); // 1 == 1
+ cmptst(field.newDfp("1"), field.newDfp("-1"), "equal", false, 21); // 1 == -1
+ cmptst(field.newDfp("-1"), field.newDfp("-1"), "equal", true, 22); // -1 == -1
+ cmptst(field.newDfp("1"), field.newDfp("1.0000000000000001"), "equal", false, 23); // 1 == 1.0000000000000001
+
+ // The tests below checks to ensure that comparisons don't set FLAG_INEXACT
+ // 100000 == 1.0000000000000001
+ cmptst(field.newDfp("1e20"), field.newDfp("1.0000000000000001"), "equal", false, 24);
+ if (field.getIEEEFlags() != 0)
+ Assert.fail("assersion failed. compare flags = "+field.getIEEEFlags());
+
+ cmptst(field.newDfp("0.000001"), field.newDfp("1e-6"), "equal", true, 25);
+
+ // check some nans -- nans shouldnt equal anything
+
+ cmptst(snan, snan, "equal", false, 27);
+ cmptst(qnan, qnan, "equal", false, 28);
+ cmptst(snan, qnan, "equal", false, 29);
+ cmptst(qnan, snan, "equal", false, 30);
+ cmptst(qnan, field.newDfp("0"), "equal", false, 31);
+ cmptst(snan, field.newDfp("0"), "equal", false, 32);
+ cmptst(field.newDfp("0"), snan, "equal", false, 33);
+ cmptst(field.newDfp("0"), qnan, "equal", false, 34);
+ cmptst(qnan, pinf, "equal", false, 35);
+ cmptst(snan, pinf, "equal", false, 36);
+ cmptst(pinf, snan, "equal", false, 37);
+ cmptst(pinf, qnan, "equal", false, 38);
+ cmptst(qnan, ninf, "equal", false, 39);
+ cmptst(snan, ninf, "equal", false, 40);
+ cmptst(ninf, snan, "equal", false, 41);
+ cmptst(ninf, qnan, "equal", false, 42);
+ cmptst(qnan, field.newDfp("-1"), "equal", false, 43);
+ cmptst(snan, field.newDfp("-1"), "equal", false, 44);
+ cmptst(field.newDfp("-1"), snan, "equal", false, 45);
+ cmptst(field.newDfp("-1"), qnan, "equal", false, 46);
+ cmptst(qnan, field.newDfp("1"), "equal", false, 47);
+ cmptst(snan, field.newDfp("1"), "equal", false, 48);
+ cmptst(field.newDfp("1"), snan, "equal", false, 49);
+ cmptst(field.newDfp("1"), qnan, "equal", false, 50);
+ cmptst(snan.negate(), snan, "equal", false, 51);
+ cmptst(qnan.negate(), qnan, "equal", false, 52);
+
+ //
+ // Tests for un equal -- do it all over again
+ //
+
+ cmptst(field.newDfp("0"), field.newDfp("0"), "unequal", false, 1); // 0 == 0
+ cmptst(field.newDfp("0"), field.newDfp("-0"), "unequal", false, 2); // 0 == -0
+ cmptst(field.newDfp("-0"), field.newDfp("-0"), "unequal", false, 3); // -0 == -0
+ cmptst(field.newDfp("-0"), field.newDfp("0"), "unequal", false, 4); // -0 == 0
+
+ // check zero vs normal numbers
+
+ cmptst(field.newDfp("0"), field.newDfp("1"), "unequal", true, 5); // 0 == 1
+ cmptst(field.newDfp("1"), field.newDfp("0"), "unequal", true, 6); // 1 == 0
+ cmptst(field.newDfp("-1"), field.newDfp("0"), "unequal", true, 7); // -1 == 0
+ cmptst(field.newDfp("0"), field.newDfp("-1"), "unequal", true, 8); // 0 == -1
+ cmptst(field.newDfp("0"), field.newDfp("1e-131072"), "unequal", true, 9); // 0 == 1e-131072
+ // check flags
+ if (field.getIEEEFlags() != 0)
+ Assert.fail("assersion failed. compare flags = "+field.getIEEEFlags());
+
+ cmptst(field.newDfp("0"), field.newDfp("1e-131078"), "unequal", true, 10); // 0 == 1e-131078
+
+ // check flags -- underflow should be set
+ if (field.getIEEEFlags() != DfpField.FLAG_UNDERFLOW)
+ Assert.fail("assersion failed. compare flags = "+field.getIEEEFlags());
+
+ field.clearIEEEFlags();
+
+ cmptst(field.newDfp("0"), field.newDfp("1e+131071"), "unequal", true, 11); // 0 == 1e+131071
+
+ // check zero vs infinities
+
+ cmptst(field.newDfp("0"), pinf, "unequal", true, 12); // 0 == pinf
+ cmptst(field.newDfp("0"), ninf, "unequal", true, 13); // 0 == ninf
+ cmptst(field.newDfp("-0"), pinf, "unequal", true, 14); // -0 == pinf
+ cmptst(field.newDfp("-0"), ninf, "unequal", true, 15); // -0 == ninf
+ cmptst(pinf, field.newDfp("0"), "unequal", true, 16); // pinf == 0
+ cmptst(ninf, field.newDfp("0"), "unequal", true, 17); // ninf == 0
+ cmptst(pinf, field.newDfp("-0"), "unequal", true, 18); // pinf == -0
+ cmptst(ninf, field.newDfp("-0"), "unequal", true, 19); // ninf == -0
+ cmptst(ninf, pinf, "unequal", true, 19.10); // ninf == pinf
+ cmptst(pinf, ninf, "unequal", true, 19.11); // pinf == ninf
+ cmptst(pinf, pinf, "unequal", false, 19.12); // pinf == pinf
+ cmptst(ninf, ninf, "unequal", false, 19.13); // ninf == ninf
+
+ // check some normal numbers
+ cmptst(field.newDfp("1"), field.newDfp("1"), "unequal", false, 20); // 1 == 1
+ cmptst(field.newDfp("1"), field.newDfp("-1"), "unequal", true, 21); // 1 == -1
+ cmptst(field.newDfp("-1"), field.newDfp("-1"), "unequal", false, 22); // -1 == -1
+ cmptst(field.newDfp("1"), field.newDfp("1.0000000000000001"), "unequal", true, 23); // 1 == 1.0000000000000001
+
+ // The tests below checks to ensure that comparisons don't set FLAG_INEXACT
+ // 100000 == 1.0000000000000001
+ cmptst(field.newDfp("1e20"), field.newDfp("1.0000000000000001"), "unequal", true, 24);
+ if (field.getIEEEFlags() != 0)
+ Assert.fail("assersion failed. compare flags = "+field.getIEEEFlags());
+
+ cmptst(field.newDfp("0.000001"), field.newDfp("1e-6"), "unequal", false, 25);
+
+ // check some nans -- nans shouldnt be unequal to anything
+
+ cmptst(snan, snan, "unequal", false, 27);
+ cmptst(qnan, qnan, "unequal", false, 28);
+ cmptst(snan, qnan, "unequal", false, 29);
+ cmptst(qnan, snan, "unequal", false, 30);
+ cmptst(qnan, field.newDfp("0"), "unequal", false, 31);
+ cmptst(snan, field.newDfp("0"), "unequal", false, 32);
+ cmptst(field.newDfp("0"), snan, "unequal", false, 33);
+ cmptst(field.newDfp("0"), qnan, "unequal", false, 34);
+ cmptst(qnan, pinf, "unequal", false, 35);
+ cmptst(snan, pinf, "unequal", false, 36);
+ cmptst(pinf, snan, "unequal", false, 37);
+ cmptst(pinf, qnan, "unequal", false, 38);
+ cmptst(qnan, ninf, "unequal", false, 39);
+ cmptst(snan, ninf, "unequal", false, 40);
+ cmptst(ninf, snan, "unequal", false, 41);
+ cmptst(ninf, qnan, "unequal", false, 42);
+ cmptst(qnan, field.newDfp("-1"), "unequal", false, 43);
+ cmptst(snan, field.newDfp("-1"), "unequal", false, 44);
+ cmptst(field.newDfp("-1"), snan, "unequal", false, 45);
+ cmptst(field.newDfp("-1"), qnan, "unequal", false, 46);
+ cmptst(qnan, field.newDfp("1"), "unequal", false, 47);
+ cmptst(snan, field.newDfp("1"), "unequal", false, 48);
+ cmptst(field.newDfp("1"), snan, "unequal", false, 49);
+ cmptst(field.newDfp("1"), qnan, "unequal", false, 50);
+ cmptst(snan.negate(), snan, "unequal", false, 51);
+ cmptst(qnan.negate(), qnan, "unequal", false, 52);
+
+ if (field.getIEEEFlags() != 0)
+ Assert.fail("assersion failed. compare unequal flags = "+field.getIEEEFlags());
+
+ //
+ // Tests for lessThan -- do it all over again
+ //
+
+ cmptst(field.newDfp("0"), field.newDfp("0"), "lessThan", false, 1); // 0 < 0
+ cmptst(field.newDfp("0"), field.newDfp("-0"), "lessThan", false, 2); // 0 < -0
+ cmptst(field.newDfp("-0"), field.newDfp("-0"), "lessThan", false, 3); // -0 < -0
+ cmptst(field.newDfp("-0"), field.newDfp("0"), "lessThan", false, 4); // -0 < 0
+
+ // check zero vs normal numbers
+
+ cmptst(field.newDfp("0"), field.newDfp("1"), "lessThan", true, 5); // 0 < 1
+ cmptst(field.newDfp("1"), field.newDfp("0"), "lessThan", false, 6); // 1 < 0
+ cmptst(field.newDfp("-1"), field.newDfp("0"), "lessThan", true, 7); // -1 < 0
+ cmptst(field.newDfp("0"), field.newDfp("-1"), "lessThan", false, 8); // 0 < -1
+ cmptst(field.newDfp("0"), field.newDfp("1e-131072"), "lessThan", true, 9); // 0 < 1e-131072
+ // check flags
+ if (field.getIEEEFlags() != 0)
+ Assert.fail("assersion failed. compare flags = "+field.getIEEEFlags());
+
+ cmptst(field.newDfp("0"), field.newDfp("1e-131078"), "lessThan", true, 10); // 0 < 1e-131078
+
+ // check flags -- underflow should be set
+ if (field.getIEEEFlags() != DfpField.FLAG_UNDERFLOW)
+ Assert.fail("assersion failed. compare flags = "+field.getIEEEFlags());
+ field.clearIEEEFlags();
+
+ cmptst(field.newDfp("0"), field.newDfp("1e+131071"), "lessThan", true, 11); // 0 < 1e+131071
+
+ // check zero vs infinities
+
+ cmptst(field.newDfp("0"), pinf, "lessThan", true, 12); // 0 < pinf
+ cmptst(field.newDfp("0"), ninf, "lessThan", false, 13); // 0 < ninf
+ cmptst(field.newDfp("-0"), pinf, "lessThan", true, 14); // -0 < pinf
+ cmptst(field.newDfp("-0"), ninf, "lessThan", false, 15); // -0 < ninf
+ cmptst(pinf, field.newDfp("0"), "lessThan", false, 16); // pinf < 0
+ cmptst(ninf, field.newDfp("0"), "lessThan", true, 17); // ninf < 0
+ cmptst(pinf, field.newDfp("-0"), "lessThan", false, 18); // pinf < -0
+ cmptst(ninf, field.newDfp("-0"), "lessThan", true, 19); // ninf < -0
+ cmptst(ninf, pinf, "lessThan", true, 19.10); // ninf < pinf
+ cmptst(pinf, ninf, "lessThan", false, 19.11); // pinf < ninf
+ cmptst(pinf, pinf, "lessThan", false, 19.12); // pinf < pinf
+ cmptst(ninf, ninf, "lessThan", false, 19.13); // ninf < ninf
+
+ // check some normal numbers
+ cmptst(field.newDfp("1"), field.newDfp("1"), "lessThan", false, 20); // 1 < 1
+ cmptst(field.newDfp("1"), field.newDfp("-1"), "lessThan", false, 21); // 1 < -1
+ cmptst(field.newDfp("-1"), field.newDfp("-1"), "lessThan", false, 22); // -1 < -1
+ cmptst(field.newDfp("1"), field.newDfp("1.0000000000000001"), "lessThan", true, 23); // 1 < 1.0000000000000001
+
+ // The tests below checks to ensure that comparisons don't set FLAG_INEXACT
+ // 100000 < 1.0000000000000001
+ cmptst(field.newDfp("1e20"), field.newDfp("1.0000000000000001"), "lessThan", false, 24);
+ if (field.getIEEEFlags() != 0)
+ Assert.fail("assersion failed. compare flags = "+field.getIEEEFlags());
+
+ cmptst(field.newDfp("0.000001"), field.newDfp("1e-6"), "lessThan", false, 25);
+
+ // check some nans -- nans shouldnt be lessThan to anything
+ cmptst(snan, snan, "lessThan", false, 27);
+ cmptst(qnan, qnan, "lessThan", false, 28);
+ cmptst(snan, qnan, "lessThan", false, 29);
+ cmptst(qnan, snan, "lessThan", false, 30);
+ cmptst(qnan, field.newDfp("0"), "lessThan", false, 31);
+ cmptst(snan, field.newDfp("0"), "lessThan", false, 32);
+ cmptst(field.newDfp("0"), snan, "lessThan", false, 33);
+ cmptst(field.newDfp("0"), qnan, "lessThan", false, 34);
+ cmptst(qnan, pinf, "lessThan", false, 35);
+ cmptst(snan, pinf, "lessThan", false, 36);
+ cmptst(pinf, snan, "lessThan", false, 37);
+ cmptst(pinf, qnan, "lessThan", false, 38);
+ cmptst(qnan, ninf, "lessThan", false, 39);
+ cmptst(snan, ninf, "lessThan", false, 40);
+ cmptst(ninf, snan, "lessThan", false, 41);
+ cmptst(ninf, qnan, "lessThan", false, 42);
+ cmptst(qnan, field.newDfp("-1"), "lessThan", false, 43);
+ cmptst(snan, field.newDfp("-1"), "lessThan", false, 44);
+ cmptst(field.newDfp("-1"), snan, "lessThan", false, 45);
+ cmptst(field.newDfp("-1"), qnan, "lessThan", false, 46);
+ cmptst(qnan, field.newDfp("1"), "lessThan", false, 47);
+ cmptst(snan, field.newDfp("1"), "lessThan", false, 48);
+ cmptst(field.newDfp("1"), snan, "lessThan", false, 49);
+ cmptst(field.newDfp("1"), qnan, "lessThan", false, 50);
+ cmptst(snan.negate(), snan, "lessThan", false, 51);
+ cmptst(qnan.negate(), qnan, "lessThan", false, 52);
+
+ //lessThan compares with nans should raise FLAG_INVALID
+ if (field.getIEEEFlags() != DfpField.FLAG_INVALID)
+ Assert.fail("assersion failed. compare lessThan flags = "+field.getIEEEFlags());
+ field.clearIEEEFlags();
+
+ //
+ // Tests for greaterThan -- do it all over again
+ //
+
+ cmptst(field.newDfp("0"), field.newDfp("0"), "greaterThan", false, 1); // 0 > 0
+ cmptst(field.newDfp("0"), field.newDfp("-0"), "greaterThan", false, 2); // 0 > -0
+ cmptst(field.newDfp("-0"), field.newDfp("-0"), "greaterThan", false, 3); // -0 > -0
+ cmptst(field.newDfp("-0"), field.newDfp("0"), "greaterThan", false, 4); // -0 > 0
+
+ // check zero vs normal numbers
+
+ cmptst(field.newDfp("0"), field.newDfp("1"), "greaterThan", false, 5); // 0 > 1
+ cmptst(field.newDfp("1"), field.newDfp("0"), "greaterThan", true, 6); // 1 > 0
+ cmptst(field.newDfp("-1"), field.newDfp("0"), "greaterThan", false, 7); // -1 > 0
+ cmptst(field.newDfp("0"), field.newDfp("-1"), "greaterThan", true, 8); // 0 > -1
+ cmptst(field.newDfp("0"), field.newDfp("1e-131072"), "greaterThan", false, 9); // 0 > 1e-131072
+ // check flags
+ if (field.getIEEEFlags() != 0)
+ Assert.fail("assersion failed. compare flags = "+field.getIEEEFlags());
+
+ cmptst(field.newDfp("0"), field.newDfp("1e-131078"), "greaterThan", false, 10); // 0 > 1e-131078
+
+ // check flags -- underflow should be set
+ if (field.getIEEEFlags() != DfpField.FLAG_UNDERFLOW)
+ Assert.fail("assersion failed. compare flags = "+field.getIEEEFlags());
+ field.clearIEEEFlags();
+
+ cmptst(field.newDfp("0"), field.newDfp("1e+131071"), "greaterThan", false, 11); // 0 > 1e+131071
+
+ // check zero vs infinities
+
+ cmptst(field.newDfp("0"), pinf, "greaterThan", false, 12); // 0 > pinf
+ cmptst(field.newDfp("0"), ninf, "greaterThan", true, 13); // 0 > ninf
+ cmptst(field.newDfp("-0"), pinf, "greaterThan", false, 14); // -0 > pinf
+ cmptst(field.newDfp("-0"), ninf, "greaterThan", true, 15); // -0 > ninf
+ cmptst(pinf, field.newDfp("0"), "greaterThan", true, 16); // pinf > 0
+ cmptst(ninf, field.newDfp("0"), "greaterThan", false, 17); // ninf > 0
+ cmptst(pinf, field.newDfp("-0"), "greaterThan", true, 18); // pinf > -0
+ cmptst(ninf, field.newDfp("-0"), "greaterThan", false, 19); // ninf > -0
+ cmptst(ninf, pinf, "greaterThan", false, 19.10); // ninf > pinf
+ cmptst(pinf, ninf, "greaterThan", true, 19.11); // pinf > ninf
+ cmptst(pinf, pinf, "greaterThan", false, 19.12); // pinf > pinf
+ cmptst(ninf, ninf, "greaterThan", false, 19.13); // ninf > ninf
+
+ // check some normal numbers
+ cmptst(field.newDfp("1"), field.newDfp("1"), "greaterThan", false, 20); // 1 > 1
+ cmptst(field.newDfp("1"), field.newDfp("-1"), "greaterThan", true, 21); // 1 > -1
+ cmptst(field.newDfp("-1"), field.newDfp("-1"), "greaterThan", false, 22); // -1 > -1
+ cmptst(field.newDfp("1"), field.newDfp("1.0000000000000001"), "greaterThan", false, 23); // 1 > 1.0000000000000001
+
+ // The tests below checks to ensure that comparisons don't set FLAG_INEXACT
+ // 100000 > 1.0000000000000001
+ cmptst(field.newDfp("1e20"), field.newDfp("1.0000000000000001"), "greaterThan", true, 24);
+ if (field.getIEEEFlags() != 0)
+ Assert.fail("assersion failed. compare flags = "+field.getIEEEFlags());
+
+ cmptst(field.newDfp("0.000001"), field.newDfp("1e-6"), "greaterThan", false, 25);
+
+ // check some nans -- nans shouldnt be greaterThan to anything
+ cmptst(snan, snan, "greaterThan", false, 27);
+ cmptst(qnan, qnan, "greaterThan", false, 28);
+ cmptst(snan, qnan, "greaterThan", false, 29);
+ cmptst(qnan, snan, "greaterThan", false, 30);
+ cmptst(qnan, field.newDfp("0"), "greaterThan", false, 31);
+ cmptst(snan, field.newDfp("0"), "greaterThan", false, 32);
+ cmptst(field.newDfp("0"), snan, "greaterThan", false, 33);
+ cmptst(field.newDfp("0"), qnan, "greaterThan", false, 34);
+ cmptst(qnan, pinf, "greaterThan", false, 35);
+ cmptst(snan, pinf, "greaterThan", false, 36);
+ cmptst(pinf, snan, "greaterThan", false, 37);
+ cmptst(pinf, qnan, "greaterThan", false, 38);
+ cmptst(qnan, ninf, "greaterThan", false, 39);
+ cmptst(snan, ninf, "greaterThan", false, 40);
+ cmptst(ninf, snan, "greaterThan", false, 41);
+ cmptst(ninf, qnan, "greaterThan", false, 42);
+ cmptst(qnan, field.newDfp("-1"), "greaterThan", false, 43);
+ cmptst(snan, field.newDfp("-1"), "greaterThan", false, 44);
+ cmptst(field.newDfp("-1"), snan, "greaterThan", false, 45);
+ cmptst(field.newDfp("-1"), qnan, "greaterThan", false, 46);
+ cmptst(qnan, field.newDfp("1"), "greaterThan", false, 47);
+ cmptst(snan, field.newDfp("1"), "greaterThan", false, 48);
+ cmptst(field.newDfp("1"), snan, "greaterThan", false, 49);
+ cmptst(field.newDfp("1"), qnan, "greaterThan", false, 50);
+ cmptst(snan.negate(), snan, "greaterThan", false, 51);
+ cmptst(qnan.negate(), qnan, "greaterThan", false, 52);
+
+ //greaterThan compares with nans should raise FLAG_INVALID
+ if (field.getIEEEFlags() != DfpField.FLAG_INVALID)
+ Assert.fail("assersion failed. compare greaterThan flags = "+field.getIEEEFlags());
+ field.clearIEEEFlags();
+ }
+
+ //
+ // Test multiplication
+ //
+ @Test
+ public void testMultiply()
+ {
+ test(field.newDfp("1").multiply(field.newDfp("1")), // Basic tests 1*1 = 1
+ field.newDfp("1"),
+ 0, "Multiply #1");
+
+ test(field.newDfp("1").multiply(1), // Basic tests 1*1 = 1
+ field.newDfp("1"),
+ 0, "Multiply #2");
+
+ test(field.newDfp("-1").multiply(field.newDfp("1")), // Basic tests -1*1 = -1
+ field.newDfp("-1"),
+ 0, "Multiply #3");
+
+ test(field.newDfp("-1").multiply(1), // Basic tests -1*1 = -1
+ field.newDfp("-1"),
+ 0, "Multiply #4");
+
+ // basic tests with integers
+ test(field.newDfp("2").multiply(field.newDfp("3")),
+ field.newDfp("6"),
+ 0, "Multiply #5");
+
+ test(field.newDfp("2").multiply(3),
+ field.newDfp("6"),
+ 0, "Multiply #6");
+
+ test(field.newDfp("-2").multiply(field.newDfp("3")),
+ field.newDfp("-6"),
+ 0, "Multiply #7");
+
+ test(field.newDfp("-2").multiply(3),
+ field.newDfp("-6"),
+ 0, "Multiply #8");
+
+ test(field.newDfp("2").multiply(field.newDfp("-3")),
+ field.newDfp("-6"),
+ 0, "Multiply #9");
+
+ test(field.newDfp("-2").multiply(field.newDfp("-3")),
+ field.newDfp("6"),
+ 0, "Multiply #10");
+
+ //multiply by zero
+
+ test(field.newDfp("-2").multiply(field.newDfp("0")),
+ field.newDfp("-0"),
+ 0, "Multiply #11");
+
+ test(field.newDfp("-2").multiply(0),
+ field.newDfp("-0"),
+ 0, "Multiply #12");
+
+ test(field.newDfp("2").multiply(field.newDfp("0")),
+ field.newDfp("0"),
+ 0, "Multiply #13");
+
+ test(field.newDfp("2").multiply(0),
+ field.newDfp("0"),
+ 0, "Multiply #14");
+
+ test(field.newDfp("2").multiply(pinf),
+ pinf,
+ 0, "Multiply #15");
+
+ test(field.newDfp("2").multiply(ninf),
+ ninf,
+ 0, "Multiply #16");
+
+ test(field.newDfp("-2").multiply(pinf),
+ ninf,
+ 0, "Multiply #17");
+
+ test(field.newDfp("-2").multiply(ninf),
+ pinf,
+ 0, "Multiply #18");
+
+ test(ninf.multiply(field.newDfp("-2")),
+ pinf,
+ 0, "Multiply #18.1");
+
+ test(field.newDfp("5e131071").multiply(2),
+ pinf,
+ DfpField.FLAG_OVERFLOW, "Multiply #19");
+
+ test(field.newDfp("5e131071").multiply(field.newDfp("1.999999999999999")),
+ field.newDfp("9.9999999999999950000e131071"),
+ 0, "Multiply #20");
+
+ test(field.newDfp("-5e131071").multiply(2),
+ ninf,
+ DfpField.FLAG_OVERFLOW, "Multiply #22");
+
+ test(field.newDfp("-5e131071").multiply(field.newDfp("1.999999999999999")),
+ field.newDfp("-9.9999999999999950000e131071"),
+ 0, "Multiply #23");
+
+ test(field.newDfp("1e-65539").multiply(field.newDfp("1e-65539")),
+ field.newDfp("1e-131078"),
+ DfpField.FLAG_UNDERFLOW, "Multiply #24");
+
+ test(field.newDfp("1").multiply(nan),
+ nan,
+ 0, "Multiply #25");
+
+ test(nan.multiply(field.newDfp("1")),
+ nan,
+ 0, "Multiply #26");
+
+ test(nan.multiply(pinf),
+ nan,
+ 0, "Multiply #27");
+
+ test(pinf.multiply(nan),
+ nan,
+ 0, "Multiply #27");
+
+ test(pinf.multiply(field.newDfp("0")),
+ nan,
+ DfpField.FLAG_INVALID, "Multiply #28");
+
+ test(field.newDfp("0").multiply(pinf),
+ nan,
+ DfpField.FLAG_INVALID, "Multiply #29");
+
+ test(pinf.multiply(pinf),
+ pinf,
+ 0, "Multiply #30");
+
+ test(ninf.multiply(pinf),
+ ninf,
+ 0, "Multiply #31");
+
+ test(pinf.multiply(ninf),
+ ninf,
+ 0, "Multiply #32");
+
+ test(ninf.multiply(ninf),
+ pinf,
+ 0, "Multiply #33");
+
+ test(pinf.multiply(1),
+ pinf,
+ 0, "Multiply #34");
+
+ test(pinf.multiply(0),
+ nan,
+ DfpField.FLAG_INVALID, "Multiply #35");
+
+ test(nan.multiply(1),
+ nan,
+ 0, "Multiply #36");
+
+ test(field.newDfp("1").multiply(10000), // out of range
+ nan,
+ DfpField.FLAG_INVALID, "Multiply #37");
+
+ test(field.newDfp("1").multiply(-1), // out of range
+ nan,
+ DfpField.FLAG_INVALID, "Multiply #38");
+ }
+
+ @Test
+ public void testDivide()
+ {
+ test(field.newDfp("1").divide(nan), // divide by NaN = NaN
+ nan,
+ 0, "Divide #1");
+
+ test(nan.divide(field.newDfp("1")), // NaN / number = NaN
+ nan,
+ 0, "Divide #2");
+
+ test(pinf.divide(field.newDfp("1")),
+ pinf,
+ 0, "Divide #3");
+
+ test(pinf.divide(field.newDfp("-1")),
+ ninf,
+ 0, "Divide #4");
+
+ test(pinf.divide(pinf),
+ nan,
+ DfpField.FLAG_INVALID, "Divide #5");
+
+ test(ninf.divide(pinf),
+ nan,
+ DfpField.FLAG_INVALID, "Divide #6");
+
+ test(pinf.divide(ninf),
+ nan,
+ DfpField.FLAG_INVALID, "Divide #7");
+
+ test(ninf.divide(ninf),
+ nan,
+ DfpField.FLAG_INVALID, "Divide #8");
+
+ test(field.newDfp("0").divide(field.newDfp("0")),
+ nan,
+ DfpField.FLAG_DIV_ZERO, "Divide #9");
+
+ test(field.newDfp("1").divide(field.newDfp("0")),
+ pinf,
+ DfpField.FLAG_DIV_ZERO, "Divide #10");
+
+ test(field.newDfp("1").divide(field.newDfp("-0")),
+ ninf,
+ DfpField.FLAG_DIV_ZERO, "Divide #11");
+
+ test(field.newDfp("-1").divide(field.newDfp("0")),
+ ninf,
+ DfpField.FLAG_DIV_ZERO, "Divide #12");
+
+ test(field.newDfp("-1").divide(field.newDfp("-0")),
+ pinf,
+ DfpField.FLAG_DIV_ZERO, "Divide #13");
+
+ test(field.newDfp("1").divide(field.newDfp("3")),
+ field.newDfp("0.33333333333333333333"),
+ DfpField.FLAG_INEXACT, "Divide #14");
+
+ test(field.newDfp("1").divide(field.newDfp("6")),
+ field.newDfp("0.16666666666666666667"),
+ DfpField.FLAG_INEXACT, "Divide #15");
+
+ test(field.newDfp("10").divide(field.newDfp("6")),
+ field.newDfp("1.6666666666666667"),
+ DfpField.FLAG_INEXACT, "Divide #16");
+
+ test(field.newDfp("100").divide(field.newDfp("6")),
+ field.newDfp("16.6666666666666667"),
+ DfpField.FLAG_INEXACT, "Divide #17");
+
+ test(field.newDfp("1000").divide(field.newDfp("6")),
+ field.newDfp("166.6666666666666667"),
+ DfpField.FLAG_INEXACT, "Divide #18");
+
+ test(field.newDfp("10000").divide(field.newDfp("6")),
+ field.newDfp("1666.6666666666666667"),
+ DfpField.FLAG_INEXACT, "Divide #19");
+
+ test(field.newDfp("1").divide(field.newDfp("1")),
+ field.newDfp("1"),
+ 0, "Divide #20");
+
+ test(field.newDfp("1").divide(field.newDfp("-1")),
+ field.newDfp("-1"),
+ 0, "Divide #21");
+
+ test(field.newDfp("-1").divide(field.newDfp("1")),
+ field.newDfp("-1"),
+ 0, "Divide #22");
+
+ test(field.newDfp("-1").divide(field.newDfp("-1")),
+ field.newDfp("1"),
+ 0, "Divide #23");
+
+ test(field.newDfp("1e-65539").divide(field.newDfp("1e65539")),
+ field.newDfp("1e-131078"),
+ DfpField.FLAG_UNDERFLOW, "Divide #24");
+
+ test(field.newDfp("1e65539").divide(field.newDfp("1e-65539")),
+ pinf,
+ DfpField.FLAG_OVERFLOW, "Divide #24");
+
+ test(field.newDfp("2").divide(field.newDfp("1.5")), // test trial-divisor too high
+ field.newDfp("1.3333333333333333"),
+ DfpField.FLAG_INEXACT, "Divide #25");
+
+ test(field.newDfp("2").divide(pinf),
+ field.newDfp("0"),
+ 0, "Divide #26");
+
+ test(field.newDfp("2").divide(ninf),
+ field.newDfp("-0"),
+ 0, "Divide #27");
+
+ test(field.newDfp("0").divide(field.newDfp("1")),
+ field.newDfp("0"),
+ 0, "Divide #28");
+ }
+
+ @Test
+ public void testDivideInt()
+ {
+ test(nan.divide(1), // NaN / number = NaN
+ nan,
+ 0, "DivideInt #1");
+
+ test(pinf.divide(1),
+ pinf,
+ 0, "DivideInt #2");
+
+ test(field.newDfp("0").divide(0),
+ nan,
+ DfpField.FLAG_DIV_ZERO, "DivideInt #3");
+
+ test(field.newDfp("1").divide(0),
+ pinf,
+ DfpField.FLAG_DIV_ZERO, "DivideInt #4");
+
+ test(field.newDfp("-1").divide(0),
+ ninf,
+ DfpField.FLAG_DIV_ZERO, "DivideInt #5");
+
+ test(field.newDfp("1").divide(3),
+ field.newDfp("0.33333333333333333333"),
+ DfpField.FLAG_INEXACT, "DivideInt #6");
+
+ test(field.newDfp("1").divide(6),
+ field.newDfp("0.16666666666666666667"),
+ DfpField.FLAG_INEXACT, "DivideInt #7");
+
+ test(field.newDfp("10").divide(6),
+ field.newDfp("1.6666666666666667"),
+ DfpField.FLAG_INEXACT, "DivideInt #8");
+
+ test(field.newDfp("100").divide(6),
+ field.newDfp("16.6666666666666667"),
+ DfpField.FLAG_INEXACT, "DivideInt #9");
+
+ test(field.newDfp("1000").divide(6),
+ field.newDfp("166.6666666666666667"),
+ DfpField.FLAG_INEXACT, "DivideInt #10");
+
+ test(field.newDfp("10000").divide(6),
+ field.newDfp("1666.6666666666666667"),
+ DfpField.FLAG_INEXACT, "DivideInt #20");
+
+ test(field.newDfp("1").divide(1),
+ field.newDfp("1"),
+ 0, "DivideInt #21");
+
+ test(field.newDfp("1e-131077").divide(10),
+ field.newDfp("1e-131078"),
+ DfpField.FLAG_UNDERFLOW, "DivideInt #22");
+
+ test(field.newDfp("0").divide(1),
+ field.newDfp("0"),
+ 0, "DivideInt #23");
+
+ test(field.newDfp("1").divide(10000),
+ nan,
+ DfpField.FLAG_INVALID, "DivideInt #24");
+
+ test(field.newDfp("1").divide(-1),
+ nan,
+ DfpField.FLAG_INVALID, "DivideInt #25");
+ }
+
+ @Test
+ public void testNextAfter()
+ {
+ test(field.newDfp("1").nextAfter(pinf),
+ field.newDfp("1.0000000000000001"),
+ 0, "NextAfter #1");
+
+ test(field.newDfp("1.0000000000000001").nextAfter(ninf),
+ field.newDfp("1"),
+ 0, "NextAfter #1.5");
+
+ test(field.newDfp("1").nextAfter(ninf),
+ field.newDfp("0.99999999999999999999"),
+ 0, "NextAfter #2");
+
+ test(field.newDfp("0.99999999999999999999").nextAfter(field.newDfp("2")),
+ field.newDfp("1"),
+ 0, "NextAfter #3");
+
+ test(field.newDfp("-1").nextAfter(ninf),
+ field.newDfp("-1.0000000000000001"),
+ 0, "NextAfter #4");
+
+ test(field.newDfp("-1").nextAfter(pinf),
+ field.newDfp("-0.99999999999999999999"),
+ 0, "NextAfter #5");
+
+ test(field.newDfp("-0.99999999999999999999").nextAfter(field.newDfp("-2")),
+ field.newDfp("-1"),
+ 0, "NextAfter #6");
+
+ test(field.newDfp("2").nextAfter(field.newDfp("2")),
+ field.newDfp("2"),
+ 0, "NextAfter #7");
+
+ test(field.newDfp("0").nextAfter(field.newDfp("0")),
+ field.newDfp("0"),
+ 0, "NextAfter #8");
+
+ test(field.newDfp("-2").nextAfter(field.newDfp("-2")),
+ field.newDfp("-2"),
+ 0, "NextAfter #9");
+
+ test(field.newDfp("0").nextAfter(field.newDfp("1")),
+ field.newDfp("1e-131092"),
+ DfpField.FLAG_UNDERFLOW, "NextAfter #10");
+
+ test(field.newDfp("0").nextAfter(field.newDfp("-1")),
+ field.newDfp("-1e-131092"),
+ DfpField.FLAG_UNDERFLOW, "NextAfter #11");
+
+ test(field.newDfp("-1e-131092").nextAfter(pinf),
+ field.newDfp("-0"),
+ DfpField.FLAG_UNDERFLOW|DfpField.FLAG_INEXACT, "Next After #12");
+
+ test(field.newDfp("1e-131092").nextAfter(ninf),
+ field.newDfp("0"),
+ DfpField.FLAG_UNDERFLOW|DfpField.FLAG_INEXACT, "Next After #13");
+
+ test(field.newDfp("9.9999999999999999999e131078").nextAfter(pinf),
+ pinf,
+ DfpField.FLAG_OVERFLOW|DfpField.FLAG_INEXACT, "Next After #14");
+ }
+
+ @Test
+ public void testToString()
+ {
+ Assert.assertEquals("toString #1", "Infinity", pinf.toString());
+ Assert.assertEquals("toString #2", "-Infinity", ninf.toString());
+ Assert.assertEquals("toString #3", "NaN", nan.toString());
+ Assert.assertEquals("toString #4", "NaN", field.newDfp((byte) 1, (byte) Dfp.QNAN).toString());
+ Assert.assertEquals("toString #5", "NaN", field.newDfp((byte) 1, (byte) Dfp.SNAN).toString());
+ Assert.assertEquals("toString #6", "1.2300000000000000e100", field.newDfp("1.23e100").toString());
+ Assert.assertEquals("toString #7", "-1.2300000000000000e100", field.newDfp("-1.23e100").toString());
+ Assert.assertEquals("toString #8", "12345678.1234", field.newDfp("12345678.1234").toString());
+ Assert.assertEquals("toString #9", "0.00001234", field.newDfp("0.00001234").toString());
+ }
+
+ @Test
+ public void testRound()
+ {
+ field.setRoundingMode(DfpField.RoundingMode.ROUND_DOWN);
+
+ // Round down
+ test(field.newDfp("12345678901234567890").add(field.newDfp("0.9")),
+ field.newDfp("12345678901234567890"),
+ DfpField.FLAG_INEXACT, "Round #1");
+
+ test(field.newDfp("12345678901234567890").add(field.newDfp("0.99999999")),
+ field.newDfp("12345678901234567890"),
+ DfpField.FLAG_INEXACT, "Round #2");
+
+ test(field.newDfp("-12345678901234567890").add(field.newDfp("-0.99999999")),
+ field.newDfp("-12345678901234567890"),
+ DfpField.FLAG_INEXACT, "Round #3");
+
+ field.setRoundingMode(DfpField.RoundingMode.ROUND_UP);
+
+ // Round up
+ test(field.newDfp("12345678901234567890").add(field.newDfp("0.1")),
+ field.newDfp("12345678901234567891"),
+ DfpField.FLAG_INEXACT, "Round #4");
+
+ test(field.newDfp("12345678901234567890").add(field.newDfp("0.0001")),
+ field.newDfp("12345678901234567891"),
+ DfpField.FLAG_INEXACT, "Round #5");
+
+ test(field.newDfp("-12345678901234567890").add(field.newDfp("-0.1")),
+ field.newDfp("-12345678901234567891"),
+ DfpField.FLAG_INEXACT, "Round #6");
+
+ test(field.newDfp("-12345678901234567890").add(field.newDfp("-0.0001")),
+ field.newDfp("-12345678901234567891"),
+ DfpField.FLAG_INEXACT, "Round #7");
+
+ field.setRoundingMode(DfpField.RoundingMode.ROUND_HALF_UP);
+
+ // Round half up
+ test(field.newDfp("12345678901234567890").add(field.newDfp("0.4999")),
+ field.newDfp("12345678901234567890"),
+ DfpField.FLAG_INEXACT, "Round #8");
+
+ test(field.newDfp("12345678901234567890").add(field.newDfp("0.5000")),
+ field.newDfp("12345678901234567891"),
+ DfpField.FLAG_INEXACT, "Round #9");
+
+ test(field.newDfp("-12345678901234567890").add(field.newDfp("-0.4999")),
+ field.newDfp("-12345678901234567890"),
+ DfpField.FLAG_INEXACT, "Round #10");
+
+ test(field.newDfp("-12345678901234567890").add(field.newDfp("-0.5000")),
+ field.newDfp("-12345678901234567891"),
+ DfpField.FLAG_INEXACT, "Round #11");
+
+ field.setRoundingMode(DfpField.RoundingMode.ROUND_HALF_DOWN);
+
+ // Round half down
+ test(field.newDfp("12345678901234567890").add(field.newDfp("0.5001")),
+ field.newDfp("12345678901234567891"),
+ DfpField.FLAG_INEXACT, "Round #12");
+
+ test(field.newDfp("12345678901234567890").add(field.newDfp("0.5000")),
+ field.newDfp("12345678901234567890"),
+ DfpField.FLAG_INEXACT, "Round #13");
+
+ test(field.newDfp("-12345678901234567890").add(field.newDfp("-0.5001")),
+ field.newDfp("-12345678901234567891"),
+ DfpField.FLAG_INEXACT, "Round #14");
+
+ test(field.newDfp("-12345678901234567890").add(field.newDfp("-0.5000")),
+ field.newDfp("-12345678901234567890"),
+ DfpField.FLAG_INEXACT, "Round #15");
+
+ field.setRoundingMode(DfpField.RoundingMode.ROUND_HALF_ODD);
+
+ // Round half odd
+ test(field.newDfp("12345678901234567890").add(field.newDfp("0.5000")),
+ field.newDfp("12345678901234567891"),
+ DfpField.FLAG_INEXACT, "Round #16");
+
+ test(field.newDfp("12345678901234567891").add(field.newDfp("0.5000")),
+ field.newDfp("12345678901234567891"),
+ DfpField.FLAG_INEXACT, "Round #17");
+
+ test(field.newDfp("-12345678901234567890").add(field.newDfp("-0.5000")),
+ field.newDfp("-12345678901234567891"),
+ DfpField.FLAG_INEXACT, "Round #18");
+
+ test(field.newDfp("-12345678901234567891").add(field.newDfp("-0.5000")),
+ field.newDfp("-12345678901234567891"),
+ DfpField.FLAG_INEXACT, "Round #19");
+
+ field.setRoundingMode(DfpField.RoundingMode.ROUND_CEIL);
+
+ // Round ceil
+ test(field.newDfp("12345678901234567890").add(field.newDfp("0.0001")),
+ field.newDfp("12345678901234567891"),
+ DfpField.FLAG_INEXACT, "Round #20");
+
+ test(field.newDfp("-12345678901234567890").add(field.newDfp("-0.9999")),
+ field.newDfp("-12345678901234567890"),
+ DfpField.FLAG_INEXACT, "Round #21");
+
+ field.setRoundingMode(DfpField.RoundingMode.ROUND_FLOOR);
+
+ // Round floor
+ test(field.newDfp("12345678901234567890").add(field.newDfp("0.9999")),
+ field.newDfp("12345678901234567890"),
+ DfpField.FLAG_INEXACT, "Round #22");
+
+ test(field.newDfp("-12345678901234567890").add(field.newDfp("-0.0001")),
+ field.newDfp("-12345678901234567891"),
+ DfpField.FLAG_INEXACT, "Round #23");
+
+ field.setRoundingMode(DfpField.RoundingMode.ROUND_HALF_EVEN); // reset
+ }
+
+ @Test
+ public void testCeil()
+ {
+ test(field.newDfp("1234.0000000000000001").ceil(),
+ field.newDfp("1235"),
+ DfpField.FLAG_INEXACT, "Ceil #1");
+ }
+
+ @Test
+ public void testFloor()
+ {
+ test(field.newDfp("1234.9999999999999999").floor(),
+ field.newDfp("1234"),
+ DfpField.FLAG_INEXACT, "Floor #1");
+ }
+
+ @Test
+ public void testRint()
+ {
+ test(field.newDfp("1234.50000000001").rint(),
+ field.newDfp("1235"),
+ DfpField.FLAG_INEXACT, "Rint #1");
+
+ test(field.newDfp("1234.5000").rint(),
+ field.newDfp("1234"),
+ DfpField.FLAG_INEXACT, "Rint #2");
+
+ test(field.newDfp("1235.5000").rint(),
+ field.newDfp("1236"),
+ DfpField.FLAG_INEXACT, "Rint #3");
+ }
+
+ @Test
+ public void testCopySign()
+ {
+ test(Dfp.copysign(field.newDfp("1234."), field.newDfp("-1")),
+ field.newDfp("-1234"),
+ 0, "CopySign #1");
+
+ test(Dfp.copysign(field.newDfp("-1234."), field.newDfp("-1")),
+ field.newDfp("-1234"),
+ 0, "CopySign #2");
+
+ test(Dfp.copysign(field.newDfp("-1234."), field.newDfp("1")),
+ field.newDfp("1234"),
+ 0, "CopySign #3");
+
+ test(Dfp.copysign(field.newDfp("1234."), field.newDfp("1")),
+ field.newDfp("1234"),
+ 0, "CopySign #4");
+ }
+
+ @Test
+ public void testIntValue()
+ {
+ Assert.assertEquals("intValue #1", 1234, field.newDfp("1234").intValue());
+ Assert.assertEquals("intValue #2", -1234, field.newDfp("-1234").intValue());
+ Assert.assertEquals("intValue #3", 1234, field.newDfp("1234.5").intValue());
+ Assert.assertEquals("intValue #4", 1235, field.newDfp("1234.500001").intValue());
+ Assert.assertEquals("intValue #5", 2147483647, field.newDfp("1e1000").intValue());
+ Assert.assertEquals("intValue #6", -2147483648, field.newDfp("-1e1000").intValue());
+ }
+
+ @Test
+ public void testLog10K()
+ {
+ Assert.assertEquals("log10K #1", 1, field.newDfp("123456").log10K());
+ Assert.assertEquals("log10K #2", 2, field.newDfp("123456789").log10K());
+ Assert.assertEquals("log10K #3", 0, field.newDfp("2").log10K());
+ Assert.assertEquals("log10K #3", 0, field.newDfp("1").log10K());
+ Assert.assertEquals("log10K #4", -1, field.newDfp("0.1").log10K());
+ }
+
+ @Test
+ public void testPower10K()
+ {
+ Dfp d = field.newDfp();
+
+ test(d.power10K(0), field.newDfp("1"), 0, "Power10 #1");
+ test(d.power10K(1), field.newDfp("10000"), 0, "Power10 #2");
+ test(d.power10K(2), field.newDfp("100000000"), 0, "Power10 #3");
+
+ test(d.power10K(-1), field.newDfp("0.0001"), 0, "Power10 #4");
+ test(d.power10K(-2), field.newDfp("0.00000001"), 0, "Power10 #5");
+ test(d.power10K(-3), field.newDfp("0.000000000001"), 0, "Power10 #6");
+ }
+
+ @Test
+ public void testLog10()
+ {
+
+ Assert.assertEquals("log10 #1", 1, field.newDfp("12").log10());
+ Assert.assertEquals("log10 #2", 2, field.newDfp("123").log10());
+ Assert.assertEquals("log10 #3", 3, field.newDfp("1234").log10());
+ Assert.assertEquals("log10 #4", 4, field.newDfp("12345").log10());
+ Assert.assertEquals("log10 #5", 5, field.newDfp("123456").log10());
+ Assert.assertEquals("log10 #6", 6, field.newDfp("1234567").log10());
+ Assert.assertEquals("log10 #6", 7, field.newDfp("12345678").log10());
+ Assert.assertEquals("log10 #7", 8, field.newDfp("123456789").log10());
+ Assert.assertEquals("log10 #8", 9, field.newDfp("1234567890").log10());
+ Assert.assertEquals("log10 #9", 10, field.newDfp("12345678901").log10());
+ Assert.assertEquals("log10 #10", 11, field.newDfp("123456789012").log10());
+ Assert.assertEquals("log10 #11", 12, field.newDfp("1234567890123").log10());
+
+ Assert.assertEquals("log10 #12", 0, field.newDfp("2").log10());
+ Assert.assertEquals("log10 #13", 0, field.newDfp("1").log10());
+ Assert.assertEquals("log10 #14", -1, field.newDfp("0.12").log10());
+ Assert.assertEquals("log10 #15", -2, field.newDfp("0.012").log10());
+ }
+
+ @Test
+ public void testPower10()
+ {
+ Dfp d = field.newDfp();
+
+ test(d.power10(0), field.newDfp("1"), 0, "Power10 #1");
+ test(d.power10(1), field.newDfp("10"), 0, "Power10 #2");
+ test(d.power10(2), field.newDfp("100"), 0, "Power10 #3");
+ test(d.power10(3), field.newDfp("1000"), 0, "Power10 #4");
+ test(d.power10(4), field.newDfp("10000"), 0, "Power10 #5");
+ test(d.power10(5), field.newDfp("100000"), 0, "Power10 #6");
+ test(d.power10(6), field.newDfp("1000000"), 0, "Power10 #7");
+ test(d.power10(7), field.newDfp("10000000"), 0, "Power10 #8");
+ test(d.power10(8), field.newDfp("100000000"), 0, "Power10 #9");
+ test(d.power10(9), field.newDfp("1000000000"), 0, "Power10 #10");
+
+ test(d.power10(-1), field.newDfp(".1"), 0, "Power10 #11");
+ test(d.power10(-2), field.newDfp(".01"), 0, "Power10 #12");
+ test(d.power10(-3), field.newDfp(".001"), 0, "Power10 #13");
+ test(d.power10(-4), field.newDfp(".0001"), 0, "Power10 #14");
+ test(d.power10(-5), field.newDfp(".00001"), 0, "Power10 #15");
+ test(d.power10(-6), field.newDfp(".000001"), 0, "Power10 #16");
+ test(d.power10(-7), field.newDfp(".0000001"), 0, "Power10 #17");
+ test(d.power10(-8), field.newDfp(".00000001"), 0, "Power10 #18");
+ test(d.power10(-9), field.newDfp(".000000001"), 0, "Power10 #19");
+ test(d.power10(-10), field.newDfp(".0000000001"), 0, "Power10 #20");
+ }
+
+ @Test
+ public void testRemainder()
+ {
+ test(field.newDfp("10").remainder(field.newDfp("3")),
+ field.newDfp("1"),
+ DfpField.FLAG_INEXACT, "Remainder #1");
+
+ test(field.newDfp("9").remainder(field.newDfp("3")),
+ field.newDfp("0"),
+ 0, "Remainder #2");
+
+ test(field.newDfp("-9").remainder(field.newDfp("3")),
+ field.newDfp("-0"),
+ 0, "Remainder #3");
+ }
+
+ @Test
+ public void testSqrt()
+ {
+ test(field.newDfp("0").sqrt(),
+ field.newDfp("0"),
+ 0, "Sqrt #1");
+
+ test(field.newDfp("-0").sqrt(),
+ field.newDfp("-0"),
+ 0, "Sqrt #2");
+
+ test(field.newDfp("1").sqrt(),
+ field.newDfp("1"),
+ 0, "Sqrt #3");
+
+ test(field.newDfp("2").sqrt(),
+ field.newDfp("1.4142135623730950"),
+ DfpField.FLAG_INEXACT, "Sqrt #4");
+
+ test(field.newDfp("3").sqrt(),
+ field.newDfp("1.7320508075688773"),
+ DfpField.FLAG_INEXACT, "Sqrt #5");
+
+ test(field.newDfp("5").sqrt(),
+ field.newDfp("2.2360679774997897"),
+ DfpField.FLAG_INEXACT, "Sqrt #6");
+
+ test(field.newDfp("500").sqrt(),
+ field.newDfp("22.3606797749978970"),
+ DfpField.FLAG_INEXACT, "Sqrt #6.2");
+
+ test(field.newDfp("50000").sqrt(),
+ field.newDfp("223.6067977499789696"),
+ DfpField.FLAG_INEXACT, "Sqrt #6.3");
+
+ test(field.newDfp("-1").sqrt(),
+ nan,
+ DfpField.FLAG_INVALID, "Sqrt #7");
+
+ test(pinf.sqrt(),
+ pinf,
+ 0, "Sqrt #8");
+
+ test(field.newDfp((byte) 1, (byte) Dfp.QNAN).sqrt(),
+ nan,
+ 0, "Sqrt #9");
+
+ test(field.newDfp((byte) 1, (byte) Dfp.SNAN).sqrt(),
+ nan,
+ DfpField.FLAG_INVALID, "Sqrt #9");
+ }
+
+}
Propchange: commons/proper/math/branches/MATH_2_X/src/test/java/org/apache/commons/math/dfp/DfpTest.java
------------------------------------------------------------------------------
svn:eol-style = native
Propchange: commons/proper/math/branches/MATH_2_X/src/test/java/org/apache/commons/math/dfp/DfpTest.java
------------------------------------------------------------------------------
svn:keywords = Author Date Id Revision