248 lines
9.4 KiB
Java
248 lines
9.4 KiB
Java
/*
|
|
* Copyright (c) 2003, 2022, Oracle and/or its affiliates. All rights reserved.
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* This code is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License version 2 only, as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
|
* accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU General Public License version
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.com if you need additional information or have any
|
|
* questions.
|
|
*/
|
|
|
|
/*
|
|
* @test
|
|
* @library /test/lib
|
|
* @build jdk.test.lib.RandomFactory
|
|
* @run main HypotTests
|
|
* @bug 4851638 4939441 8078672 8240632
|
|
* @summary Tests for {Math, StrictMath}.hypot (use -Dseed=X to set PRNG seed)
|
|
* @key randomness
|
|
*/
|
|
|
|
import jdk.test.lib.RandomFactory;
|
|
|
|
public class HypotTests {
|
|
private HypotTests(){}
|
|
|
|
static final double infinityD = Double.POSITIVE_INFINITY;
|
|
static final double NaNd = Double.NaN;
|
|
|
|
/**
|
|
* Given integers m and n, assuming m < n, the triple (n^2 - m^2,
|
|
* 2mn, and n^2 + m^2) is a Pythagorean triple with a^2 + b^2 =
|
|
* c^2. This methods returns a long array holding the Pythagorean
|
|
* triple corresponding to the inputs.
|
|
*/
|
|
static long [] pythagoreanTriple(int m, int n) {
|
|
long M = m;
|
|
long N = n;
|
|
long result[] = new long[3];
|
|
|
|
result[0] = Math.abs(M*M - N*N);
|
|
result[1] = Math.abs(2*M*N);
|
|
result[2] = Math.abs(M*M + N*N);
|
|
|
|
return result;
|
|
}
|
|
|
|
static int testHypot() {
|
|
int failures = 0;
|
|
|
|
double [][] testCases = {
|
|
// Special cases
|
|
{infinityD, infinityD, infinityD},
|
|
{infinityD, 0.0, infinityD},
|
|
{infinityD, 1.0, infinityD},
|
|
{infinityD, NaNd, infinityD},
|
|
{NaNd, NaNd, NaNd},
|
|
{0.0, NaNd, NaNd},
|
|
{1.0, NaNd, NaNd},
|
|
{Double.longBitsToDouble(0x7FF0000000000001L), 1.0, NaNd},
|
|
{Double.longBitsToDouble(0xFFF0000000000001L), 1.0, NaNd},
|
|
{Double.longBitsToDouble(0x7FF8555555555555L), 1.0, NaNd},
|
|
{Double.longBitsToDouble(0xFFF8555555555555L), 1.0, NaNd},
|
|
{Double.longBitsToDouble(0x7FFFFFFFFFFFFFFFL), 1.0, NaNd},
|
|
{Double.longBitsToDouble(0xFFFFFFFFFFFFFFFFL), 1.0, NaNd},
|
|
{Double.longBitsToDouble(0x7FFDeadBeef00000L), 1.0, NaNd},
|
|
{Double.longBitsToDouble(0xFFFDeadBeef00000L), 1.0, NaNd},
|
|
{Double.longBitsToDouble(0x7FFCafeBabe00000L), 1.0, NaNd},
|
|
{Double.longBitsToDouble(0xFFFCafeBabe00000L), 1.0, NaNd},
|
|
};
|
|
|
|
for(int i = 0; i < testCases.length; i++) {
|
|
failures += testHypotCase(testCases[i][0], testCases[i][1],
|
|
testCases[i][2]);
|
|
}
|
|
|
|
// Verify hypot(x, 0.0) is close to x over the entire exponent
|
|
// range.
|
|
for(int i = DoubleConsts.MIN_SUB_EXPONENT;
|
|
i <= Double.MAX_EXPONENT;
|
|
i++) {
|
|
double input = Math.scalb(2, i);
|
|
failures += testHypotCase(input, 0.0, input);
|
|
}
|
|
|
|
|
|
// Test Pythagorean triples
|
|
|
|
// Small ones
|
|
for(int m = 1; m < 10; m++) {
|
|
for(int n = m+1; n < 11; n++) {
|
|
long [] result = pythagoreanTriple(m, n);
|
|
failures += testHypotCase(result[0], result[1], result[2]);
|
|
}
|
|
}
|
|
|
|
// Big ones
|
|
for(int m = 100000; m < 100100; m++) {
|
|
for(int n = m+100000; n < 200200; n++) {
|
|
long [] result = pythagoreanTriple(m, n);
|
|
failures += testHypotCase(result[0], result[1], result[2]);
|
|
}
|
|
}
|
|
|
|
// Approaching overflow tests
|
|
|
|
/*
|
|
* Create a random value r with an large-ish exponent. The
|
|
* result of hypot(3*r, 4*r) should be approximately 5*r. (The
|
|
* computation of 4*r is exact since it just changes the
|
|
* exponent). While the exponent of r is less than or equal
|
|
* to (MAX_EXPONENT - 3), the computation should not overflow.
|
|
*/
|
|
java.util.Random rand = RandomFactory.getRandom();
|
|
for(int i = 0; i < 1000; i++) {
|
|
double d = rand.nextDouble();
|
|
// Scale d to have an exponent equal to MAX_EXPONENT -15
|
|
d = Math.scalb(d, Double.MAX_EXPONENT
|
|
-15 - Tests.ilogb(d));
|
|
for(int j = 0; j <= 13; j += 1) {
|
|
failures += testHypotCase(3*d, 4*d, 5*d, 2.5);
|
|
d *= 2.0; // increase exponent by 1
|
|
}
|
|
}
|
|
|
|
// Test for monotonicity failures. Fix one argument and test
|
|
// two numbers before and two numbers after each chosen value;
|
|
// i.e.
|
|
//
|
|
// pcNeighbors[] =
|
|
// {nextDown(nextDown(pc)),
|
|
// nextDown(pc),
|
|
// pc,
|
|
// nextUp(pc),
|
|
// nextUp(nextUp(pc))}
|
|
//
|
|
// and we test that hypot(pcNeighbors[i]) <= hypot(pcNeighbors[i+1])
|
|
{
|
|
double pcNeighbors[] = new double[5];
|
|
double pcNeighborsHypot[] = new double[5];
|
|
double pcNeighborsStrictHypot[] = new double[5];
|
|
|
|
|
|
for(int i = -18; i <= 18; i++) {
|
|
double pc = Math.scalb(1.0, i);
|
|
|
|
pcNeighbors[2] = pc;
|
|
pcNeighbors[1] = Math.nextDown(pc);
|
|
pcNeighbors[0] = Math.nextDown(pcNeighbors[1]);
|
|
pcNeighbors[3] = Math.nextUp(pc);
|
|
pcNeighbors[4] = Math.nextUp(pcNeighbors[3]);
|
|
|
|
for(int j = 0; j < pcNeighbors.length; j++) {
|
|
pcNeighborsHypot[j] = Math.hypot(2.0, pcNeighbors[j]);
|
|
pcNeighborsStrictHypot[j] = StrictMath.hypot(2.0, pcNeighbors[j]);
|
|
}
|
|
|
|
for(int j = 0; j < pcNeighborsHypot.length-1; j++) {
|
|
if(pcNeighborsHypot[j] > pcNeighborsHypot[j+1] ) {
|
|
failures++;
|
|
System.err.println("Monotonicity failure for Math.hypot on " +
|
|
pcNeighbors[j] + " and " +
|
|
pcNeighbors[j+1] + "\n\treturned " +
|
|
pcNeighborsHypot[j] + " and " +
|
|
pcNeighborsHypot[j+1] );
|
|
}
|
|
|
|
if(pcNeighborsStrictHypot[j] > pcNeighborsStrictHypot[j+1] ) {
|
|
failures++;
|
|
System.err.println("Monotonicity failure for StrictMath.hypot on " +
|
|
pcNeighbors[j] + " and " +
|
|
pcNeighbors[j+1] + "\n\treturned " +
|
|
pcNeighborsStrictHypot[j] + " and " +
|
|
pcNeighborsStrictHypot[j+1] );
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
return failures;
|
|
}
|
|
|
|
/**
|
|
* Verify +0.0 is returned if both arguments are zero.
|
|
*/
|
|
private static int testHypotZeros() {
|
|
return testHypotCase(0.0, 0.0, +0.0, 0.0);
|
|
}
|
|
|
|
static int testHypotCase(double input1, double input2, double expected) {
|
|
return testHypotCase(input1,input2, expected, 1);
|
|
}
|
|
|
|
static int testHypotCase(double input1, double input2, double expected,
|
|
double ulps) {
|
|
int failures = 0;
|
|
if (expected < 0.0) {
|
|
throw new AssertionError("Result of hypot must be greater than " +
|
|
"or equal to zero");
|
|
}
|
|
|
|
// Test Math and StrictMath methods with no inputs negated,
|
|
// each input negated singly, and both inputs negated. Also
|
|
// test inputs in reversed order.
|
|
|
|
for(int i = -1; i <= 1; i += 2) {
|
|
for(int j = -1; j <= 1; j += 2) {
|
|
double x = i * input1;
|
|
double y = j * input2;
|
|
failures += Tests.testUlpDiff("Math.hypot", x, y, Math::hypot, expected, ulps);
|
|
failures += Tests.testUlpDiff("Math.hypot", y, x, Math::hypot, expected, ulps);
|
|
|
|
failures += Tests.testUlpDiff("StrictMath.hypot", x, y, StrictMath::hypot, expected, ulps);
|
|
failures += Tests.testUlpDiff("StrictMath.hypot", y, x, StrictMath::hypot, expected, ulps);
|
|
}
|
|
}
|
|
|
|
return failures;
|
|
}
|
|
|
|
public static void main(String... argv) {
|
|
int failures = 0;
|
|
|
|
failures += testHypot();
|
|
failures += testHypotZeros();
|
|
|
|
if (failures > 0) {
|
|
System.err.println("Testing the hypot incurred "
|
|
+ failures + " failures.");
|
|
throw new RuntimeException();
|
|
}
|
|
}
|
|
}
|