/*
 * 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();
        }
    }
}
