| /* |
| * Copyright (c) 2015, 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. |
| */ |
| |
| // This file is available under and governed by the GNU General Public |
| // License version 2 only, as published by the Free Software Foundation. |
| // However, the following notice accompanied the original version of this |
| // file: |
| // |
| // Copyright 2011 the V8 project authors. All rights reserved. |
| // Redistribution and use in source and binary forms, with or without |
| // modification, are permitted provided that the following conditions are |
| // met: |
| // |
| // * Redistributions of source code must retain the above copyright |
| // notice, this list of conditions and the following disclaimer. |
| // * Redistributions in binary form must reproduce the above |
| // copyright notice, this list of conditions and the following |
| // disclaimer in the documentation and/or other materials provided |
| // with the distribution. |
| // * Neither the name of Google Inc. nor the names of its |
| // contributors may be used to endorse or promote products derived |
| // from this software without specific prior written permission. |
| // |
| // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| package jdk.nashorn.internal.runtime.doubleconv; |
| |
| /** |
| * This class provides the public API for the double conversion package. |
| */ |
| public final class DoubleConversion { |
| |
| private final static int BUFFER_LENGTH = 30; |
| |
| /** |
| * Converts a double number to its shortest string representation. |
| * |
| * @param value number to convert |
| * @return formatted number |
| */ |
| public static String toShortestString(final double value) { |
| final DtoaBuffer buffer = new DtoaBuffer(FastDtoa.kFastDtoaMaximalLength); |
| final double absValue = Math.abs(value); |
| |
| if (value < 0) { |
| buffer.isNegative = true; |
| } |
| |
| if (!fastDtoaShortest(absValue, buffer)) { |
| buffer.reset(); |
| bignumDtoa(absValue, DtoaMode.SHORTEST, 0, buffer); |
| } |
| |
| return buffer.format(DtoaMode.SHORTEST, 0); |
| } |
| |
| /** |
| * Converts a double number to a string representation with a fixed number of digits |
| * after the decimal point. |
| * |
| * @param value number to convert. |
| * @param requestedDigits number of digits after decimal point |
| * @return formatted number |
| */ |
| public static String toFixed(final double value, final int requestedDigits) { |
| final DtoaBuffer buffer = new DtoaBuffer(BUFFER_LENGTH); |
| final double absValue = Math.abs(value); |
| |
| if (value < 0) { |
| buffer.isNegative = true; |
| } |
| |
| if (value == 0) { |
| buffer.append('0'); |
| buffer.decimalPoint = 1; |
| } else if (!fixedDtoa(absValue, requestedDigits, buffer)) { |
| buffer.reset(); |
| bignumDtoa(absValue, DtoaMode.FIXED, requestedDigits, buffer); |
| } |
| |
| return buffer.format(DtoaMode.FIXED, requestedDigits); |
| } |
| |
| /** |
| * Converts a double number to a string representation with a fixed number of digits. |
| * |
| * @param value number to convert |
| * @param precision number of digits to create |
| * @return formatted number |
| */ |
| public static String toPrecision(final double value, final int precision) { |
| final DtoaBuffer buffer = new DtoaBuffer(precision); |
| final double absValue = Math.abs(value); |
| |
| if (value < 0) { |
| buffer.isNegative = true; |
| } |
| |
| if (value == 0) { |
| for (int i = 0; i < precision; i++) { |
| buffer.append('0'); |
| } |
| buffer.decimalPoint = 1; |
| |
| } else if (!fastDtoaCounted(absValue, precision, buffer)) { |
| buffer.reset(); |
| bignumDtoa(absValue, DtoaMode.PRECISION, precision, buffer); |
| } |
| |
| return buffer.format(DtoaMode.PRECISION, 0); |
| } |
| |
| /** |
| * Converts a double number to a string representation using the |
| * {@code BignumDtoa} algorithm and the specified conversion mode |
| * and number of digits. |
| * |
| * @param v number to convert |
| * @param mode conversion mode |
| * @param digits number of digits |
| * @param buffer buffer to use |
| */ |
| public static void bignumDtoa(final double v, final DtoaMode mode, final int digits, final DtoaBuffer buffer) { |
| assert(v > 0); |
| assert(!Double.isNaN(v)); |
| assert(!Double.isInfinite(v)); |
| |
| BignumDtoa.bignumDtoa(v, mode, digits, buffer); |
| } |
| |
| /** |
| * Converts a double number to its shortest string representation |
| * using the {@code FastDtoa} algorithm. |
| * |
| * @param v number to convert |
| * @param buffer buffer to use |
| * @return true if conversion succeeded |
| */ |
| public static boolean fastDtoaShortest(final double v, final DtoaBuffer buffer) { |
| assert(v > 0); |
| assert(!Double.isNaN(v)); |
| assert(!Double.isInfinite(v)); |
| |
| return FastDtoa.grisu3(v, buffer); |
| } |
| |
| /** |
| * Converts a double number to a string representation with the |
| * given number of digits using the {@code FastDtoa} algorithm. |
| * |
| * @param v number to convert |
| * @param precision number of digits to generate |
| * @param buffer buffer to use |
| * @return true if conversion succeeded |
| */ |
| public static boolean fastDtoaCounted(final double v, final int precision, final DtoaBuffer buffer) { |
| assert(v > 0); |
| assert(!Double.isNaN(v)); |
| assert(!Double.isInfinite(v)); |
| |
| return FastDtoa.grisu3Counted(v, precision, buffer); |
| } |
| |
| /** |
| * Converts a double number to a string representation with a |
| * fixed number of digits after the decimal point using the |
| * {@code FixedDtoa} algorithm. |
| * |
| * @param v number to convert. |
| * @param digits number of digits after the decimal point |
| * @param buffer buffer to use |
| * @return true if conversion succeeded |
| */ |
| public static boolean fixedDtoa(final double v, final int digits, final DtoaBuffer buffer) { |
| assert(v > 0); |
| assert(!Double.isNaN(v)); |
| assert(!Double.isInfinite(v)); |
| |
| return FixedDtoa.fastFixedDtoa(v, digits, buffer); |
| } |
| |
| } |
