## test/java/lang/Math/HypotTests.java

 ``` `````` 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 * @bug 4851638 4939441 27 * @summary Tests for {Math, StrictMath}.hypot 28 * @author Joseph D. Darcy 29 */ 30 31 import sun.misc.DoubleConsts; 32 33 public class HypotTests { 34 private HypotTests(){} 35 36 static final double infinityD = Double.POSITIVE_INFINITY; 37 static final double NaNd = Double.NaN; 38 39 /** 40 * Given integers m and n, assuming m < n, the triple (n^2 - m^2, 41 * 2mn, and n^2 + m^2) is a Pythagorean triple with a^2 + b^2 = 42 * c^2. This methods returns a long array holding the Pythagorean 43 * triple corresponding to the inputs. 44 */ 45 static long [] pythagoreanTriple(int m, int n) { 46 long M = m; 47 long N = n; 48 long result[] = new long; 49 50 51 result = Math.abs(M*M - N*N); `````` 69 {1.0, NaNd, NaNd}, 70 {Double.longBitsToDouble(0x7FF0000000000001L), 1.0, NaNd}, 71 {Double.longBitsToDouble(0xFFF0000000000001L), 1.0, NaNd}, 72 {Double.longBitsToDouble(0x7FF8555555555555L), 1.0, NaNd}, 73 {Double.longBitsToDouble(0xFFF8555555555555L), 1.0, NaNd}, 74 {Double.longBitsToDouble(0x7FFFFFFFFFFFFFFFL), 1.0, NaNd}, 75 {Double.longBitsToDouble(0xFFFFFFFFFFFFFFFFL), 1.0, NaNd}, 76 {Double.longBitsToDouble(0x7FFDeadBeef00000L), 1.0, NaNd}, 77 {Double.longBitsToDouble(0xFFFDeadBeef00000L), 1.0, NaNd}, 78 {Double.longBitsToDouble(0x7FFCafeBabe00000L), 1.0, NaNd}, 79 {Double.longBitsToDouble(0xFFFCafeBabe00000L), 1.0, NaNd}, 80 }; 81 82 for(int i = 0; i < testCases.length; i++) { 83 failures += testHypotCase(testCases[i], testCases[i], 84 testCases[i]); 85 } 86 87 // Verify hypot(x, 0.0) is close to x over the entire exponent 88 // range. 89 for(int i = DoubleConsts.MIN_SUB_EXPONENT; 90 i <= DoubleConsts.MAX_EXPONENT; 91 i++) { 92 double input = Math.scalb(2, i); 93 failures += testHypotCase(input, 0.0, input); 94 } 95 96 97 // Test Pythagorean triples 98 99 // Small ones 100 for(int m = 1; m < 10; m++) { 101 for(int n = m+1; n < 11; n++) { 102 long [] result = pythagoreanTriple(m, n); 103 failures += testHypotCase(result, result, result); 104 } 105 } 106 107 // Big ones 108 for(int m = 100000; m < 100100; m++) { 109 for(int n = m+100000; n < 200200; n++) { 110 long [] result = pythagoreanTriple(m, n); 111 failures += testHypotCase(result, result, result); 112 } 113 } 114 115 // Approaching overflow tests 116 117 /* 118 * Create a random value r with an large-ish exponent. The 119 * result of hypot(3*r, 4*r) should be approximately 5*r. (The 120 * computation of 4*r is exact since it just changes the 121 * exponent). While the exponent of r is less than or equal 122 * to (MAX_EXPONENT - 3), the computation should not overflow. 123 */ 124 java.util.Random rand = new java.util.Random(); 125 for(int i = 0; i < 1000; i++) { 126 double d = rand.nextDouble(); 127 // Scale d to have an exponent equal to MAX_EXPONENT -15 128 d = Math.scalb(d, DoubleConsts.MAX_EXPONENT 129 -15 - Tests.ilogb(d)); 130 for(int j = 0; j <= 13; j += 1) { 131 failures += testHypotCase(3*d, 4*d, 5*d, 2.5); 132 d *= 2.0; // increase exponent by 1 133 } 134 } 135 136 // Test for monotonicity failures. Fix one argument and test 137 // two numbers before and two numbers after each chosen value; 138 // i.e. 139 // 140 // pcNeighbors[] = 141 // {nextDown(nextDown(pc)), 142 // nextDown(pc), 143 // pc, 144 // nextUp(pc), 145 // nextUp(nextUp(pc))} 146 // 147 // and we test that hypot(pcNeighbors[i]) <= hypot(pcNeighbors[i+1]) 148 { ``` ``` `````` 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 * @bug 4851638 4939441 27 * @summary Tests for {Math, StrictMath}.hypot 28 * @library /lib/testlibrary 29 * @build jdk.testlibrary.DoubleUtils jdk.testlibrary.FloatUtils 30 * @run main HypotTests 31 * @author Joseph D. Darcy 32 */ 33 34 import static jdk.testlibrary.DoubleUtils.*; 35 36 public class HypotTests { 37 private HypotTests(){} 38 39 static final double infinityD = Double.POSITIVE_INFINITY; 40 static final double NaNd = Double.NaN; 41 42 /** 43 * Given integers m and n, assuming m < n, the triple (n^2 - m^2, 44 * 2mn, and n^2 + m^2) is a Pythagorean triple with a^2 + b^2 = 45 * c^2. This methods returns a long array holding the Pythagorean 46 * triple corresponding to the inputs. 47 */ 48 static long [] pythagoreanTriple(int m, int n) { 49 long M = m; 50 long N = n; 51 long result[] = new long; 52 53 54 result = Math.abs(M*M - N*N); `````` 72 {1.0, NaNd, NaNd}, 73 {Double.longBitsToDouble(0x7FF0000000000001L), 1.0, NaNd}, 74 {Double.longBitsToDouble(0xFFF0000000000001L), 1.0, NaNd}, 75 {Double.longBitsToDouble(0x7FF8555555555555L), 1.0, NaNd}, 76 {Double.longBitsToDouble(0xFFF8555555555555L), 1.0, NaNd}, 77 {Double.longBitsToDouble(0x7FFFFFFFFFFFFFFFL), 1.0, NaNd}, 78 {Double.longBitsToDouble(0xFFFFFFFFFFFFFFFFL), 1.0, NaNd}, 79 {Double.longBitsToDouble(0x7FFDeadBeef00000L), 1.0, NaNd}, 80 {Double.longBitsToDouble(0xFFFDeadBeef00000L), 1.0, NaNd}, 81 {Double.longBitsToDouble(0x7FFCafeBabe00000L), 1.0, NaNd}, 82 {Double.longBitsToDouble(0xFFFCafeBabe00000L), 1.0, NaNd}, 83 }; 84 85 for(int i = 0; i < testCases.length; i++) { 86 failures += testHypotCase(testCases[i], testCases[i], 87 testCases[i]); 88 } 89 90 // Verify hypot(x, 0.0) is close to x over the entire exponent 91 // range. 92 for(int i = MIN_SUB_EXPONENT; 93 i <= Double.MAX_EXPONENT; 94 i++) { 95 double input = Math.scalb(2, i); 96 failures += testHypotCase(input, 0.0, input); 97 } 98 99 100 // Test Pythagorean triples 101 102 // Small ones 103 for(int m = 1; m < 10; m++) { 104 for(int n = m+1; n < 11; n++) { 105 long [] result = pythagoreanTriple(m, n); 106 failures += testHypotCase(result, result, result); 107 } 108 } 109 110 // Big ones 111 for(int m = 100000; m < 100100; m++) { 112 for(int n = m+100000; n < 200200; n++) { 113 long [] result = pythagoreanTriple(m, n); 114 failures += testHypotCase(result, result, result); 115 } 116 } 117 118 // Approaching overflow tests 119 120 /* 121 * Create a random value r with an large-ish exponent. The 122 * result of hypot(3*r, 4*r) should be approximately 5*r. (The 123 * computation of 4*r is exact since it just changes the 124 * exponent). While the exponent of r is less than or equal 125 * to (MAX_EXPONENT - 3), the computation should not overflow. 126 */ 127 java.util.Random rand = new java.util.Random(); 128 for(int i = 0; i < 1000; i++) { 129 double d = rand.nextDouble(); 130 // Scale d to have an exponent equal to MAX_EXPONENT -15 131 d = Math.scalb(d, Double.MAX_EXPONENT 132 -15 - Tests.ilogb(d)); 133 for(int j = 0; j <= 13; j += 1) { 134 failures += testHypotCase(3*d, 4*d, 5*d, 2.5); 135 d *= 2.0; // increase exponent by 1 136 } 137 } 138 139 // Test for monotonicity failures. Fix one argument and test 140 // two numbers before and two numbers after each chosen value; 141 // i.e. 142 // 143 // pcNeighbors[] = 144 // {nextDown(nextDown(pc)), 145 // nextDown(pc), 146 // pc, 147 // nextUp(pc), 148 // nextUp(nextUp(pc))} 149 // 150 // and we test that hypot(pcNeighbors[i]) <= hypot(pcNeighbors[i+1]) 151 { ```