Java example source code file (ParseHexFloatingPoint.java)

This example Java source code file (ParseHexFloatingPoint.java) is included in the alvinalexander.com "Java Source Code Warehouse" project. The intent of this project is to help you "Learn Java by Example" ^TM.

Learn more about this Java project at its project page.

Java - Java tags/keywords

for, nand, pairsd, parsehexfloatingpoint, regex, runtimeexception, string

The ParseHexFloatingPoint.java Java example source code

/*
 * Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

/*
 * @test
 * @bug 4826774
 * @summary Numerical tests for hexadecimal inputs to parseDouble, parseFloat
 * @author Joseph D. Darcy
 */


import java.util.regex.*;
import sun.misc.DoubleConsts;

public class ParseHexFloatingPoint {
    private ParseHexFloatingPoint(){}

    public static final double infinityD = Double.POSITIVE_INFINITY;
    public static final double NaND = Double.NaN;

    static int test(String testName, String input,
                    double result, double expected) {
        int failures =0;

        if (Double.compare(result, expected) != 0 ) {
            System.err.println("Failure for " + testName +
                               ": For input " + input +
                               " expected " + expected +
                               " got " + result + ".");
        }

        return failures;
    }

    static int testCase(String input, double expected) {
        int failures =0;


        // Try different combination of letter components
        input = input.toLowerCase(java.util.Locale.US);

        String [] suffices = {"", "f", "F", "d", "D"};
        String [] signs = {"", "-", "+"};

        for(int i = 0; i < 2; i++) {
            String s1 = input;
            if(i == 1)
                s1 = s1.replace('x', 'X');

            for(int j = 0; j < 2; j++) {
                String s2 = s1;
                if(j == 1)
                    s2 = s2.replace('p', 'P');

                for(int k = 0; k < 2; k++) {
                    String s3 = s2;
                    if(k == 1)
                        s3 = upperCaseHex(s3);


                    for(int m = 0; m < suffices.length; m++) {
                        String s4 = s3 + suffices[m];


                        for(int n = 0; n < signs.length; n++) {
                            String s5 = signs[n] + s4;

                            double result = Double.parseDouble(s5);
                            failures += test("Double.parseDouble",
                                             s5, result, (signs[n].equals("-") ?
                                                          -expected:
                                                          expected));
                        }
                    }
                }
            }
        }

        return failures;
    }

    static String upperCaseHex(String s) {
        return s.replace('a', 'A').replace('b', 'B').replace('c', 'C').
                 replace('d', 'D').replace('e','E').replace('f', 'F');
    }

    /*
     * Test easy and tricky double rounding cases.
     */
    static int doubleTests() {

        /*
         * A String, double pair
         */
        class PairSD {
            public String s;
            public double d;
            PairSD(String s, double d) {
                this.s = s;
                this.d = d;
            }
        }
        int failures = 0;



        // Hex strings that convert to three; test basic functionality
        // of significand and exponent shift adjusts along with the
        // no-op of adding leading zeros.  These cases don't exercise
        // the rounding code.
        String leadingZeros = "0x0000000000000000000";
        String [] threeTests = {
            "0x.003p12",
            "0x.006p11",
            "0x.00cp10",
            "0x.018p9",

            "0x.3p4",
            "0x.6p3",
            "0x.cp2",
            "0x1.8p1",

            "0x3p0",
            "0x6.0p-1",
            "0xc.0p-2",
            "0x18.0p-3",

            "0x3000000p-24",
            "0x3.0p0",
            "0x3.000000p0",
        };
        for(int i=0; i < threeTests.length; i++) {
            String input = threeTests[i];
            failures += testCase(input, 3.0);

            input.replaceFirst("^0x", leadingZeros);
            failures += testCase(input, 3.0);
        }

        long bigExponents [] = {
            2*DoubleConsts.MAX_EXPONENT,
            2*DoubleConsts.MIN_EXPONENT,

            (long)Integer.MAX_VALUE-1,
            (long)Integer.MAX_VALUE,
            (long)Integer.MAX_VALUE+1,

            (long)Integer.MIN_VALUE-1,
            (long)Integer.MIN_VALUE,
            (long)Integer.MIN_VALUE+1,

            Long.MAX_VALUE-1,
            Long.MAX_VALUE,

            Long.MIN_VALUE+1,
            Long.MIN_VALUE,
        };

        // Test zero significand with large exponents.
        for(int i = 0; i < bigExponents.length; i++) {
            failures += testCase("0x0.0p"+Long.toString(bigExponents[i]) , 0.0);
        }

        // Test nonzero significand with large exponents.
        for(int i = 0; i < bigExponents.length; i++) {
            long exponent = bigExponents[i];
            failures += testCase("0x10000.0p"+Long.toString(exponent) ,
                                 (exponent <0?0.0:infinityD));
        }

        // Test significands with different lengths and bit patterns.
        {
            long signif = 0;
                for(int i = 1; i <= 0xe; i++) {
                    signif = (signif <<4) | (long)i;
                    failures += testCase("0x"+Long.toHexString(signif)+"p0", signif);
                }
        }

        PairSD [] testCases = {
            new PairSD("0x0.0p0",               0.0/16.0),
            new PairSD("0x0.1p0",               1.0/16.0),
            new PairSD("0x0.2p0",               2.0/16.0),
            new PairSD("0x0.3p0",               3.0/16.0),
            new PairSD("0x0.4p0",               4.0/16.0),
            new PairSD("0x0.5p0",               5.0/16.0),
            new PairSD("0x0.6p0",               6.0/16.0),
            new PairSD("0x0.7p0",               7.0/16.0),
            new PairSD("0x0.8p0",               8.0/16.0),
            new PairSD("0x0.9p0",               9.0/16.0),
            new PairSD("0x0.ap0",               10.0/16.0),
            new PairSD("0x0.bp0",               11.0/16.0),
            new PairSD("0x0.cp0",               12.0/16.0),
            new PairSD("0x0.dp0",               13.0/16.0),
            new PairSD("0x0.ep0",               14.0/16.0),
            new PairSD("0x0.fp0",               15.0/16.0),

            // Half-way case between zero and MIN_VALUE rounds down to
            // zero
            new PairSD("0x1.0p-1075",           0.0),

            // Slighly more than half-way case between zero and
            // MIN_VALUES rounds up to zero.
            new PairSD("0x1.1p-1075",                   Double.MIN_VALUE),
            new PairSD("0x1.000000000001p-1075",        Double.MIN_VALUE),
            new PairSD("0x1.000000000000001p-1075",     Double.MIN_VALUE),

            // More subnormal rounding tests
            new PairSD("0x0.fffffffffffff7fffffp-1022", Math.nextDown(DoubleConsts.MIN_NORMAL)),
            new PairSD("0x0.fffffffffffff8p-1022",      DoubleConsts.MIN_NORMAL),
            new PairSD("0x0.fffffffffffff800000001p-1022",DoubleConsts.MIN_NORMAL),
            new PairSD("0x0.fffffffffffff80000000000000001p-1022",DoubleConsts.MIN_NORMAL),
            new PairSD("0x1.0p-1022",                   DoubleConsts.MIN_NORMAL),


            // Large value and overflow rounding tests
            new PairSD("0x1.fffffffffffffp1023",        Double.MAX_VALUE),
            new PairSD("0x1.fffffffffffff0000000p1023", Double.MAX_VALUE),
            new PairSD("0x1.fffffffffffff4p1023",       Double.MAX_VALUE),
            new PairSD("0x1.fffffffffffff7fffffp1023",  Double.MAX_VALUE),
            new PairSD("0x1.fffffffffffff8p1023",       infinityD),
            new PairSD("0x1.fffffffffffff8000001p1023", infinityD),

            new PairSD("0x1.ffffffffffffep1023",        Math.nextDown(Double.MAX_VALUE)),
            new PairSD("0x1.ffffffffffffe0000p1023",    Math.nextDown(Double.MAX_VALUE)),
            new PairSD("0x1.ffffffffffffe8p1023",       Math.nextDown(Double.MAX_VALUE)),
            new PairSD("0x1.ffffffffffffe7p1023",       Math.nextDown(Double.MAX_VALUE)),
            new PairSD("0x1.ffffffffffffeffffffp1023",  Double.MAX_VALUE),
            new PairSD("0x1.ffffffffffffe8000001p1023", Double.MAX_VALUE),
        };

        for (int i = 0; i < testCases.length; i++) {
            failures += testCase(testCases[i].s,testCases[i].d);
        }

        failures += significandAlignmentTests();

        {
            java.util.Random rand = new java.util.Random();
            // Consistency check; double => hexadecimal => double
            // preserves the original value.
            for(int i = 0; i < 1000; i++) {
                double d = rand.nextDouble();
                failures += testCase(Double.toHexString(d), d);
            }
        }

        return failures;
    }

    /*
     * Verify rounding works the same regardless of how the
     * significand is aligned on input.  A useful extension could be
     * to have this sort of test for strings near the overflow
     * threshold.
     */
    static int significandAlignmentTests() {
        int failures = 0;
                // baseSignif * 2^baseExp = nextDown(2.0)
        long [] baseSignifs = {
            0x1ffffffffffffe00L,
            0x1fffffffffffff00L
        };

        double [] answers = {
            Math.nextDown(Math.nextDown(2.0)),
            Math.nextDown(2.0),
            2.0
        };

        int baseExp = -60;
        int count = 0;
        for(int i = 0; i < 2; i++) {
            for(long j = 0; j <= 0xfL; j++) {
                for(long k = 0; k <= 8; k+= 4) { // k = {0, 4, 8}
                    long base = baseSignifs[i];
                    long testValue = base | (j<<4) | k;

                    int offset = 0;
                    // Calculate when significand should be incremented
                    // see table 4.7 in Koren book

                    if ((base & 0x100L) == 0L ) { // lsb is 0
                        if ( (j >= 8L) &&         // round is 1
                             ((j & 0x7L) != 0 || k != 0 ) ) // sticky is 1
                            offset = 1;
                    }
                    else {                        // lsb is 1
                        if (j >= 8L)              // round is 1
                            offset = 1;
                    }

                    double expected = answers[i+offset];

                    for(int m = -2; m <= 3; m++) {
                        count ++;

                        // Form equal value string and evaluate it
                        String s = "0x" +
                            Long.toHexString((m >=0) ?(testValue<>(-m))) +
                            "p" + (baseExp - m);

                        failures += testCase(s, expected);
                    }
                }
            }
        }

        return failures;
    }


    /*
     * Test tricky float rounding cases.  The code which
     * reads in a hex string converts the string to a double value.
     * If a float value is needed, the double value is cast to float.
     * However, the cast be itself not always guaranteed to return the
     * right result since:
     *
     * 1. hex string => double can discard a sticky bit which would
     * influence a direct hex string => float conversion.
     *
     * 2. hex string => double => float can have a rounding to double
     * precision which results in a larger float value while a direct
     * hex string => float conversion would not round up.
     *
     * This method includes tests of the latter two possibilities.
     */
    static int floatTests(){
        int failures = 0;

        /*
         * A String, float pair
         */
        class PairSD {
            public String s;
            public float f;
            PairSD(String s, float f) {
                this.s = s;
                this.f = f;
            }
        }

        String [][] roundingTestCases = {
            // Target float value       hard rouding version

            {"0x1.000000p0",    "0x1.0000000000001p0"},

            // Try some values that should round up to nextUp(1.0f)
            {"0x1.000002p0",    "0x1.0000010000001p0"},
            {"0x1.000002p0",    "0x1.00000100000008p0"},
            {"0x1.000002p0",    "0x1.0000010000000fp0"},
            {"0x1.000002p0",    "0x1.00000100000001p0"},
            {"0x1.000002p0",    "0x1.00000100000000000000000000000000000000001p0"},
            {"0x1.000002p0",    "0x1.0000010000000fp0"},

            // Potential double rounding cases
            {"0x1.000002p0",    "0x1.000002fffffffp0"},
            {"0x1.000002p0",    "0x1.000002fffffff8p0"},
            {"0x1.000002p0",    "0x1.000002ffffffffp0"},

            {"0x1.000002p0",    "0x1.000002ffff0ffp0"},
            {"0x1.000002p0",    "0x1.000002ffff0ff8p0"},
            {"0x1.000002p0",    "0x1.000002ffff0fffp0"},


            {"0x1.000000p0",    "0x1.000000fffffffp0"},
            {"0x1.000000p0",    "0x1.000000fffffff8p0"},
            {"0x1.000000p0",    "0x1.000000ffffffffp0"},

            {"0x1.000000p0",    "0x1.000000ffffffep0"},
            {"0x1.000000p0",    "0x1.000000ffffffe8p0"},
            {"0x1.000000p0",    "0x1.000000ffffffefp0"},

            // Float subnormal cases
            {"0x0.000002p-126", "0x0.0000010000001p-126"},
            {"0x0.000002p-126", "0x0.00000100000000000001p-126"},

            {"0x0.000006p-126", "0x0.0000050000001p-126"},
            {"0x0.000006p-126", "0x0.00000500000000000001p-126"},

            {"0x0.0p-149",      "0x0.7ffffffffffffffp-149"},
            {"0x1.0p-148",      "0x1.3ffffffffffffffp-148"},
            {"0x1.cp-147",      "0x1.bffffffffffffffp-147"},

            {"0x1.fffffcp-127", "0x1.fffffdffffffffp-127"},
        };

        String [] signs = {"", "-"};

        for(int i = 0; i < roundingTestCases.length; i++) {
            for(int j = 0; j < signs.length; j++) {
                String expectedIn = signs[j]+roundingTestCases[i][0];
                String resultIn   = signs[j]+roundingTestCases[i][1];

                float expected =  Float.parseFloat(expectedIn);
                float result   =  Float.parseFloat(resultIn);

                if( Float.compare(expected, result) != 0) {
                    failures += 1;
                    System.err.println("" + (i+1));
                    System.err.println("Expected = " + Float.toHexString(expected));
                    System.err.println("Rounded  = " + Float.toHexString(result));
                    System.err.println("Double   = " + Double.toHexString(Double.parseDouble(resultIn)));
                    System.err.println("Input    = " + resultIn);
                    System.err.println("");
                }
            }
        }

        return failures;
    }

    public static void main(String argv[]) {
        int failures = 0;

        failures += doubleTests();
        failures += floatTests();

        if (failures != 0) {
            throw new RuntimeException("" + failures + " failures while " +
                                       "testing hexadecimal floating-point " +
                                       "parsing.");
        }
    }

}