/*
* 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.math4.dfp;
import org.apache.commons.math4.ExtendedFieldElementAbstractTest;
import org.apache.commons.math4.dfp.Dfp;
import org.apache.commons.math4.dfp.DfpField;
import org.apache.commons.math4.util.FastMath;
import org.apache.commons.numbers.core.Precision;
import org.junit.After;
import org.junit.Assert;
import org.junit.Before;
import org.junit.Test;
public class DfpTest extends ExtendedFieldElementAbstractTest<Dfp> {
@Override
protected Dfp build(final double x) {
return field.newDfp(x);
}
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),
field.newDfp("10000"),
0, "Multiply #37");
test(field.newDfp("2").multiply(1000000),
field.newDfp("2000000"),
0, "Multiply #38");
test(field.newDfp("1").multiply(-1),
field.newDfp("-1"),
0, "Multiply #39");
}
@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 testReciprocal()
{
test(nan.reciprocal(),
nan,
0, "Reciprocal #1");
test(field.newDfp("0").reciprocal(),
pinf,
DfpField.FLAG_DIV_ZERO, "Reciprocal #2");
test(field.newDfp("-0").reciprocal(),
ninf,
DfpField.FLAG_DIV_ZERO, "Reciprocal #3");
test(field.newDfp("3").reciprocal(),
field.newDfp("0.33333333333333333333"),
DfpField.FLAG_INEXACT, "Reciprocal #4");
test(field.newDfp("6").reciprocal(),
field.newDfp("0.16666666666666666667"),
DfpField.FLAG_INEXACT, "Reciprocal #5");
test(field.newDfp("1").reciprocal(),
field.newDfp("1"),
0, "Reciprocal #6");
test(field.newDfp("-1").reciprocal(),
field.newDfp("-1"),
0, "Reciprocal #7");
test(pinf.reciprocal(),
field.newDfp("0"),
0, "Reciprocal #8");
test(ninf.reciprocal(),
field.newDfp("-0"),
0, "Reciprocal #9");
}
@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, Dfp.QNAN).toString());
Assert.assertEquals("toString #5", "NaN", field.newDfp((byte) 1, 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());
}
@Override
@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
}
@Override
@Test
public void testCeil()
{
test(field.newDfp("1234.0000000000000001").ceil(),
field.newDfp("1235"),
DfpField.FLAG_INEXACT, "Ceil #1");
}
@Override
@Test
public void testFloor()
{
test(field.newDfp("1234.9999999999999999").floor(),
field.newDfp("1234"),
DfpField.FLAG_INEXACT, "Floor #1");
}
@Override
@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").intLog10());
Assert.assertEquals("log10 #2", 2, field.newDfp("123").intLog10());
Assert.assertEquals("log10 #3", 3, field.newDfp("1234").intLog10());
Assert.assertEquals("log10 #4", 4, field.newDfp("12345").intLog10());
Assert.assertEquals("log10 #5", 5, field.newDfp("123456").intLog10());
Assert.assertEquals("log10 #6", 6, field.newDfp("1234567").intLog10());
Assert.assertEquals("log10 #6", 7, field.newDfp("12345678").intLog10());
Assert.assertEquals("log10 #7", 8, field.newDfp("123456789").intLog10());
Assert.assertEquals("log10 #8", 9, field.newDfp("1234567890").intLog10());
Assert.assertEquals("log10 #9", 10, field.newDfp("12345678901").intLog10());
Assert.assertEquals("log10 #10", 11, field.newDfp("123456789012").intLog10());
Assert.assertEquals("log10 #11", 12, field.newDfp("1234567890123").intLog10());
Assert.assertEquals("log10 #12", 0, field.newDfp("2").intLog10());
Assert.assertEquals("log10 #13", 0, field.newDfp("1").intLog10());
Assert.assertEquals("log10 #14", -1, field.newDfp("0.12").intLog10());
Assert.assertEquals("log10 #15", -2, field.newDfp("0.012").intLog10());
}
@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");
}
@Override
@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, Dfp.QNAN).sqrt(),
nan,
0, "Sqrt #9");
test(field.newDfp((byte) 1, Dfp.SNAN).sqrt(),
nan,
DfpField.FLAG_INVALID, "Sqrt #9");
}
@Test
public void testIssue567() {
DfpField field = new DfpField(100);
Assert.assertEquals(0.0, field.getZero().toDouble(), Precision.SAFE_MIN);
Assert.assertEquals(0.0, field.newDfp(0.0).toDouble(), Precision.SAFE_MIN);
Assert.assertEquals(-1, FastMath.copySign(1, field.newDfp(-0.0).toDouble()), Precision.EPSILON);
Assert.assertEquals(+1, FastMath.copySign(1, field.newDfp(+0.0).toDouble()), Precision.EPSILON);
}
@Test
public void testIsZero() {
Assert.assertTrue(field.getZero().isZero());
Assert.assertTrue(field.getZero().negate().isZero());
Assert.assertTrue(field.newDfp(+0.0).isZero());
Assert.assertTrue(field.newDfp(-0.0).isZero());
Assert.assertFalse(field.newDfp(1.0e-90).isZero());
Assert.assertFalse(nan.isZero());
Assert.assertFalse(nan.negate().isZero());
Assert.assertFalse(pinf.isZero());
Assert.assertFalse(pinf.negate().isZero());
Assert.assertFalse(ninf.isZero());
Assert.assertFalse(ninf.negate().isZero());
}
@Test
public void testSignPredicates() {
Assert.assertTrue(field.getZero().negativeOrNull());
Assert.assertTrue(field.getZero().positiveOrNull());
Assert.assertFalse(field.getZero().strictlyNegative());
Assert.assertFalse(field.getZero().strictlyPositive());
Assert.assertTrue(field.getZero().negate().negativeOrNull());
Assert.assertTrue(field.getZero().negate().positiveOrNull());
Assert.assertFalse(field.getZero().negate().strictlyNegative());
Assert.assertFalse(field.getZero().negate().strictlyPositive());
Assert.assertFalse(field.getOne().negativeOrNull());
Assert.assertTrue(field.getOne().positiveOrNull());
Assert.assertFalse(field.getOne().strictlyNegative());
Assert.assertTrue(field.getOne().strictlyPositive());
Assert.assertTrue(field.getOne().negate().negativeOrNull());
Assert.assertFalse(field.getOne().negate().positiveOrNull());
Assert.assertTrue(field.getOne().negate().strictlyNegative());
Assert.assertFalse(field.getOne().negate().strictlyPositive());
Assert.assertFalse(nan.negativeOrNull());
Assert.assertFalse(nan.positiveOrNull());
Assert.assertFalse(nan.strictlyNegative());
Assert.assertFalse(nan.strictlyPositive());
Assert.assertFalse(nan.negate().negativeOrNull());
Assert.assertFalse(nan.negate().positiveOrNull());
Assert.assertFalse(nan.negate().strictlyNegative());
Assert.assertFalse(nan.negate().strictlyPositive());
Assert.assertFalse(pinf.negativeOrNull());
Assert.assertTrue(pinf.positiveOrNull());
Assert.assertFalse(pinf.strictlyNegative());
Assert.assertTrue(pinf.strictlyPositive());
Assert.assertTrue(pinf.negate().negativeOrNull());
Assert.assertFalse(pinf.negate().positiveOrNull());
Assert.assertTrue(pinf.negate().strictlyNegative());
Assert.assertFalse(pinf.negate().strictlyPositive());
Assert.assertTrue(ninf.negativeOrNull());
Assert.assertFalse(ninf.positiveOrNull());
Assert.assertTrue(ninf.strictlyNegative());
Assert.assertFalse(ninf.strictlyPositive());
Assert.assertFalse(ninf.negate().negativeOrNull());
Assert.assertTrue(ninf.negate().positiveOrNull());
Assert.assertFalse(ninf.negate().strictlyNegative());
Assert.assertTrue(ninf.negate().strictlyPositive());
}
@Test
public void testSpecialConstructors() {
Assert.assertEquals(ninf, field.newDfp(Double.NEGATIVE_INFINITY));
Assert.assertEquals(ninf, field.newDfp("-Infinity"));
Assert.assertEquals(pinf, field.newDfp(Double.POSITIVE_INFINITY));
Assert.assertEquals(pinf, field.newDfp("Infinity"));
Assert.assertTrue(field.newDfp(Double.NaN).isNaN());
Assert.assertTrue(field.newDfp("NaN").isNaN());
}
@Test
public void testEqualsHashcodeContract() {
DfpField var1 = new DfpField(1);
Dfp var6 = var1.newDfp(-0.0d);
Dfp var5 = var1.newDfp(0L);
// Checks the contract: equals-hashcode on var5 and var6
Assert.assertTrue(var5.equals(var6) ? var5.hashCode() == var6.hashCode() : true);
}
}