1 /* 2 * Copyright (c) 2003, 2017, Oracle and/or its affiliates. All rights reserved. 3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. 4 * 5 * This code is free software; you can redistribute it and/or modify it 6 * under the terms of the GNU General Public License version 2 only, as 7 * published by the Free Software Foundation. 8 * 9 * This code is distributed in the hope that it will be useful, but WITHOUT 10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 12 * version 2 for more details (a copy is included in the LICENSE file that 13 * accompanied this code). 14 * 15 * You should have received a copy of the GNU General Public License version 16 * 2 along with this work; if not, write to the Free Software Foundation, 17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. 18 * 19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA 20 * or visit www.oracle.com if you need additional information or have any 21 * questions. 22 */ 23 24 /* 25 * @test 26 * @library /test/lib 27 * @build jdk.test.lib.RandomFactory 28 * @run main Log1pTests 29 * @bug 4851638 4939441 8078672 30 * @summary Tests for {Math, StrictMath}.log1p (use -Dseed=X to set PRNG seed) 31 * @author Joseph D. Darcy 32 * @key randomness 33 */ 34 package test.java.lang.Math; 35 36 import java.util.Random; 37 38 import org.testng.annotations.Test; 39 import org.testng.Assert; 40 41 public class Log1pTests { 42 Log1pTests()43 private Log1pTests() { 44 } 45 46 static final double infinityD = Double.POSITIVE_INFINITY; 47 static final double NaNd = Double.NaN; 48 49 /** 50 * Formulation taken from HP-15C Advanced Functions Handbook, part number HP 0015-90011, p 181. 51 * This is accurate to a few ulps. 52 */ hp15cLogp(double x)53 static double hp15cLogp(double x) { 54 double u = 1.0 + x; 55 return (u == 1.0 ? x : StrictMath.log(u) * x / (u - 1)); 56 } 57 58 /* 59 * The Taylor expansion of ln(1 + x) for -1 < x <= 1 is: 60 * 61 * x - x^2/2 + x^3/3 - ... -(-x^j)/j 62 * 63 * Therefore, for small values of x, log1p(x) ~= x. For large 64 * values of x, log1p(x) ~= log(x). 65 * 66 * Also x/(x+1) < ln(1+x) < x 67 */ 68 69 @Test testLog1p()70 public void testLog1p() { 71 double[][] testCases = { 72 {Double.NaN, NaNd}, 73 {Double.longBitsToDouble(0x7FF0000000000001L), NaNd}, 74 {Double.longBitsToDouble(0xFFF0000000000001L), NaNd}, 75 {Double.longBitsToDouble(0x7FF8555555555555L), NaNd}, 76 {Double.longBitsToDouble(0xFFF8555555555555L), NaNd}, 77 {Double.longBitsToDouble(0x7FFFFFFFFFFFFFFFL), NaNd}, 78 {Double.longBitsToDouble(0xFFFFFFFFFFFFFFFFL), NaNd}, 79 {Double.longBitsToDouble(0x7FFDeadBeef00000L), NaNd}, 80 {Double.longBitsToDouble(0xFFFDeadBeef00000L), NaNd}, 81 {Double.longBitsToDouble(0x7FFCafeBabe00000L), NaNd}, 82 {Double.longBitsToDouble(0xFFFCafeBabe00000L), NaNd}, 83 {Double.NEGATIVE_INFINITY, NaNd}, 84 {-8.0, NaNd}, 85 {-1.0, -infinityD}, 86 {-0.0, -0.0}, 87 {+0.0, +0.0}, 88 {infinityD, infinityD}, 89 }; 90 91 // Test special cases 92 for (double[] testCase : testCases) { 93 testLog1pCaseWithUlpDiff(testCase[0], testCase[1], 0); 94 } 95 96 // For |x| < 2^-54 log1p(x) ~= x 97 for (int i = DoubleConsts.MIN_SUB_EXPONENT; i <= -54; i++) { 98 double d = Math.scalb(2, i); 99 testLog1pCase(d, d); 100 testLog1pCase(-d, -d); 101 } 102 103 // For x > 2^53 log1p(x) ~= log(x) 104 for (int i = 53; i <= Double.MAX_EXPONENT; i++) { 105 double d = Math.scalb(2, i); 106 testLog1pCaseWithUlpDiff(d, StrictMath.log(d), 2.001); 107 } 108 109 // Construct random values with exponents ranging from -53 to 110 // 52 and compare against HP-15C formula. 111 java.util.Random rand = new Random(); 112 for (int i = 0; i < 1000; i++) { 113 double d = rand.nextDouble(); 114 115 d = Math.scalb(d, -53 - Tests.ilogb(d)); 116 117 for (int j = -53; j <= 52; j++) { 118 testLog1pCaseWithUlpDiff(d, hp15cLogp(d), 5); 119 120 d *= 2.0; // increase exponent by 1 121 } 122 } 123 124 // Test for monotonicity failures near values y-1 where y ~= 125 // e^x. Test two numbers before and two numbers after each 126 // chosen value; i.e. 127 // 128 // pcNeighbors[] = 129 // {nextDown(nextDown(pc)), 130 // nextDown(pc), 131 // pc, 132 // nextUp(pc), 133 // nextUp(nextUp(pc))} 134 // 135 // and we test that log1p(pcNeighbors[i]) <= log1p(pcNeighbors[i+1]) 136 { 137 double[] pcNeighbors = new double[5]; 138 double[] pcNeighborsLog1p = new double[5]; 139 double[] pcNeighborsStrictLog1p = new double[5]; 140 141 for (int i = -36; i <= 36; i++) { 142 double pc = StrictMath.pow(Math.E, i) - 1; 143 144 pcNeighbors[2] = pc; 145 pcNeighbors[1] = Math.nextDown(pc); 146 pcNeighbors[0] = Math.nextDown(pcNeighbors[1]); 147 pcNeighbors[3] = Math.nextUp(pc); 148 pcNeighbors[4] = Math.nextUp(pcNeighbors[3]); 149 150 for (int j = 0; j < pcNeighbors.length; j++) { 151 pcNeighborsLog1p[j] = Math.log1p(pcNeighbors[j]); 152 pcNeighborsStrictLog1p[j] = StrictMath.log1p(pcNeighbors[j]); 153 } 154 155 for (int j = 0; j < pcNeighborsLog1p.length - 1; j++) { 156 if (pcNeighborsLog1p[j] > pcNeighborsLog1p[j + 1]) { 157 Assert.fail("Monotonicity failure for Math.log1p on " + 158 pcNeighbors[j] + " and " + 159 pcNeighbors[j + 1] + "\n\treturned " + 160 pcNeighborsLog1p[j] + " and " + 161 pcNeighborsLog1p[j + 1]); 162 } 163 164 if (pcNeighborsStrictLog1p[j] > pcNeighborsStrictLog1p[j + 1]) { 165 Assert.fail("Monotonicity failure for StrictMath.log1p on " + 166 pcNeighbors[j] + " and " + 167 pcNeighbors[j + 1] + "\n\treturned " + 168 pcNeighborsStrictLog1p[j] + " and " + 169 pcNeighborsStrictLog1p[j + 1]); 170 } 171 172 173 } 174 175 } 176 } 177 } 178 testLog1pCase(double input, double expected)179 public static void testLog1pCase(double input, double expected) { 180 testLog1pCaseWithUlpDiff(input, expected, 1); 181 } 182 testLog1pCaseWithUlpDiff(double input, double expected, double ulps)183 public static void testLog1pCaseWithUlpDiff(double input, double expected, double ulps) { 184 Tests.testUlpDiff("Math.lop1p(double)", 185 input, Math.log1p(input), 186 expected, ulps); 187 Tests.testUlpDiff("StrictMath.log1p(double)", 188 input, StrictMath.log1p(input), 189 expected, ulps); 190 } 191 } 192