FormattedFloatingDecimal.java

/*
 * Copyright (c) 2003, 2013, 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.  Oracle designates this
 * particular file as subject to the "Classpath" exception as provided
 * by Oracle in the LICENSE file that accompanied this code.
 *
 * 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.
 */

package sun.misc;

import java.util.Arrays;

public class FormattedFloatingDecimal{

    public enum Form { SCIENTIFIC, COMPATIBLE, DECIMAL_FLOAT, GENERAL };


    public static FormattedFloatingDecimal valueOf(double d, int precision, Form form){
        FloatingDecimal.BinaryToASCIIConverter fdConverter =
                FloatingDecimal.getBinaryToASCIIConverter(d, form == Form.COMPATIBLE);
        return new FormattedFloatingDecimal(precision,form, fdConverter);
    }

    private int decExponentRounded;
    private char[] mantissa;
    private char[] exponent;

    private static final ThreadLocal<Object> threadLocalCharBuffer =
            new ThreadLocal<Object>() {
                @Override
                protected Object initialValue() {
                    return new char[20];
                }
            };

    private static char[] getBuffer(){
        return (char[]) threadLocalCharBuffer.get();
    }

    private FormattedFloatingDecimal(int precision, Form form, FloatingDecimal.BinaryToASCIIConverter fdConverter) {
        if (fdConverter.isExceptional()) {
            this.mantissa = fdConverter.toJavaFormatString().toCharArray();
            this.exponent = null;
            return;
        }
        char[] digits = getBuffer();
        int nDigits = fdConverter.getDigits(digits);
        int decExp = fdConverter.getDecimalExponent();
        int exp;
        boolean isNegative = fdConverter.isNegative();
        switch (form) {
            case COMPATIBLE:
                exp = decExp;
                this.decExponentRounded = exp;
                fillCompatible(precision, digits, nDigits, exp, isNegative);
                break;
            case DECIMAL_FLOAT:
                exp = applyPrecision(decExp, digits, nDigits, decExp + precision);
                fillDecimal(precision, digits, nDigits, exp, isNegative);
                this.decExponentRounded = exp;
                break;
            case SCIENTIFIC:
                exp = applyPrecision(decExp, digits, nDigits, precision + 1);
                fillScientific(precision, digits, nDigits, exp, isNegative);
                this.decExponentRounded = exp;
                break;
            case GENERAL:
                exp = applyPrecision(decExp, digits, nDigits, precision);
                // adjust precision to be the number of digits to right of decimal
                // the real exponent to be output is actually exp - 1, not exp
                if (exp - 1 < -4 || exp - 1 >= precision) {
                    // form = Form.SCIENTIFIC;
                    precision--;
                    fillScientific(precision, digits, nDigits, exp, isNegative);
                } else {
                    // form = Form.DECIMAL_FLOAT;
                    precision = precision - exp;
                    fillDecimal(precision, digits, nDigits, exp, isNegative);
                }
                this.decExponentRounded = exp;
                break;
            default:
                assert false;
        }
    }

    // returns the exponent after rounding has been done by applyPrecision
    public int getExponentRounded() {
        return decExponentRounded - 1;
    }

    public char[] getMantissa(){
        return mantissa;
    }

    public char[] getExponent(){
        return exponent;
    }

    /**
     * Returns new decExp in case of overflow.
     */
    private static int applyPrecision(int decExp, char[] digits, int nDigits, int prec) {
        if (prec >= nDigits || prec < 0) {
            // no rounding necessary
            return decExp;
        }
        if (prec == 0) {
            // only one digit (0 or 1) is returned because the precision
            // excludes all significant digits
            if (digits[0] >= '5') {
                digits[0] = '1';
                Arrays.fill(digits, 1, nDigits, '0');
                return decExp + 1;
            } else {
                Arrays.fill(digits, 0, nDigits, '0');
                return decExp;
            }
        }
        int q = digits[prec];
        if (q >= '5') {
            int i = prec;
            q = digits[--i];
            if ( q == '9' ) {
                while ( q == '9' && i > 0 ){
                    q = digits[--i];
                }
                if ( q == '9' ){
                    // carryout! High-order 1, rest 0s, larger exp.
                    digits[0] = '1';
                    Arrays.fill(digits, 1, nDigits, '0');
                    return decExp+1;
                }
            }
            digits[i] = (char)(q + 1);
            Arrays.fill(digits, i+1, nDigits, '0');
        } else {
            Arrays.fill(digits, prec, nDigits, '0');
        }
        return decExp;
    }

    /**
     * Fills mantissa and exponent char arrays for compatible format.
     */
    private void fillCompatible(int precision, char[] digits, int nDigits, int exp, boolean isNegative) {
        int startIndex = isNegative ? 1 : 0;
        if (exp > 0 && exp < 8) {
            // print digits.digits.
            if (nDigits < exp) {
                int extraZeros = exp - nDigits;
                mantissa = create(isNegative, nDigits + extraZeros + 2);
                System.arraycopy(digits, 0, mantissa, startIndex, nDigits);
                Arrays.fill(mantissa, startIndex + nDigits, startIndex + nDigits + extraZeros, '0');
                mantissa[startIndex + nDigits + extraZeros] = '.';
                mantissa[startIndex + nDigits + extraZeros+1] = '0';
            } else if (exp < nDigits) {
                int t = Math.min(nDigits - exp, precision);
                mantissa = create(isNegative, exp + 1 + t);
                System.arraycopy(digits, 0, mantissa, startIndex, exp);
                mantissa[startIndex + exp ] = '.';
                System.arraycopy(digits, exp, mantissa, startIndex+exp+1, t);
            } else { // exp == digits.length
                mantissa = create(isNegative, nDigits + 2);
                System.arraycopy(digits, 0, mantissa, startIndex, nDigits);
                mantissa[startIndex + nDigits ] = '.';
                mantissa[startIndex + nDigits +1] = '0';
            }
        } else if (exp <= 0 && exp > -3) {
            int zeros = Math.max(0, Math.min(-exp, precision));
            int t = Math.max(0, Math.min(nDigits, precision + exp));
            // write '0' s before the significant digits
            if (zeros > 0) {
                mantissa = create(isNegative, zeros + 2 + t);
                mantissa[startIndex] = '0';
                mantissa[startIndex+1] = '.';
                Arrays.fill(mantissa, startIndex + 2, startIndex + 2 + zeros, '0');
                if (t > 0) {
                    // copy only when significant digits are within the precision
                    System.arraycopy(digits, 0, mantissa, startIndex + 2 + zeros, t);
                }
            } else if (t > 0) {
                mantissa = create(isNegative, zeros + 2 + t);
                mantissa[startIndex] = '0';
                mantissa[startIndex + 1] = '.';
                // copy only when significant digits are within the precision
                System.arraycopy(digits, 0, mantissa, startIndex + 2, t);
            } else {
                this.mantissa = create(isNegative, 1);
                this.mantissa[startIndex] = '0';
            }
        } else {
            if (nDigits > 1) {
                mantissa = create(isNegative, nDigits + 1);
                mantissa[startIndex] = digits[0];
                mantissa[startIndex + 1] = '.';
                System.arraycopy(digits, 1, mantissa, startIndex + 2, nDigits - 1);
            } else {
                mantissa = create(isNegative, 3);
                mantissa[startIndex] = digits[0];
                mantissa[startIndex + 1] = '.';
                mantissa[startIndex + 2] = '0';
            }
            int e, expStartIntex;
            boolean isNegExp = (exp <= 0);
            if (isNegExp) {
                e = -exp + 1;
                expStartIntex = 1;
            } else {
                e = exp - 1;
                expStartIntex = 0;
            }
            // decExponent has 1, 2, or 3, digits
            if (e <= 9) {
                exponent = create(isNegExp,1);
                exponent[expStartIntex] = (char) (e + '0');
            } else if (e <= 99) {
                exponent = create(isNegExp,2);
                exponent[expStartIntex] = (char) (e / 10 + '0');
                exponent[expStartIntex+1] = (char) (e % 10 + '0');
            } else {
                exponent = create(isNegExp,3);
                exponent[expStartIntex] = (char) (e / 100 + '0');
                e %= 100;
                exponent[expStartIntex+1] = (char) (e / 10 + '0');
                exponent[expStartIntex+2] = (char) (e % 10 + '0');
            }
        }
    }

    private static char[] create(boolean isNegative, int size) {
        if(isNegative) {
            char[] r = new char[size +1];
            r[0] = '-';
            return r;
        } else {
            return new char[size];
        }
    }

    /*
     * Fills mantissa char arrays for DECIMAL_FLOAT format.
     * Exponent should be equal to null.
     */
    private void fillDecimal(int precision, char[] digits, int nDigits, int exp, boolean isNegative) {
        int startIndex = isNegative ? 1 : 0;
        if (exp > 0) {
            // print digits.digits.
            if (nDigits < exp) {
                mantissa = create(isNegative,exp);
                System.arraycopy(digits, 0, mantissa, startIndex, nDigits);
                Arrays.fill(mantissa, startIndex + nDigits, startIndex + exp, '0');
                // Do not append ".0" for formatted floats since the user
                // may request that it be omitted. It is added as necessary
                // by the Formatter.
            } else {
                int t = Math.min(nDigits - exp, precision);
                mantissa = create(isNegative, exp + (t > 0 ? (t + 1) : 0));
                System.arraycopy(digits, 0, mantissa, startIndex, exp);
                // Do not append ".0" for formatted floats since the user
                // may request that it be omitted. It is added as necessary
                // by the Formatter.
                if (t > 0) {
                    mantissa[startIndex + exp] = '.';
                    System.arraycopy(digits, exp, mantissa, startIndex + exp + 1, t);
                }
            }
        } else if (exp <= 0) {
            int zeros = Math.max(0, Math.min(-exp, precision));
            int t = Math.max(0, Math.min(nDigits, precision + exp));
            // write '0' s before the significant digits
            if (zeros > 0) {
                mantissa = create(isNegative, zeros + 2 + t);
                mantissa[startIndex] = '0';
                mantissa[startIndex+1] = '.';
                Arrays.fill(mantissa, startIndex + 2, startIndex + 2 + zeros, '0');
                if (t > 0) {
                    // copy only when significant digits are within the precision
                    System.arraycopy(digits, 0, mantissa, startIndex + 2 + zeros, t);
                }
            } else if (t > 0) {
                mantissa = create(isNegative, zeros + 2 + t);
                mantissa[startIndex] = '0';
                mantissa[startIndex + 1] = '.';
                // copy only when significant digits are within the precision
                System.arraycopy(digits, 0, mantissa, startIndex + 2, t);
            } else {
                this.mantissa = create(isNegative, 1);
                this.mantissa[startIndex] = '0';
            }
        }
    }

    /**
     * Fills mantissa and exponent char arrays for SCIENTIFIC format.
     */
    private void fillScientific(int precision, char[] digits, int nDigits, int exp, boolean isNegative) {
        int startIndex = isNegative ? 1 : 0;
        int t = Math.max(0, Math.min(nDigits - 1, precision));
        if (t > 0) {
            mantissa = create(isNegative, t + 2);
            mantissa[startIndex] = digits[0];
            mantissa[startIndex + 1] = '.';
            System.arraycopy(digits, 1, mantissa, startIndex + 2, t);
        } else {
            mantissa = create(isNegative, 1);
            mantissa[startIndex] = digits[0];
        }
        char expSign;
        int e;
        if (exp <= 0) {
            expSign = '-';
            e = -exp + 1;
        } else {
            expSign = '+' ;
            e = exp - 1;
        }
        // decExponent has 1, 2, or 3, digits
        if (e <= 9) {
            exponent = new char[] { expSign,
                    '0', (char) (e + '0') };
        } else if (e <= 99) {
            exponent = new char[] { expSign,
                    (char) (e / 10 + '0'), (char) (e % 10 + '0') };
        } else {
            char hiExpChar = (char) (e / 100 + '0');
            e %= 100;
            exponent = new char[] { expSign,
                    hiExpChar, (char) (e / 10 + '0'), (char) (e % 10 + '0') };
        }
    }
}