/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* 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
* @bug 4851638 4939441
* @summary Tests for {Math, StrictMath}.hypot
* @author Joseph D. Darcy
*/
public class HypotTests {
private HypotTests(){}
/**
* 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];
return result;
}
static int testHypot() {
int failures = 0;
double [][] testCases = {
// Special cases
};
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 <= DoubleConsts.MAX_EXPONENT;
i++) {
}
// 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);
}
}
// Big ones
for(int m = 100000; m < 100100; m++) {
for(int n = m+100000; n < 200200; n++) {
long [] result = pythagoreanTriple(m, n);
}
}
// 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.
*/
for(int i = 0; i < 1000; i++) {
double d = rand.nextDouble();
// Scale d to have an exponent equal to MAX_EXPONENT -15
for(int j = 0; j <= 13; j += 1) {
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++) {
}
failures++;
pcNeighbors[j] + " and " +
pcNeighborsHypot[j] + " and " +
pcNeighborsHypot[j+1] );
}
failures++;
pcNeighbors[j] + " and " +
pcNeighborsStrictHypot[j] + " and " +
pcNeighborsStrictHypot[j+1] );
}
}
}
}
return failures;
}
}
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;
}
}
return failures;
}
int failures = 0;
if (failures > 0) {
+ failures + " failures.");
throw new RuntimeException();
}
}
}