Eine aufbereitete Darstellung der Quelle

 
     
 
 
Anforderungen  |   Konzepte  |   Entwurf  |   Entwicklung  |   Qualitätssicherung  |   Lebenszyklus  |   Steuerung
 
 
 
 
Benutzer

products/Sources/formale Sprachen/C/Android/art/art/test/580-checker-fp16/src-art/   (Android Betriebssystem Version 17©)  Datei vom 26.5.2026 mit Größe 28 kB image not shown  

Quelle  Main.java

  Sprache: 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();
    }
}

Messung V0.5 in Prozent
C=91 H=96 G=93

¤ Dauer der Verarbeitung: 0.14 Sekunden  (vorverarbeitet am  2026-06-29) ¤

*© Formatika GbR, Deutschland




Wurzel

Suchen

PVS Prover

Isabelle Prover

NIST Cobol Testsuite

Cephes Mathematical Library

Vienna Development Method

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.





                                                                                                                                                                                                                                                                                                                                                                                                     

Neuigkeiten

     Aktuelles
     Motto des Tages

Software

     Quellcodebibliothek
     Eigene Quellcodes
     Fremde Quellcodes
     Suchen

Aktivitäten

     Artikel über Sicherheit
     Anleitung zur Aktivierung von SSL

Muße

     Gedichte
     Musik
     Bilder
Jenseits des Üblichen ....
    

Besucherstatistik

Besucherstatistik