/*
 * Copyright (C) 2018 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import libcore.util.FP16;

public class Main {

    public static short FP16_ALT_NAN = (short)(FP16.NaN | 0x0098);

    public Main() {
    }

    public static int TestFP16ToFloatRawIntBits(short half) {
        float f = FP16.toFloat(half);
        // Since in this test class we need to check the integer representing of
        // the actual float NaN values, the floatToRawIntBits() is used instead of
        // floatToIntBits().
        return Float.floatToRawIntBits(f);
    }

    public static void assertEquals(short expected, short calculated) {
        if (expected != calculated) {
            throw new Error("Expected: " + expected + ", Calculated: " + calculated);
        }
    }
    public static void assertEquals(float expected, float calculated) {
        if (expected != calculated) {
            throw new Error("Expected: " + expected + ", Calculated: " + calculated);
        }
    }
    public static void assertEquals(int expected, int calculated) {
        if (expected != calculated) {
            throw new Error("Expected: " + expected + ", Calculated: " + calculated);
        }
    }
    static public void assertTrue(boolean condition) {
        if (!condition) {
            throw new Error("condition not true");
        }
    }

    static public void assertFalse(boolean condition) {
        if (condition) {
            throw new Error("condition not false");
        }
    }

    public static void testHalfToFloatToHalfConversions(){
        // Test FP16 to float and back to Half for all possible Short values
        for (short h = Short.MIN_VALUE; h < Short.MAX_VALUE; h++) {
            if (FP16.isNaN(h)) {
                // NaN inputs are tested below.
                continue;
            }
            assertEquals(h, FP16.toHalf(FP16.toFloat(h)));
        }
    }

    public static void testToHalf(){
        // These asserts check some known values and edge cases for FP16.toHalf
        // and have been inspired by the cts HalfTest.
        // Zeroes, NaN and infinities
        assertEquals(FP16.POSITIVE_ZERO, FP16.toHalf(0.0f));
        assertEquals(FP16.NEGATIVE_ZERO, FP16.toHalf(-0.0f));
        assertEquals(FP16.NaN, FP16.toHalf(Float.NaN));
        assertEquals(FP16.POSITIVE_INFINITY, FP16.toHalf(Float.POSITIVE_INFINITY));
        assertEquals(FP16.NEGATIVE_INFINITY, FP16.toHalf(Float.NEGATIVE_INFINITY));
        // Known values
        assertEquals((short) 0x3c01, FP16.toHalf(1.0009765625f));
        assertEquals((short) 0xc000, FP16.toHalf(-2.0f));
        assertEquals((short) 0x0400, FP16.toHalf(6.10352e-5f));
        assertEquals((short) 0x7bff, FP16.toHalf(65504.0f));
        assertEquals((short) 0x3555, FP16.toHalf(1.0f / 3.0f));
        // Subnormals
        assertEquals((short) 0x03ff, FP16.toHalf(6.09756e-5f));
        assertEquals(FP16.MIN_VALUE, FP16.toHalf(5.96046e-8f));
        assertEquals((short) 0x83ff, FP16.toHalf(-6.09756e-5f));
        assertEquals((short) 0x8001, FP16.toHalf(-5.96046e-8f));
        // Subnormals (flushed to +/-0)
        assertEquals(FP16.POSITIVE_ZERO, FP16.toHalf(5.96046e-9f));
        assertEquals(FP16.NEGATIVE_ZERO, FP16.toHalf(-5.96046e-9f));
        // Test for values that overflow the mantissa bits into exp bits
        assertEquals(0x1000, FP16.toHalf(Float.intBitsToFloat(0x39fff000)));
        assertEquals(0x0400, FP16.toHalf(Float.intBitsToFloat(0x387fe000)));
        // Floats with absolute value above +/-65519 are rounded to +/-inf
        // when using round-to-even
        assertEquals(0x7bff, FP16.toHalf(65519.0f));
        assertEquals(0x7bff, FP16.toHalf(65519.9f));
        assertEquals(FP16.POSITIVE_INFINITY, FP16.toHalf(65520.0f));
        assertEquals(FP16.NEGATIVE_INFINITY, FP16.toHalf(-65520.0f));
        // Check if numbers are rounded to nearest even when they
        // cannot be accurately represented by Half
        assertEquals(0x6800, FP16.toHalf(2049.0f));
        assertEquals(0x6c00, FP16.toHalf(4098.0f));
        assertEquals(0x7000, FP16.toHalf(8196.0f));
        assertEquals(0x7400, FP16.toHalf(16392.0f));
        assertEquals(0x7800, FP16.toHalf(32784.0f));

    }

    public static void testToFloat(){
        // FP16 SNaN/QNaN inputs to float
        // The most significant bit of mantissa:
        //                 V
        // 0xfc01: 1 11111 0000000001 (signaling NaN)
        // 0xfdff: 1 11111 0111111111 (signaling NaN)
        // 0xfe00: 1 11111 1000000000 (quiet NaN)
        // 0xffff: 1 11111 1111111111 (quiet NaN)
        // This test is inspired by Java implementation of android.util.Half.toFloat(),
        // where the implementation performs SNaN->QNaN conversion.
        assert(Float.isNaN(FP16.toFloat((short)0xfc01)));
        assert(Float.isNaN(FP16.toFloat((short)0xfdff)));
        assert(Float.isNaN(FP16.toFloat((short)0xfe00)));
        assert(Float.isNaN(FP16.toFloat((short)0xffff)));
        assertEquals(0xffc02000, TestFP16ToFloatRawIntBits((short)(0xfc01)));  // SNaN->QNaN
        assertEquals(0xffffe000, TestFP16ToFloatRawIntBits((short)(0xfdff)));  // SNaN->QNaN
        assertEquals(0xffc00000, TestFP16ToFloatRawIntBits((short)(0xfe00)));  // QNaN->QNaN
        assertEquals(0xffffe000, TestFP16ToFloatRawIntBits((short)(0xffff)));  // QNaN->QNaN
    }

    public static void testFloor() {
        // These tests have been taken from the cts HalfTest
        assertEquals(FP16.POSITIVE_INFINITY, FP16.floor(FP16.POSITIVE_INFINITY));
        assertEquals(FP16.NEGATIVE_INFINITY, FP16.floor(FP16.NEGATIVE_INFINITY));
        assertEquals(FP16.POSITIVE_ZERO, FP16.floor(FP16.POSITIVE_ZERO));
        assertEquals(FP16.NEGATIVE_ZERO, FP16.floor(FP16.NEGATIVE_ZERO));
        assertEquals(FP16.NaN, FP16.floor(FP16.NaN));
        assertEquals(FP16.LOWEST_VALUE, FP16.floor(FP16.LOWEST_VALUE));
        assertEquals(FP16.POSITIVE_ZERO, FP16.floor(FP16.MIN_NORMAL));
        assertEquals(FP16.POSITIVE_ZERO, FP16.floor((short) 0x3ff));
        assertEquals(FP16.POSITIVE_ZERO, FP16.floor(FP16.toHalf(0.2f)));
        assertEquals(-1.0f, FP16.toFloat(FP16.floor(FP16.toHalf(-0.2f))));
        assertEquals(-1.0f, FP16.toFloat(FP16.floor(FP16.toHalf(-0.7f))));
        assertEquals(FP16.POSITIVE_ZERO, FP16.floor(FP16.toHalf(0.7f)));
        assertEquals(124.0f, FP16.toFloat(FP16.floor(FP16.toHalf(124.7f))));
        assertEquals(-125.0f, FP16.toFloat(FP16.floor(FP16.toHalf(-124.7f))));
        assertEquals(124.0f, FP16.toFloat(FP16.floor(FP16.toHalf(124.2f))));
        assertEquals(-125.0f, FP16.toFloat(FP16.floor(FP16.toHalf(-124.2f))));
        // floor for NaN values
        assertEquals((short) 0x7e01, FP16.floor((short) 0x7c01));
        assertEquals((short) 0x7f00, FP16.floor((short) 0x7d00));
        assertEquals((short) 0xfe01, FP16.floor((short) 0xfc01));
        assertEquals((short) 0xff00, FP16.floor((short) 0xfd00));
    }

    public static void testCeil() {
        // These tests have been taken from the cts HalfTest
        assertEquals(FP16.POSITIVE_INFINITY, FP16.ceil(FP16.POSITIVE_INFINITY));
        assertEquals(FP16.NEGATIVE_INFINITY, FP16.ceil(FP16.NEGATIVE_INFINITY));
        assertEquals(FP16.POSITIVE_ZERO, FP16.ceil(FP16.POSITIVE_ZERO));
        assertEquals(FP16.NEGATIVE_ZERO, FP16.ceil(FP16.NEGATIVE_ZERO));
        assertEquals(FP16.NaN, FP16.ceil(FP16.NaN));
        assertEquals(FP16.LOWEST_VALUE, FP16.ceil(FP16.LOWEST_VALUE));
        assertEquals(1.0f, FP16.toFloat(FP16.ceil(FP16.MIN_NORMAL)));
        assertEquals(1.0f, FP16.toFloat(FP16.ceil((short) 0x3ff)));
        assertEquals(1.0f, FP16.toFloat(FP16.ceil(FP16.toHalf(0.2f))));
        assertEquals(FP16.NEGATIVE_ZERO, FP16.ceil(FP16.toHalf(-0.2f)));
        assertEquals(1.0f, FP16.toFloat(FP16.ceil(FP16.toHalf(0.7f))));
        assertEquals(FP16.NEGATIVE_ZERO, FP16.ceil(FP16.toHalf(-0.7f)));
        assertEquals(125.0f, FP16.toFloat(FP16.ceil(FP16.toHalf(124.7f))));
        assertEquals(-124.0f, FP16.toFloat(FP16.ceil(FP16.toHalf(-124.7f))));
        assertEquals(125.0f, FP16.toFloat(FP16.ceil(FP16.toHalf(124.2f))));
        assertEquals(-124.0f, FP16.toFloat(FP16.ceil(FP16.toHalf(-124.2f))));
        // ceil for NaN values
        assertEquals((short) 0x7e01, FP16.floor((short) 0x7c01));
        assertEquals((short) 0x7f00, FP16.floor((short) 0x7d00));
        assertEquals((short) 0xfe01, FP16.floor((short) 0xfc01));
        assertEquals((short) 0xff00, FP16.floor((short) 0xfd00));
    }

    public static void testRint() {
        assertEquals(FP16.POSITIVE_INFINITY, FP16.rint(FP16.POSITIVE_INFINITY));
        assertEquals(FP16.NEGATIVE_INFINITY, FP16.rint(FP16.NEGATIVE_INFINITY));
        assertEquals(FP16.POSITIVE_ZERO, FP16.rint(FP16.POSITIVE_ZERO));
        assertEquals(FP16.NEGATIVE_ZERO, FP16.rint(FP16.NEGATIVE_ZERO));
        assertEquals(FP16.NaN, FP16.rint(FP16.NaN));
        assertEquals(FP16.LOWEST_VALUE, FP16.rint(FP16.LOWEST_VALUE));
        assertEquals(FP16.POSITIVE_ZERO, FP16.rint(FP16.MIN_VALUE));
        assertEquals(FP16.POSITIVE_ZERO, FP16.rint((short) 0x200));
        assertEquals(FP16.POSITIVE_ZERO, FP16.rint((short) 0x3ff));
        assertEquals(FP16.POSITIVE_ZERO, FP16.rint(FP16.toHalf(0.2f)));
        assertEquals(FP16.NEGATIVE_ZERO, FP16.rint(FP16.toHalf(-0.2f)));
        assertEquals(1.0f, FP16.toFloat(FP16.rint(FP16.toHalf(0.7f))));
        assertEquals(-1.0f, FP16.toFloat(FP16.rint(FP16.toHalf(-0.7f))));
        assertEquals(0.0f, FP16.toFloat(FP16.rint(FP16.toHalf(0.5f))));
        assertEquals(-0.0f, FP16.toFloat(FP16.rint(FP16.toHalf(-0.5f))));
        assertEquals(125.0f, FP16.toFloat(FP16.rint(FP16.toHalf(124.7f))));
        assertEquals(-125.0f, FP16.toFloat(FP16.rint(FP16.toHalf(-124.7f))));
        assertEquals(124.0f, FP16.toFloat(FP16.rint(FP16.toHalf(124.2f))));
        assertEquals(-124.0f, FP16.toFloat(FP16.rint(FP16.toHalf(-124.2f))));
        // floor for NaN values
        assertEquals((short) 0x7e01, FP16.floor((short) 0x7c01));
        assertEquals((short) 0x7f00, FP16.floor((short) 0x7d00));
        assertEquals((short) 0xfe01, FP16.floor((short) 0xfc01));
        assertEquals((short) 0xff00, FP16.floor((short) 0xfd00));

    }

    public static void testGreater() {
        assertTrue(FP16.greater(FP16.POSITIVE_INFINITY, FP16.NEGATIVE_INFINITY));
        assertTrue(FP16.greater(FP16.POSITIVE_INFINITY, FP16.MAX_VALUE));
        assertFalse(FP16.greater(FP16.MAX_VALUE, FP16.POSITIVE_INFINITY));
        assertFalse(FP16.greater(FP16.NEGATIVE_INFINITY, FP16.LOWEST_VALUE));
        assertTrue(FP16.greater(FP16.LOWEST_VALUE, FP16.NEGATIVE_INFINITY));
        assertFalse(FP16.greater(FP16.NEGATIVE_ZERO, FP16.POSITIVE_ZERO));
        assertFalse(FP16.greater(FP16.POSITIVE_ZERO, FP16.NEGATIVE_ZERO));
        assertFalse(FP16.greater(FP16.toHalf(12.3f), FP16.NaN));
        assertFalse(FP16.greater(FP16.NaN, FP16.toHalf(12.3f)));
        assertTrue(FP16.greater(FP16.MIN_NORMAL, FP16.MIN_VALUE));
        assertFalse(FP16.greater(FP16.MIN_VALUE, FP16.MIN_NORMAL));
        assertTrue(FP16.greater(FP16.toHalf(12.4f), FP16.toHalf(12.3f)));
        assertFalse(FP16.greater(FP16.toHalf(12.3f), FP16.toHalf(12.4f)));
        assertFalse(FP16.greater(FP16.toHalf(-12.4f), FP16.toHalf(-12.3f)));
        assertTrue(FP16.greater(FP16.toHalf(-12.3f), FP16.toHalf(-12.4f)));
        assertTrue(FP16.greater((short) 0x3ff, FP16.MIN_VALUE));

        assertFalse(FP16.greater(FP16.toHalf(-1.0f), FP16.toHalf(0.0f)));
        assertTrue(FP16.greater(FP16.toHalf(0.0f), FP16.toHalf(-1.0f)));
        assertFalse(FP16.greater(FP16.toHalf(-1.0f), FP16.toHalf(-1.0f)));
        assertFalse(FP16.greater(FP16.toHalf(-1.3f), FP16.toHalf(-1.3f)));
        assertTrue(FP16.greater(FP16.toHalf(1.0f), FP16.toHalf(0.0f)));
        assertFalse(FP16.greater(FP16.toHalf(0.0f), FP16.toHalf(1.0f)));
        assertFalse(FP16.greater(FP16.toHalf(1.0f), FP16.toHalf(1.0f)));
        assertFalse(FP16.greater(FP16.toHalf(1.3f), FP16.toHalf(1.3f)));
        assertFalse(FP16.greater(FP16.toHalf(-0.1f), FP16.toHalf(0.0f)));
        assertTrue(FP16.greater(FP16.toHalf(0.0f), FP16.toHalf(-0.1f)));
        assertFalse(FP16.greater(FP16.toHalf(-0.1f), FP16.toHalf(-0.1f)));
        assertTrue(FP16.greater(FP16.toHalf(0.1f), FP16.toHalf(0.0f)));
        assertFalse(FP16.greater(FP16.toHalf(0.0f), FP16.toHalf(0.1f)));
        assertFalse(FP16.greater(FP16.toHalf(0.1f), FP16.toHalf(0.1f)));
    }

    public static void testGreaterEquals() {
        assertTrue(FP16.greaterEquals(FP16.POSITIVE_INFINITY, FP16.NEGATIVE_INFINITY));
        assertTrue(FP16.greaterEquals(FP16.POSITIVE_INFINITY, FP16.MAX_VALUE));
        assertFalse(FP16.greaterEquals(FP16.MAX_VALUE, FP16.POSITIVE_INFINITY));
        assertFalse(FP16.greaterEquals(FP16.NEGATIVE_INFINITY, FP16.LOWEST_VALUE));
        assertTrue(FP16.greaterEquals(FP16.LOWEST_VALUE, FP16.NEGATIVE_INFINITY));
        assertTrue(FP16.greaterEquals(FP16.NEGATIVE_ZERO, FP16.POSITIVE_ZERO));
        assertTrue(FP16.greaterEquals(FP16.POSITIVE_ZERO, FP16.NEGATIVE_ZERO));
        assertFalse(FP16.greaterEquals(FP16.toHalf(12.3f), FP16.NaN));
        assertFalse(FP16.greaterEquals(FP16.NaN, FP16.toHalf(12.3f)));
        assertTrue(FP16.greaterEquals(FP16.MIN_NORMAL, FP16.MIN_VALUE));
        assertFalse(FP16.greaterEquals(FP16.MIN_VALUE, FP16.MIN_NORMAL));
        assertTrue(FP16.greaterEquals(FP16.toHalf(12.4f), FP16.toHalf(12.3f)));
        assertFalse(FP16.greaterEquals(FP16.toHalf(12.3f), FP16.toHalf(12.4f)));
        assertFalse(FP16.greaterEquals(FP16.toHalf(-12.4f), FP16.toHalf(-12.3f)));
        assertTrue(FP16.greaterEquals(FP16.toHalf(-12.3f), FP16.toHalf(-12.4f)));
        assertTrue(FP16.greaterEquals((short) 0x3ff, FP16.MIN_VALUE));
        assertTrue(FP16.greaterEquals(FP16.NEGATIVE_INFINITY, FP16.NEGATIVE_INFINITY));
        assertTrue(FP16.greaterEquals(FP16.POSITIVE_INFINITY, FP16.POSITIVE_INFINITY));
        assertTrue(FP16.greaterEquals(FP16.toHalf(12.12356f), FP16.toHalf(12.12356f)));
        assertTrue(FP16.greaterEquals(FP16.toHalf(-12.12356f), FP16.toHalf(-12.12356f)));

        assertFalse(FP16.greaterEquals(FP16.toHalf(-1.0f), FP16.toHalf(0.0f)));
        assertTrue(FP16.greaterEquals(FP16.toHalf(0.0f), FP16.toHalf(-1.0f)));
        assertTrue(FP16.greaterEquals(FP16.toHalf(-1.0f), FP16.toHalf(-1.0f)));
        assertTrue(FP16.greaterEquals(FP16.toHalf(-1.3f), FP16.toHalf(-1.3f)));
        assertTrue(FP16.greaterEquals(FP16.toHalf(1.0f), FP16.toHalf(0.0f)));
        assertFalse(FP16.greaterEquals(FP16.toHalf(0.0f), FP16.toHalf(1.0f)));
        assertTrue(FP16.greaterEquals(FP16.toHalf(1.0f), FP16.toHalf(1.0f)));
        assertTrue(FP16.greaterEquals(FP16.toHalf(1.3f), FP16.toHalf(1.3f)));
        assertFalse(FP16.greaterEquals(FP16.toHalf(-0.1f), FP16.toHalf(0.0f)));
        assertTrue(FP16.greaterEquals(FP16.toHalf(0.0f), FP16.toHalf(-0.1f)));
        assertTrue(FP16.greaterEquals(FP16.toHalf(-0.1f), FP16.toHalf(-0.1f)));
        assertTrue(FP16.greaterEquals(FP16.toHalf(0.1f), FP16.toHalf(0.0f)));
        assertFalse(FP16.greaterEquals(FP16.toHalf(0.0f), FP16.toHalf(0.1f)));
        assertTrue(FP16.greaterEquals(FP16.toHalf(0.1f), FP16.toHalf(0.1f)));
    }

    public static void testLess() {
        assertTrue(FP16.less(FP16.NEGATIVE_INFINITY, FP16.POSITIVE_INFINITY));
        assertTrue(FP16.less(FP16.MAX_VALUE, FP16.POSITIVE_INFINITY));
        assertFalse(FP16.less(FP16.POSITIVE_INFINITY, FP16.MAX_VALUE));
        assertFalse(FP16.less(FP16.LOWEST_VALUE, FP16.NEGATIVE_INFINITY));
        assertTrue(FP16.less(FP16.NEGATIVE_INFINITY, FP16.LOWEST_VALUE));
        assertFalse(FP16.less(FP16.POSITIVE_ZERO, FP16.NEGATIVE_ZERO));
        assertFalse(FP16.less(FP16.NEGATIVE_ZERO, FP16.POSITIVE_ZERO));
        assertFalse(FP16.less(FP16.NaN, FP16.toHalf(12.3f)));
        assertFalse(FP16.less(FP16.toHalf(12.3f), FP16.NaN));
        assertTrue(FP16.less(FP16.MIN_VALUE, FP16.MIN_NORMAL));
        assertFalse(FP16.less(FP16.MIN_NORMAL, FP16.MIN_VALUE));
        assertTrue(FP16.less(FP16.toHalf(12.3f), FP16.toHalf(12.4f)));
        assertFalse(FP16.less(FP16.toHalf(12.4f), FP16.toHalf(12.3f)));
        assertFalse(FP16.less(FP16.toHalf(-12.3f), FP16.toHalf(-12.4f)));
        assertTrue(FP16.less(FP16.toHalf(-12.4f), FP16.toHalf(-12.3f)));
        assertTrue(FP16.less(FP16.MIN_VALUE, (short) 0x3ff));

        assertTrue(FP16.less(FP16.toHalf(-1.0f), FP16.toHalf(0.0f)));
        assertFalse(FP16.less(FP16.toHalf(0.0f), FP16.toHalf(-1.0f)));
        assertFalse(FP16.less(FP16.toHalf(-1.0f), FP16.toHalf(-1.0f)));
        assertFalse(FP16.less(FP16.toHalf(-1.3f), FP16.toHalf(-1.3f)));
        assertFalse(FP16.less(FP16.toHalf(1.0f), FP16.toHalf(0.0f)));
        assertTrue(FP16.less(FP16.toHalf(0.0f), FP16.toHalf(1.0f)));
        assertFalse(FP16.less(FP16.toHalf(1.0f), FP16.toHalf(1.0f)));
        assertFalse(FP16.less(FP16.toHalf(1.3f), FP16.toHalf(1.3f)));
        assertTrue(FP16.less(FP16.toHalf(-0.1f), FP16.toHalf(0.0f)));
        assertFalse(FP16.less(FP16.toHalf(0.0f), FP16.toHalf(-0.1f)));
        assertFalse(FP16.less(FP16.toHalf(-0.1f), FP16.toHalf(-0.1f)));
        assertFalse(FP16.less(FP16.toHalf(0.1f), FP16.toHalf(0.0f)));
        assertTrue(FP16.less(FP16.toHalf(0.0f), FP16.toHalf(0.1f)));
        assertFalse(FP16.less(FP16.toHalf(0.1f), FP16.toHalf(0.1f)));
    }

    public static void testLessEquals() {
        assertTrue(FP16.lessEquals(FP16.NEGATIVE_INFINITY, FP16.POSITIVE_INFINITY));
        assertTrue(FP16.lessEquals(FP16.MAX_VALUE, FP16.POSITIVE_INFINITY));
        assertFalse(FP16.lessEquals(FP16.POSITIVE_INFINITY, FP16.MAX_VALUE));
        assertFalse(FP16.lessEquals(FP16.LOWEST_VALUE, FP16.NEGATIVE_INFINITY));
        assertTrue(FP16.lessEquals(FP16.NEGATIVE_INFINITY, FP16.LOWEST_VALUE));
        assertTrue(FP16.lessEquals(FP16.POSITIVE_ZERO, FP16.NEGATIVE_ZERO));
        assertTrue(FP16.lessEquals(FP16.NEGATIVE_ZERO, FP16.POSITIVE_ZERO));
        assertFalse(FP16.lessEquals(FP16.NaN, FP16.toHalf(12.3f)));
        assertFalse(FP16.lessEquals(FP16.toHalf(12.3f), FP16.NaN));
        assertTrue(FP16.lessEquals(FP16.MIN_VALUE, FP16.MIN_NORMAL));
        assertFalse(FP16.lessEquals(FP16.MIN_NORMAL, FP16.MIN_VALUE));
        assertTrue(FP16.lessEquals(FP16.toHalf(12.3f), FP16.toHalf(12.4f)));
        assertFalse(FP16.lessEquals(FP16.toHalf(12.4f), FP16.toHalf(12.3f)));
        assertFalse(FP16.lessEquals(FP16.toHalf(-12.3f), FP16.toHalf(-12.4f)));
        assertTrue(FP16.lessEquals(FP16.toHalf(-12.4f), FP16.toHalf(-12.3f)));
        assertTrue(FP16.lessEquals(FP16.MIN_VALUE, (short) 0x3ff));
        assertTrue(FP16.lessEquals(FP16.NEGATIVE_INFINITY, FP16.NEGATIVE_INFINITY));
        assertTrue(FP16.lessEquals(FP16.POSITIVE_INFINITY, FP16.POSITIVE_INFINITY));
        assertTrue(FP16.lessEquals(FP16.toHalf(12.12356f), FP16.toHalf(12.12356f)));
        assertTrue(FP16.lessEquals(FP16.toHalf(-12.12356f), FP16.toHalf(-12.12356f)));

        assertTrue(FP16.lessEquals(FP16.toHalf(-1.0f), FP16.toHalf(0.0f)));
        assertFalse(FP16.lessEquals(FP16.toHalf(0.0f), FP16.toHalf(-1.0f)));
        assertTrue(FP16.lessEquals(FP16.toHalf(-1.0f), FP16.toHalf(-1.0f)));
        assertTrue(FP16.lessEquals(FP16.toHalf(-1.3f), FP16.toHalf(-1.3f)));
        assertFalse(FP16.lessEquals(FP16.toHalf(1.0f), FP16.toHalf(0.0f)));
        assertTrue(FP16.lessEquals(FP16.toHalf(0.0f), FP16.toHalf(1.0f)));
        assertTrue(FP16.lessEquals(FP16.toHalf(1.0f), FP16.toHalf(1.0f)));
        assertTrue(FP16.lessEquals(FP16.toHalf(1.3f), FP16.toHalf(1.3f)));
        assertTrue(FP16.lessEquals(FP16.toHalf(-0.1f), FP16.toHalf(0.0f)));
        assertFalse(FP16.lessEquals(FP16.toHalf(0.0f), FP16.toHalf(-0.1f)));
        assertTrue(FP16.lessEquals(FP16.toHalf(-0.1f), FP16.toHalf(-0.1f)));
        assertFalse(FP16.lessEquals(FP16.toHalf(0.1f), FP16.toHalf(0.0f)));
        assertTrue(FP16.lessEquals(FP16.toHalf(0.0f), FP16.toHalf(0.1f)));
        assertTrue(FP16.lessEquals(FP16.toHalf(0.1f), FP16.toHalf(0.1f)));
    }

    public static void testCompare() {
        assertEquals(0, FP16.compare(FP16.NaN, FP16.NaN));
        assertEquals(0, FP16.compare(FP16.NaN, FP16_ALT_NAN));
        assertEquals(0, FP16.compare(FP16_ALT_NAN, FP16.NaN));
        assertEquals(1, FP16.compare(FP16.NaN, FP16.POSITIVE_INFINITY));
        assertEquals(-1, FP16.compare(FP16.POSITIVE_INFINITY, FP16.NaN));

        assertEquals(0, FP16.compare(FP16.POSITIVE_INFINITY, FP16.POSITIVE_INFINITY));
        assertEquals(0, FP16.compare(FP16.NEGATIVE_INFINITY, FP16.NEGATIVE_INFINITY));
        assertEquals(1, FP16.compare(FP16.POSITIVE_INFINITY, FP16.NEGATIVE_INFINITY));
        assertEquals(-1, FP16.compare(FP16.NEGATIVE_INFINITY, FP16.POSITIVE_INFINITY));

        assertEquals(0, FP16.compare(FP16.POSITIVE_ZERO, FP16.POSITIVE_ZERO));
        assertEquals(0, FP16.compare(FP16.NEGATIVE_ZERO, FP16.NEGATIVE_ZERO));
        assertEquals(1, FP16.compare(FP16.POSITIVE_ZERO, FP16.NEGATIVE_ZERO));
        assertEquals(-1, FP16.compare(FP16.NEGATIVE_ZERO, FP16.POSITIVE_ZERO));

        assertEquals(0, FP16.compare(FP16.toHalf(12.462f), FP16.toHalf(12.462f)));
        assertEquals(0, FP16.compare(FP16.toHalf(-12.462f), FP16.toHalf(-12.462f)));
        assertEquals(1, FP16.compare(FP16.toHalf(12.462f), FP16.toHalf(-12.462f)));
        assertEquals(-1, FP16.compare(FP16.toHalf(-12.462f), FP16.toHalf(12.462f)));

        assertEquals(1, FP16.compare(FP16.NaN, FP16.toHalf(12.462f)));
        assertEquals(1, FP16.compare(FP16.NaN, FP16.toHalf(-12.462f)));
        assertEquals(1, FP16.compare(FP16.NaN, FP16.EPSILON));
        assertEquals(1, FP16.compare(FP16.NaN, FP16.LOWEST_VALUE));
        assertEquals(1, FP16.compare(FP16.NaN, FP16.MAX_VALUE));
        assertEquals(1, FP16.compare(FP16.NaN, FP16.MIN_NORMAL));
        assertEquals(1, FP16.compare(FP16.NaN, FP16.MIN_VALUE));
        assertEquals(1, FP16.compare(FP16.NaN, FP16.NEGATIVE_INFINITY));
        assertEquals(1, FP16.compare(FP16.NaN, FP16.NEGATIVE_ZERO));
        assertEquals(1, FP16.compare(FP16.NaN, FP16.POSITIVE_ZERO));

        assertEquals(-1, FP16.compare(FP16.toHalf(12.462f), FP16.NaN));
        assertEquals(-1, FP16.compare(FP16.toHalf(-12.462f), FP16.NaN));
        assertEquals(-1, FP16.compare(FP16.EPSILON, FP16.NaN));
        assertEquals(-1, FP16.compare(FP16.LOWEST_VALUE, FP16.NaN));
        assertEquals(-1, FP16.compare(FP16.MAX_VALUE, FP16.NaN));
        assertEquals(-1, FP16.compare(FP16.MIN_NORMAL, FP16.NaN));
        assertEquals(-1, FP16.compare(FP16.MIN_VALUE, FP16.NaN));
        assertEquals(-1, FP16.compare(FP16.NEGATIVE_INFINITY, FP16.NaN));
        assertEquals(-1, FP16.compare(FP16.NEGATIVE_ZERO, FP16.NaN));
        assertEquals(-1, FP16.compare(FP16.POSITIVE_ZERO, FP16.NaN));

        assertEquals(1, FP16.compare(FP16.POSITIVE_INFINITY, FP16.NEGATIVE_ZERO));
        assertEquals(1, FP16.compare(FP16.POSITIVE_INFINITY, FP16.POSITIVE_ZERO));
        assertEquals(1, FP16.compare(FP16.POSITIVE_INFINITY, FP16.toHalf(12.462f)));
        assertEquals(1, FP16.compare(FP16.POSITIVE_INFINITY, FP16.toHalf(-12.462f)));
        assertEquals(-1, FP16.compare(FP16.NEGATIVE_INFINITY, FP16.toHalf(12.462f)));
        assertEquals(-1, FP16.compare(FP16.NEGATIVE_INFINITY, FP16.toHalf(-12.462f)));
        assertEquals(-1, FP16.compare(FP16.NEGATIVE_INFINITY, FP16.NEGATIVE_ZERO));
        assertEquals(-1, FP16.compare(FP16.NEGATIVE_INFINITY, FP16.POSITIVE_ZERO));

        assertEquals(-1, FP16.compare(FP16.NEGATIVE_ZERO, FP16.toHalf(12.462f)));
        assertEquals(1, FP16.compare(FP16.NEGATIVE_ZERO, FP16.toHalf(-12.462f)));
    }

    /// CHECK-START-ARM64: void Main.testCheckCompare() disassembly (after)
    /// CHECK-IF: hasIsaFeature("fp16")
    ///      CHECK:                 InvokeStaticOrDirect intrinsic:FP16Compare
    ///      CHECK:                 fcmp {{h\d+}}, {{h\d+}}
    /// CHECK-ELSE:
    ///      CHECK:                 InvokeStaticOrDirect intrinsic:FP16Compare
    ///      CHECK-NOT:             fcmp {{h\d+}}, {{h\d+}}
    /// CHECK-FI:

    public static void testCheckCompare() {
        assertEquals(0, FP16.compare(FP16.toHalf(12.462f), FP16.toHalf(12.462f)));
    }

    public static void assertMinPermutations(short small, short large){
        assertEquals(small, FP16.min(small, large));
        assertEquals(small, FP16.min(large, small));

        assertEquals(small, FP16.min(small, small));
        assertEquals(large, FP16.min(large, large));
    }

    public static void testMin() {
        assertMinPermutations(FP16.NEGATIVE_INFINITY, FP16.POSITIVE_INFINITY);
        assertMinPermutations(FP16.NEGATIVE_ZERO,FP16.POSITIVE_ZERO);
        assertMinPermutations(FP16.NEGATIVE_INFINITY, FP16.LOWEST_VALUE);
        assertMinPermutations(FP16.MAX_VALUE, FP16.POSITIVE_INFINITY);
        assertMinPermutations(FP16.MIN_VALUE, FP16.MIN_NORMAL);
        assertMinPermutations(FP16.POSITIVE_ZERO, FP16.MIN_VALUE);
        assertMinPermutations(FP16.POSITIVE_ZERO, FP16.MIN_NORMAL);
        assertMinPermutations(FP16.toHalf(-3.456f), FP16.toHalf(-3.453f));
        assertMinPermutations(FP16.toHalf(3.453f), FP16.toHalf(3.456f));
        assertMinPermutations(FP16.toHalf(-3.456f), FP16.toHalf(3.456f));
        assertMinPermutations(FP16.NaN, FP16.LOWEST_VALUE);

        assertEquals(FP16.NaN, FP16.min(FP16.NaN, FP16_ALT_NAN));
        assertEquals(FP16.NaN, FP16.min(FP16_ALT_NAN, FP16.NaN));
        assertEquals(FP16.NaN, FP16.min(FP16.NaN, FP16.NaN));
        assertEquals(FP16.NaN, FP16.min(FP16_ALT_NAN, FP16_ALT_NAN));
    }

    /// CHECK-START-ARM64: void Main.testCheckMin() disassembly (after)
    /// CHECK-IF: hasIsaFeature("fp16")
    ///      CHECK:                 InvokeStaticOrDirect intrinsic:FP16Min
    ///      CHECK:                 fcmp {{h\d+}}, {{h\d+}}
    /// CHECK-ELSE:
    ///      CHECK:                 InvokeStaticOrDirect intrinsic:FP16Min
    ///      CHECK-NOT:             fcmp {{h\d+}}, {{h\d+}}
    /// CHECK-FI:
    public static void testCheckMin() {
        assertEquals(FP16.toHalf(-3.456f), FP16.min(FP16.toHalf(-3.456f), FP16.toHalf(-3.453f)));
    }

    public static void assertMaxPermutations(short small, short large){
        assertEquals(large, FP16.max(small, large));
        assertEquals(large, FP16.max(large, small));

        assertEquals(small, FP16.max(small, small));
        assertEquals(large, FP16.max(large, large));
    }

    public static void testMax() {
        assertMaxPermutations(FP16.NEGATIVE_INFINITY, FP16.POSITIVE_INFINITY);
        assertMaxPermutations(FP16.NEGATIVE_ZERO,FP16.POSITIVE_ZERO);
        assertMaxPermutations(FP16.NEGATIVE_INFINITY, FP16.LOWEST_VALUE);
        assertMaxPermutations(FP16.MAX_VALUE, FP16.POSITIVE_INFINITY);
        assertMaxPermutations(FP16.MIN_VALUE, FP16.MIN_NORMAL);
        assertMaxPermutations(FP16.POSITIVE_ZERO, FP16.MIN_VALUE);
        assertMaxPermutations(FP16.POSITIVE_ZERO, FP16.MIN_NORMAL);
        assertMaxPermutations(FP16.toHalf(-3.456f), FP16.toHalf(-3.453f));
        assertMaxPermutations(FP16.toHalf(3.453f), FP16.toHalf(3.456f));
        assertMaxPermutations(FP16.toHalf(-3.456f), FP16.toHalf(3.456f));
        assertMaxPermutations(FP16.MAX_VALUE, FP16.NaN);

        assertEquals(FP16.NaN, FP16.max(FP16.NaN, FP16_ALT_NAN));
        assertEquals(FP16.NaN, FP16.max(FP16_ALT_NAN, FP16.NaN));
        assertEquals(FP16.NaN, FP16.max(FP16.NaN, FP16.NaN));
        assertEquals(FP16.NaN, FP16.max(FP16_ALT_NAN, FP16_ALT_NAN));
    }

    /// CHECK-START-ARM64: void Main.testCheckMax() disassembly (after)
    /// CHECK-IF: hasIsaFeature("fp16")
    ///      CHECK:                 InvokeStaticOrDirect intrinsic:FP16Max
    ///      CHECK:                 fcmp {{h\d+}}, {{h\d+}}
    /// CHECK-ELSE:
    ///      CHECK:                 InvokeStaticOrDirect intrinsic:FP16Max
    ///      CHECK-NOT:             fcmp {{h\d+}}, {{h\d+}}
    /// CHECK-FI:
    public static void testCheckMax() {
        assertEquals(FP16.toHalf(-3.453f), FP16.max(FP16.toHalf(-3.456f), FP16.toHalf(-3.453f)));
    }

    public static void main(String args[]) {
        testHalfToFloatToHalfConversions();
        testToHalf();
        testToFloat();
        testFloor();
        testCeil();
        testRint();
        testGreater();
        testGreaterEquals();
        testLessEquals();
        testLess();
        testCompare();
        testCheckCompare();
        testMin();
        testCheckMin();
        testMax();
        testCheckMax();
    }
}