523 lines
28 KiB
Java
523 lines
28 KiB
Java
/*
|
|
* 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();
|
|
}
|
|
}
|