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