| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package org.apache.commons.math3.dfp; |
| |
| import org.junit.After; |
| import org.junit.Assert; |
| import org.junit.Before; |
| import org.junit.Test; |
| |
| public class DfpMathTest { |
| |
| private DfpField factory; |
| private Dfp pinf; |
| private Dfp ninf; |
| private Dfp nan; |
| private Dfp qnan; |
| |
| @Before |
| public void setUp() { |
| // Some basic setup. Define some constants and clear the status flags |
| factory = new DfpField(20); |
| pinf = factory.newDfp("1").divide(factory.newDfp("0")); |
| ninf = factory.newDfp("-1").divide(factory.newDfp("0")); |
| nan = factory.newDfp("0").divide(factory.newDfp("0")); |
| qnan = factory.newDfp((byte)1, Dfp.QNAN); |
| ninf.getField().clearIEEEFlags(); |
| |
| // force loading of dfpmath |
| Dfp pi = factory.getPi(); |
| pi.getField().clearIEEEFlags(); |
| } |
| |
| @After |
| public void tearDown() { |
| pinf = null; |
| ninf = null; |
| nan = 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(factory.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 testPow() |
| { |
| // Test special cases exponent of zero |
| test(DfpMath.pow(factory.newDfp("0"), factory.newDfp("0")), |
| factory.newDfp("1"), |
| 0, "pow #1"); |
| |
| test(DfpMath.pow(factory.newDfp("0"), factory.newDfp("-0")), |
| factory.newDfp("1"), |
| 0, "pow #2"); |
| |
| test(DfpMath.pow(factory.newDfp("2"), factory.newDfp("0")), |
| factory.newDfp("1"), |
| 0, "pow #3"); |
| |
| test(DfpMath.pow(factory.newDfp("-2"), factory.newDfp("-0")), |
| factory.newDfp("1"), |
| 0, "pow #4"); |
| |
| test(DfpMath.pow(pinf, factory.newDfp("-0")), |
| factory.newDfp("1"), |
| 0, "pow #5"); |
| |
| test(DfpMath.pow(pinf, factory.newDfp("0")), |
| factory.newDfp("1"), |
| 0, "pow #6"); |
| |
| test(DfpMath.pow(ninf, factory.newDfp("-0")), |
| factory.newDfp("1"), |
| 0, "pow #7"); |
| |
| test(DfpMath.pow(ninf, factory.newDfp("0")), |
| factory.newDfp("1"), |
| 0, "pow #8"); |
| |
| test(DfpMath.pow(qnan, factory.newDfp("0")), |
| factory.newDfp("1"), |
| 0, "pow #8"); |
| |
| // exponent of one |
| test(DfpMath.pow(factory.newDfp("0"), factory.newDfp("1")), |
| factory.newDfp("0"), |
| 0, "pow #9"); |
| |
| test(DfpMath.pow(factory.newDfp("-0"), factory.newDfp("1")), |
| factory.newDfp("-0"), |
| 0, "pow #10"); |
| |
| test(DfpMath.pow(factory.newDfp("2"), factory.newDfp("1")), |
| factory.newDfp("2"), |
| 0, "pow #11"); |
| |
| test(DfpMath.pow(factory.newDfp("-2"), factory.newDfp("1")), |
| factory.newDfp("-2"), |
| 0, "pow #12"); |
| |
| test(DfpMath.pow(pinf, factory.newDfp("1")), |
| pinf, |
| 0, "pow #13"); |
| |
| test(DfpMath.pow(ninf, factory.newDfp("1")), |
| ninf, |
| 0, "pow #14"); |
| |
| test(DfpMath.pow(qnan, factory.newDfp("1")), |
| qnan, |
| DfpField.FLAG_INVALID, "pow #14.1"); |
| |
| // exponent of NaN |
| test(DfpMath.pow(factory.newDfp("0"), qnan), |
| qnan, |
| DfpField.FLAG_INVALID, "pow #15"); |
| |
| test(DfpMath.pow(factory.newDfp("-0"), qnan), |
| qnan, |
| DfpField.FLAG_INVALID, "pow #16"); |
| |
| test(DfpMath.pow(factory.newDfp("2"), qnan), |
| qnan, |
| DfpField.FLAG_INVALID, "pow #17"); |
| |
| test(DfpMath.pow(factory.newDfp("-2"), qnan), |
| qnan, |
| DfpField.FLAG_INVALID, "pow #18"); |
| |
| test(DfpMath.pow(pinf, qnan), |
| qnan, |
| DfpField.FLAG_INVALID, "pow #19"); |
| |
| test(DfpMath.pow(ninf, qnan), |
| qnan, |
| DfpField.FLAG_INVALID, "pow #20"); |
| |
| test(DfpMath.pow(qnan, qnan), |
| qnan, |
| DfpField.FLAG_INVALID, "pow #21"); |
| |
| // radix of NaN |
| test(DfpMath.pow(qnan, factory.newDfp("1")), |
| qnan, |
| DfpField.FLAG_INVALID, "pow #22"); |
| |
| test(DfpMath.pow(qnan, factory.newDfp("-1")), |
| qnan, |
| DfpField.FLAG_INVALID, "pow #23"); |
| |
| test(DfpMath.pow(qnan, pinf), |
| qnan, |
| DfpField.FLAG_INVALID, "pow #24"); |
| |
| test(DfpMath.pow(qnan, ninf), |
| qnan, |
| DfpField.FLAG_INVALID, "pow #25"); |
| |
| test(DfpMath.pow(qnan, qnan), |
| qnan, |
| DfpField.FLAG_INVALID, "pow #26"); |
| |
| // (x > 1) ^ pinf = pinf, (x < -1) ^ pinf = pinf |
| test(DfpMath.pow(factory.newDfp("2"), pinf), |
| pinf, |
| 0, "pow #27"); |
| |
| test(DfpMath.pow(factory.newDfp("-2"), pinf), |
| pinf, |
| 0, "pow #28"); |
| |
| test(DfpMath.pow(pinf, pinf), |
| pinf, |
| 0, "pow #29"); |
| |
| test(DfpMath.pow(ninf, pinf), |
| pinf, |
| 0, "pow #30"); |
| |
| // (x > 1) ^ ninf = +0, (x < -1) ^ ninf = +0 |
| test(DfpMath.pow(factory.newDfp("2"), ninf), |
| factory.getZero(), |
| 0, "pow #31"); |
| |
| test(DfpMath.pow(factory.newDfp("-2"), ninf), |
| factory.getZero(), |
| 0, "pow #32"); |
| |
| test(DfpMath.pow(pinf, ninf), |
| factory.getZero(), |
| 0, "pow #33"); |
| |
| test(DfpMath.pow(ninf, ninf), |
| factory.getZero(), |
| 0, "pow #34"); |
| |
| // (-1 < x < 1) ^ pinf = 0 |
| test(DfpMath.pow(factory.newDfp("0.5"), pinf), |
| factory.getZero(), |
| 0, "pow #35"); |
| |
| test(DfpMath.pow(factory.newDfp("-0.5"), pinf), |
| factory.getZero(), |
| 0, "pow #36"); |
| |
| // (-1 < x < 1) ^ ninf = pinf |
| test(DfpMath.pow(factory.newDfp("0.5"), ninf), |
| pinf, |
| 0, "pow #37"); |
| |
| test(DfpMath.pow(factory.newDfp("-0.5"), ninf), |
| pinf, |
| 0, "pow #38"); |
| |
| // +/- 1 ^ +/-inf = NaN |
| test(DfpMath.pow(factory.getOne(), pinf), |
| qnan, |
| DfpField.FLAG_INVALID, "pow #39"); |
| |
| test(DfpMath.pow(factory.getOne(), ninf), |
| qnan, |
| DfpField.FLAG_INVALID, "pow #40"); |
| |
| test(DfpMath.pow(factory.newDfp("-1"), pinf), |
| qnan, |
| DfpField.FLAG_INVALID, "pow #41"); |
| |
| test(DfpMath.pow(factory.getOne().negate(), ninf), |
| qnan, |
| DfpField.FLAG_INVALID, "pow #42"); |
| |
| // +0 ^ +anything except 0, NAN = +0 |
| |
| test(DfpMath.pow(factory.newDfp("0"), factory.newDfp("1")), |
| factory.newDfp("0"), |
| 0, "pow #43"); |
| |
| test(DfpMath.pow(factory.newDfp("0"), factory.newDfp("1e30")), |
| factory.newDfp("0"), |
| 0, "pow #44"); |
| |
| test(DfpMath.pow(factory.newDfp("0"), factory.newDfp("1e-30")), |
| factory.newDfp("0"), |
| 0, "pow #45"); |
| |
| test(DfpMath.pow(factory.newDfp("0"), pinf), |
| factory.newDfp("0"), |
| 0, "pow #46"); |
| |
| // -0 ^ +anything except 0, NAN, odd integer = +0 |
| |
| test(DfpMath.pow(factory.newDfp("-0"), factory.newDfp("2")), |
| factory.newDfp("0"), |
| 0, "pow #47"); |
| |
| test(DfpMath.pow(factory.newDfp("-0"), factory.newDfp("1e30")), |
| factory.newDfp("0"), |
| 0, "pow #48"); |
| |
| test(DfpMath.pow(factory.newDfp("-0"), factory.newDfp("1e-30")), |
| factory.newDfp("0"), |
| DfpField.FLAG_INEXACT, "pow #49"); |
| |
| test(DfpMath.pow(factory.newDfp("-0"), pinf), |
| factory.newDfp("0"), |
| 0, "pow #50"); |
| |
| // +0 ^ -anything except 0, NAN = +INF |
| |
| test(DfpMath.pow(factory.newDfp("0"), factory.newDfp("-1")), |
| pinf, |
| 0, "pow #51"); |
| |
| test(DfpMath.pow(factory.newDfp("0"), factory.newDfp("-1e30")), |
| pinf, |
| 0, "pow #52"); |
| |
| test(DfpMath.pow(factory.newDfp("0"), factory.newDfp("-1e-30")), |
| pinf, |
| 0, "pow #53"); |
| |
| test(DfpMath.pow(factory.newDfp("0"), ninf), |
| pinf, |
| 0, "pow #54"); |
| |
| // -0 ^ -anything except 0, NAN, odd integer = +INF |
| |
| test(DfpMath.pow(factory.newDfp("-0"), factory.newDfp("-2")), |
| pinf, |
| 0, "pow #55"); |
| |
| test(DfpMath.pow(factory.newDfp("-0"), factory.newDfp("-1e30")), |
| pinf, |
| 0, "pow #56"); |
| |
| test(DfpMath.pow(factory.newDfp("-0"), factory.newDfp("-1e-30")), |
| pinf, |
| DfpField.FLAG_INEXACT, "pow #57"); |
| |
| test(DfpMath.pow(factory.newDfp("-0"), ninf), |
| pinf, |
| 0, "pow #58"); |
| |
| // -0 ^ -odd integer = -INF |
| test(DfpMath.pow(factory.newDfp("-0"), factory.newDfp("-1")), |
| ninf, |
| DfpField.FLAG_INEXACT, "pow #59"); |
| |
| test(DfpMath.pow(factory.newDfp("-0"), factory.newDfp("-12345")), |
| ninf, |
| DfpField.FLAG_INEXACT, "pow #60"); |
| |
| // -0 ^ +odd integer = -0 |
| test(DfpMath.pow(factory.newDfp("-0"), factory.newDfp("3")), |
| factory.newDfp("-0"), |
| DfpField.FLAG_INEXACT, "pow #61"); |
| |
| test(DfpMath.pow(factory.newDfp("-0"), factory.newDfp("12345")), |
| factory.newDfp("-0"), |
| DfpField.FLAG_INEXACT, "pow #62"); |
| |
| // pinf ^ +anything = pinf |
| test(DfpMath.pow(pinf, factory.newDfp("3")), |
| pinf, |
| 0, "pow #63"); |
| |
| test(DfpMath.pow(pinf, factory.newDfp("1e30")), |
| pinf, |
| 0, "pow #64"); |
| |
| test(DfpMath.pow(pinf, factory.newDfp("1e-30")), |
| pinf, |
| 0, "pow #65"); |
| |
| test(DfpMath.pow(pinf, pinf), |
| pinf, |
| 0, "pow #66"); |
| |
| // pinf ^ -anything = +0 |
| |
| test(DfpMath.pow(pinf, factory.newDfp("-3")), |
| factory.getZero(), |
| 0, "pow #67"); |
| |
| test(DfpMath.pow(pinf, factory.newDfp("-1e30")), |
| factory.getZero(), |
| 0, "pow #68"); |
| |
| test(DfpMath.pow(pinf, factory.newDfp("-1e-30")), |
| factory.getZero(), |
| 0, "pow #69"); |
| |
| test(DfpMath.pow(pinf, ninf), |
| factory.getZero(), |
| 0, "pow #70"); |
| |
| // ninf ^ anything = -0 ^ -anything |
| // ninf ^ -anything except 0, NAN, odd integer = +0 |
| |
| test(DfpMath.pow(ninf, factory.newDfp("-2")), |
| factory.newDfp("0"), |
| 0, "pow #71"); |
| |
| test(DfpMath.pow(ninf, factory.newDfp("-1e30")), |
| factory.newDfp("0"), |
| 0, "pow #72"); |
| |
| test(DfpMath.pow(ninf, factory.newDfp("-1e-30")), |
| factory.newDfp("0"), |
| DfpField.FLAG_INEXACT, "pow #73"); |
| |
| test(DfpMath.pow(ninf, ninf), |
| factory.newDfp("0"), |
| 0, "pow #74"); |
| |
| // ninf ^ +anything except 0, NAN, odd integer = +INF |
| |
| test(DfpMath.pow(ninf, factory.newDfp("2")), |
| pinf, |
| 0, "pow #75"); |
| |
| test(DfpMath.pow(ninf, factory.newDfp("1e30")), |
| pinf, |
| 0, "pow #76"); |
| |
| test(DfpMath.pow(ninf, factory.newDfp("1e-30")), |
| pinf, |
| DfpField.FLAG_INEXACT, "pow #77"); |
| |
| test(DfpMath.pow(ninf, pinf), |
| pinf, |
| 0, "pow #78"); |
| |
| // ninf ^ +odd integer = -INF |
| test(DfpMath.pow(ninf, factory.newDfp("3")), |
| ninf, |
| DfpField.FLAG_INEXACT, "pow #79"); |
| |
| test(DfpMath.pow(ninf, factory.newDfp("12345")), |
| ninf, |
| DfpField.FLAG_INEXACT, "pow #80"); |
| |
| // ninf ^ -odd integer = -0 |
| test(DfpMath.pow(ninf, factory.newDfp("-3")), |
| factory.newDfp("-0"), |
| DfpField.FLAG_INEXACT, "pow #81"); |
| |
| test(DfpMath.pow(ninf, factory.newDfp("-12345")), |
| factory.newDfp("-0"), |
| DfpField.FLAG_INEXACT, "pow #82"); |
| |
| // -anything ^ integer |
| test(DfpMath.pow(factory.newDfp("-2"), factory.newDfp("3")), |
| factory.newDfp("-8"), |
| DfpField.FLAG_INEXACT, "pow #83"); |
| |
| test(DfpMath.pow(factory.newDfp("-2"), factory.newDfp("16")), |
| factory.newDfp("65536"), |
| 0, "pow #84"); |
| |
| test(DfpMath.pow(factory.newDfp("-2"), factory.newDfp("-3")), |
| factory.newDfp("-0.125"), |
| DfpField.FLAG_INEXACT, "pow #85"); |
| |
| test(DfpMath.pow(factory.newDfp("-2"), factory.newDfp("-4")), |
| factory.newDfp("0.0625"), |
| 0, "pow #86"); |
| |
| // -anything ^ noninteger = NaN |
| |
| test(DfpMath.pow(factory.newDfp("-2"), factory.newDfp("-4.1")), |
| qnan, |
| DfpField.FLAG_INVALID|DfpField.FLAG_INEXACT, "pow #87"); |
| |
| // Some fractional cases. |
| test(DfpMath.pow(factory.newDfp("2"),factory.newDfp("1.5")), |
| factory.newDfp("2.8284271247461901"), |
| DfpField.FLAG_INEXACT, "pow #88"); |
| } |
| |
| @Test |
| public void testSin() |
| { |
| test(DfpMath.sin(pinf), |
| nan, |
| DfpField.FLAG_INVALID|DfpField.FLAG_INEXACT, "sin #1"); |
| |
| test(DfpMath.sin(nan), |
| nan, |
| DfpField.FLAG_INVALID|DfpField.FLAG_INEXACT, "sin #2"); |
| |
| test(DfpMath.sin(factory.getZero()), |
| factory.getZero(), |
| DfpField.FLAG_INEXACT, "sin #3"); |
| |
| test(DfpMath.sin(factory.getPi()), |
| factory.getZero(), |
| DfpField.FLAG_INEXACT, "sin #4"); |
| |
| test(DfpMath.sin(factory.getPi().negate()), |
| factory.newDfp("-0"), |
| DfpField.FLAG_INEXACT, "sin #5"); |
| |
| test(DfpMath.sin(factory.getPi().multiply(2)), |
| factory.getZero(), |
| DfpField.FLAG_INEXACT, "sin #6"); |
| |
| test(DfpMath.sin(factory.getPi().divide(2)), |
| factory.getOne(), |
| DfpField.FLAG_INEXACT, "sin #7"); |
| |
| test(DfpMath.sin(factory.getPi().divide(2).negate()), |
| factory.getOne().negate(), |
| DfpField.FLAG_INEXACT, "sin #8"); |
| |
| test(DfpMath.sin(DfpMath.atan(factory.getOne())), // pi/4 |
| factory.newDfp("0.5").sqrt(), |
| DfpField.FLAG_INEXACT, "sin #9"); |
| |
| test(DfpMath.sin(DfpMath.atan(factory.getOne())).negate(), // -pi/4 |
| factory.newDfp("0.5").sqrt().negate(), |
| DfpField.FLAG_INEXACT, "sin #10"); |
| |
| test(DfpMath.sin(DfpMath.atan(factory.getOne())).negate(), // -pi/4 |
| factory.newDfp("0.5").sqrt().negate(), |
| DfpField.FLAG_INEXACT, "sin #11"); |
| |
| test(DfpMath.sin(factory.newDfp("0.1")), |
| factory.newDfp("0.0998334166468281523"), |
| DfpField.FLAG_INEXACT, "sin #12"); |
| |
| test(DfpMath.sin(factory.newDfp("0.2")), |
| factory.newDfp("0.19866933079506121546"), |
| DfpField.FLAG_INEXACT, "sin #13"); |
| |
| test(DfpMath.sin(factory.newDfp("0.3")), |
| factory.newDfp("0.2955202066613395751"), |
| DfpField.FLAG_INEXACT, "sin #14"); |
| |
| test(DfpMath.sin(factory.newDfp("0.4")), |
| factory.newDfp("0.38941834230865049166"), |
| DfpField.FLAG_INEXACT, "sin #15"); |
| |
| test(DfpMath.sin(factory.newDfp("0.5")), |
| factory.newDfp("0.47942553860420300026"), // off by one ULP |
| DfpField.FLAG_INEXACT, "sin #16"); |
| |
| test(DfpMath.sin(factory.newDfp("0.6")), |
| factory.newDfp("0.56464247339503535721"), // off by one ULP |
| DfpField.FLAG_INEXACT, "sin #17"); |
| |
| test(DfpMath.sin(factory.newDfp("0.7")), |
| factory.newDfp("0.64421768723769105367"), |
| DfpField.FLAG_INEXACT, "sin #18"); |
| |
| test(DfpMath.sin(factory.newDfp("0.8")), |
| factory.newDfp("0.71735609089952276163"), |
| DfpField.FLAG_INEXACT, "sin #19"); |
| |
| test(DfpMath.sin(factory.newDfp("0.9")), // off by one ULP |
| factory.newDfp("0.78332690962748338847"), |
| DfpField.FLAG_INEXACT, "sin #20"); |
| |
| test(DfpMath.sin(factory.newDfp("1.0")), |
| factory.newDfp("0.84147098480789650666"), |
| DfpField.FLAG_INEXACT, "sin #21"); |
| |
| test(DfpMath.sin(factory.newDfp("1.1")), |
| factory.newDfp("0.89120736006143533995"), |
| DfpField.FLAG_INEXACT, "sin #22"); |
| |
| test(DfpMath.sin(factory.newDfp("1.2")), |
| factory.newDfp("0.93203908596722634968"), |
| DfpField.FLAG_INEXACT, "sin #23"); |
| |
| test(DfpMath.sin(factory.newDfp("1.3")), |
| factory.newDfp("0.9635581854171929647"), |
| DfpField.FLAG_INEXACT, "sin #24"); |
| |
| test(DfpMath.sin(factory.newDfp("1.4")), |
| factory.newDfp("0.98544972998846018066"), |
| DfpField.FLAG_INEXACT, "sin #25"); |
| |
| test(DfpMath.sin(factory.newDfp("1.5")), |
| factory.newDfp("0.99749498660405443096"), |
| DfpField.FLAG_INEXACT, "sin #26"); |
| |
| test(DfpMath.sin(factory.newDfp("1.6")), |
| factory.newDfp("0.99957360304150516323"), |
| DfpField.FLAG_INEXACT, "sin #27"); |
| } |
| |
| |
| } |
