| /* |
| * 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 2010 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; |
| |
| // Dtoa implementation based on our own Bignum implementation, supporting |
| // all conversion modes but slightly slower than the specialized implementations. |
| class BignumDtoa { |
| |
| private static int normalizedExponent(long significand, int exponent) { |
| assert (significand != 0); |
| while ((significand & IeeeDouble.kHiddenBit) == 0) { |
| significand = significand << 1; |
| exponent = exponent - 1; |
| } |
| return exponent; |
| } |
| |
| // Converts the given double 'v' to ascii. |
| // The result should be interpreted as buffer * 10^(point-length). |
| // The buffer will be null-terminated. |
| // |
| // The input v must be > 0 and different from NaN, and Infinity. |
| // |
| // The output depends on the given mode: |
| // - SHORTEST: produce the least amount of digits for which the internal |
| // identity requirement is still satisfied. If the digits are printed |
| // (together with the correct exponent) then reading this number will give |
| // 'v' again. The buffer will choose the representation that is closest to |
| // 'v'. If there are two at the same distance, than the number is round up. |
| // In this mode the 'requested_digits' parameter is ignored. |
| // - FIXED: produces digits necessary to print a given number with |
| // 'requested_digits' digits after the decimal point. The produced digits |
| // might be too short in which case the caller has to fill the gaps with '0's. |
| // Example: toFixed(0.001, 5) is allowed to return buffer="1", point=-2. |
| // Halfway cases are rounded up. The call toFixed(0.15, 2) thus returns |
| // buffer="2", point=0. |
| // Note: the length of the returned buffer has no meaning wrt the significance |
| // of its digits. That is, just because it contains '0's does not mean that |
| // any other digit would not satisfy the internal identity requirement. |
| // - PRECISION: produces 'requested_digits' where the first digit is not '0'. |
| // Even though the length of produced digits usually equals |
| // 'requested_digits', the function is allowed to return fewer digits, in |
| // which case the caller has to fill the missing digits with '0's. |
| // Halfway cases are again rounded up. |
| // 'BignumDtoa' expects the given buffer to be big enough to hold all digits |
| // and a terminating null-character. |
| static void bignumDtoa(final double v, final DtoaMode mode, final int requested_digits, |
| final DtoaBuffer buffer) { |
| assert (v > 0); |
| assert (!IeeeDouble.isSpecial(IeeeDouble.doubleToLong(v))); |
| final long significand; |
| final int exponent; |
| final boolean lower_boundary_is_closer; |
| |
| final long l = IeeeDouble.doubleToLong(v); |
| significand = IeeeDouble.significand(l); |
| exponent = IeeeDouble.exponent(l); |
| lower_boundary_is_closer = IeeeDouble.lowerBoundaryIsCloser(l); |
| |
| final boolean need_boundary_deltas = mode == DtoaMode.SHORTEST; |
| |
| final boolean is_even = (significand & 1) == 0; |
| assert (significand != 0); |
| final int normalizedExponent = normalizedExponent(significand, exponent); |
| // estimated_power might be too low by 1. |
| final int estimated_power = estimatePower(normalizedExponent); |
| |
| // Shortcut for Fixed. |
| // The requested digits correspond to the digits after the point. If the |
| // number is much too small, then there is no need in trying to get any |
| // digits. |
| if (mode == DtoaMode.FIXED && -estimated_power - 1 > requested_digits) { |
| buffer.reset(); |
| // Set decimal-point to -requested_digits. This is what Gay does. |
| // Note that it should not have any effect anyways since the string is |
| // empty. |
| buffer.decimalPoint = -requested_digits; |
| return; |
| } |
| |
| final Bignum numerator = new Bignum(); |
| final Bignum denominator = new Bignum(); |
| final Bignum delta_minus = new Bignum(); |
| final Bignum delta_plus = new Bignum(); |
| // Make sure the bignum can grow large enough. The smallest double equals |
| // 4e-324. In this case the denominator needs fewer than 324*4 binary digits. |
| // The maximum double is 1.7976931348623157e308 which needs fewer than |
| // 308*4 binary digits. |
| assert (Bignum.kMaxSignificantBits >= 324*4); |
| initialScaledStartValues(significand, exponent, lower_boundary_is_closer, |
| estimated_power, need_boundary_deltas, |
| numerator, denominator, |
| delta_minus, delta_plus); |
| // We now have v = (numerator / denominator) * 10^estimated_power. |
| buffer.decimalPoint = fixupMultiply10(estimated_power, is_even, |
| numerator, denominator, |
| delta_minus, delta_plus); |
| // We now have v = (numerator / denominator) * 10^(decimal_point-1), and |
| // 1 <= (numerator + delta_plus) / denominator < 10 |
| switch (mode) { |
| case SHORTEST: |
| generateShortestDigits(numerator, denominator, |
| delta_minus, delta_plus, |
| is_even, buffer); |
| break; |
| case FIXED: |
| bignumToFixed(requested_digits, |
| numerator, denominator, |
| buffer); |
| break; |
| case PRECISION: |
| generateCountedDigits(requested_digits, |
| numerator, denominator, |
| buffer); |
| break; |
| default: |
| throw new RuntimeException(); |
| } |
| } |
| |
| |
| // The procedure starts generating digits from the left to the right and stops |
| // when the generated digits yield the shortest decimal representation of v. A |
| // decimal representation of v is a number lying closer to v than to any other |
| // double, so it converts to v when read. |
| // |
| // This is true if d, the decimal representation, is between m- and m+, the |
| // upper and lower boundaries. d must be strictly between them if !is_even. |
| // m- := (numerator - delta_minus) / denominator |
| // m+ := (numerator + delta_plus) / denominator |
| // |
| // Precondition: 0 <= (numerator+delta_plus) / denominator < 10. |
| // If 1 <= (numerator+delta_plus) / denominator < 10 then no leading 0 digit |
| // will be produced. This should be the standard precondition. |
| static void generateShortestDigits(final Bignum numerator, final Bignum denominator, |
| final Bignum delta_minus, Bignum delta_plus, |
| final boolean is_even, |
| final DtoaBuffer buffer) { |
| // Small optimization: if delta_minus and delta_plus are the same just reuse |
| // one of the two bignums. |
| if (Bignum.equal(delta_minus, delta_plus)) { |
| delta_plus = delta_minus; |
| } |
| for (;;) { |
| final char digit; |
| digit = numerator.divideModuloIntBignum(denominator); |
| assert (digit <= 9); // digit is a uint16_t and therefore always positive. |
| // digit = numerator / denominator (integer division). |
| // numerator = numerator % denominator. |
| buffer.append((char) (digit + '0')); |
| |
| // Can we stop already? |
| // If the remainder of the division is less than the distance to the lower |
| // boundary we can stop. In this case we simply round down (discarding the |
| // remainder). |
| // Similarly we test if we can round up (using the upper boundary). |
| final boolean in_delta_room_minus; |
| final boolean in_delta_room_plus; |
| if (is_even) { |
| in_delta_room_minus = Bignum.lessEqual(numerator, delta_minus); |
| } else { |
| in_delta_room_minus = Bignum.less(numerator, delta_minus); |
| } |
| if (is_even) { |
| in_delta_room_plus = |
| Bignum.plusCompare(numerator, delta_plus, denominator) >= 0; |
| } else { |
| in_delta_room_plus = |
| Bignum.plusCompare(numerator, delta_plus, denominator) > 0; |
| } |
| if (!in_delta_room_minus && !in_delta_room_plus) { |
| // Prepare for next iteration. |
| numerator.times10(); |
| delta_minus.times10(); |
| // We optimized delta_plus to be equal to delta_minus (if they share the |
| // same value). So don't multiply delta_plus if they point to the same |
| // object. |
| if (delta_minus != delta_plus) { |
| delta_plus.times10(); |
| } |
| } else if (in_delta_room_minus && in_delta_room_plus) { |
| // Let's see if 2*numerator < denominator. |
| // If yes, then the next digit would be < 5 and we can round down. |
| final int compare = Bignum.plusCompare(numerator, numerator, denominator); |
| if (compare < 0) { |
| // Remaining digits are less than .5. -> Round down (== do nothing). |
| } else if (compare > 0) { |
| // Remaining digits are more than .5 of denominator. -> Round up. |
| // Note that the last digit could not be a '9' as otherwise the whole |
| // loop would have stopped earlier. |
| // We still have an assert here in case the preconditions were not |
| // satisfied. |
| assert (buffer.chars[buffer.length - 1] != '9'); |
| buffer.chars[buffer.length - 1]++; |
| } else { |
| // Halfway case. |
| // TODO(floitsch): need a way to solve half-way cases. |
| // For now let's round towards even (since this is what Gay seems to |
| // do). |
| |
| if ((buffer.chars[buffer.length - 1] - '0') % 2 == 0) { |
| // Round down => Do nothing. |
| } else { |
| assert (buffer.chars[buffer.length - 1] != '9'); |
| buffer.chars[buffer.length - 1]++; |
| } |
| } |
| return; |
| } else if (in_delta_room_minus) { |
| // Round down (== do nothing). |
| return; |
| } else { // in_delta_room_plus |
| // Round up. |
| // Note again that the last digit could not be '9' since this would have |
| // stopped the loop earlier. |
| // We still have an ASSERT here, in case the preconditions were not |
| // satisfied. |
| assert (buffer.chars[buffer.length -1] != '9'); |
| buffer.chars[buffer.length - 1]++; |
| return; |
| } |
| } |
| } |
| |
| |
| // Let v = numerator / denominator < 10. |
| // Then we generate 'count' digits of d = x.xxxxx... (without the decimal point) |
| // from left to right. Once 'count' digits have been produced we decide wether |
| // to round up or down. Remainders of exactly .5 round upwards. Numbers such |
| // as 9.999999 propagate a carry all the way, and change the |
| // exponent (decimal_point), when rounding upwards. |
| static void generateCountedDigits(final int count, |
| final Bignum numerator, final Bignum denominator, |
| final DtoaBuffer buffer) { |
| assert (count >= 0); |
| for (int i = 0; i < count - 1; ++i) { |
| final char digit; |
| digit = numerator.divideModuloIntBignum(denominator); |
| assert (digit <= 9); // digit is a uint16_t and therefore always positive. |
| // digit = numerator / denominator (integer division). |
| // numerator = numerator % denominator. |
| buffer.chars[i] = (char)(digit + '0'); |
| // Prepare for next iteration. |
| numerator.times10(); |
| } |
| // Generate the last digit. |
| char digit; |
| digit = numerator.divideModuloIntBignum(denominator); |
| if (Bignum.plusCompare(numerator, numerator, denominator) >= 0) { |
| digit++; |
| } |
| assert (digit <= 10); |
| buffer.chars[count - 1] = (char) (digit + '0'); |
| // Correct bad digits (in case we had a sequence of '9's). Propagate the |
| // carry until we hat a non-'9' or til we reach the first digit. |
| for (int i = count - 1; i > 0; --i) { |
| if (buffer.chars[i] != '0' + 10) break; |
| buffer.chars[i] = '0'; |
| buffer.chars[i - 1]++; |
| } |
| if (buffer.chars[0] == '0' + 10) { |
| // Propagate a carry past the top place. |
| buffer.chars[0] = '1'; |
| buffer.decimalPoint++; |
| } |
| buffer.length = count; |
| } |
| |
| |
| // Generates 'requested_digits' after the decimal point. It might omit |
| // trailing '0's. If the input number is too small then no digits at all are |
| // generated (ex.: 2 fixed digits for 0.00001). |
| // |
| // Input verifies: 1 <= (numerator + delta) / denominator < 10. |
| static void bignumToFixed(final int requested_digits, |
| final Bignum numerator, final Bignum denominator, |
| final DtoaBuffer buffer) { |
| // Note that we have to look at more than just the requested_digits, since |
| // a number could be rounded up. Example: v=0.5 with requested_digits=0. |
| // Even though the power of v equals 0 we can't just stop here. |
| if (-buffer.decimalPoint > requested_digits) { |
| // The number is definitively too small. |
| // Ex: 0.001 with requested_digits == 1. |
| // Set decimal-decimalPoint to -requested_digits. This is what Gay does. |
| // Note that it should not have any effect anyways since the string is |
| // empty. |
| buffer.decimalPoint = -requested_digits; |
| buffer.length = 0; |
| // return; |
| } else if (-buffer.decimalPoint == requested_digits) { |
| // We only need to verify if the number rounds down or up. |
| // Ex: 0.04 and 0.06 with requested_digits == 1. |
| assert (buffer.decimalPoint == -requested_digits); |
| // Initially the fraction lies in range (1, 10]. Multiply the denominator |
| // by 10 so that we can compare more easily. |
| denominator.times10(); |
| if (Bignum.plusCompare(numerator, numerator, denominator) >= 0) { |
| // If the fraction is >= 0.5 then we have to include the rounded |
| // digit. |
| buffer.chars[0] = '1'; |
| buffer.length = 1; |
| buffer.decimalPoint++; |
| } else { |
| // Note that we caught most of similar cases earlier. |
| buffer.length = 0; |
| } |
| // return; |
| } else { |
| // The requested digits correspond to the digits after the point. |
| // The variable 'needed_digits' includes the digits before the point. |
| final int needed_digits = buffer.decimalPoint + requested_digits; |
| generateCountedDigits(needed_digits, |
| numerator, denominator, |
| buffer); |
| } |
| } |
| |
| |
| // Returns an estimation of k such that 10^(k-1) <= v < 10^k where |
| // v = f * 2^exponent and 2^52 <= f < 2^53. |
| // v is hence a normalized double with the given exponent. The output is an |
| // approximation for the exponent of the decimal approimation .digits * 10^k. |
| // |
| // The result might undershoot by 1 in which case 10^k <= v < 10^k+1. |
| // Note: this property holds for v's upper boundary m+ too. |
| // 10^k <= m+ < 10^k+1. |
| // (see explanation below). |
| // |
| // Examples: |
| // EstimatePower(0) => 16 |
| // EstimatePower(-52) => 0 |
| // |
| // Note: e >= 0 => EstimatedPower(e) > 0. No similar claim can be made for e<0. |
| static int estimatePower(final int exponent) { |
| // This function estimates log10 of v where v = f*2^e (with e == exponent). |
| // Note that 10^floor(log10(v)) <= v, but v <= 10^ceil(log10(v)). |
| // Note that f is bounded by its container size. Let p = 53 (the double's |
| // significand size). Then 2^(p-1) <= f < 2^p. |
| // |
| // Given that log10(v) == log2(v)/log2(10) and e+(len(f)-1) is quite close |
| // to log2(v) the function is simplified to (e+(len(f)-1)/log2(10)). |
| // The computed number undershoots by less than 0.631 (when we compute log3 |
| // and not log10). |
| // |
| // Optimization: since we only need an approximated result this computation |
| // can be performed on 64 bit integers. On x86/x64 architecture the speedup is |
| // not really measurable, though. |
| // |
| // Since we want to avoid overshooting we decrement by 1e10 so that |
| // floating-point imprecisions don't affect us. |
| // |
| // Explanation for v's boundary m+: the computation takes advantage of |
| // the fact that 2^(p-1) <= f < 2^p. Boundaries still satisfy this requirement |
| // (even for denormals where the delta can be much more important). |
| |
| final double k1Log10 = 0.30102999566398114; // 1/lg(10) |
| |
| // For doubles len(f) == 53 (don't forget the hidden bit). |
| final int kSignificandSize = IeeeDouble.kSignificandSize; |
| final double estimate = Math.ceil((exponent + kSignificandSize - 1) * k1Log10 - 1e-10); |
| return (int) estimate; |
| } |
| |
| |
| // See comments for InitialScaledStartValues. |
| static void initialScaledStartValuesPositiveExponent( |
| final long significand, final int exponent, |
| final int estimated_power, final boolean need_boundary_deltas, |
| final Bignum numerator, final Bignum denominator, |
| final Bignum delta_minus, final Bignum delta_plus) { |
| // A positive exponent implies a positive power. |
| assert (estimated_power >= 0); |
| // Since the estimated_power is positive we simply multiply the denominator |
| // by 10^estimated_power. |
| |
| // numerator = v. |
| numerator.assignUInt64(significand); |
| numerator.shiftLeft(exponent); |
| // denominator = 10^estimated_power. |
| denominator.assignPowerUInt16(10, estimated_power); |
| |
| if (need_boundary_deltas) { |
| // Introduce a common denominator so that the deltas to the boundaries are |
| // integers. |
| denominator.shiftLeft(1); |
| numerator.shiftLeft(1); |
| // Let v = f * 2^e, then m+ - v = 1/2 * 2^e; With the common |
| // denominator (of 2) delta_plus equals 2^e. |
| delta_plus.assignUInt16((char) 1); |
| delta_plus.shiftLeft(exponent); |
| // Same for delta_minus. The adjustments if f == 2^p-1 are done later. |
| delta_minus.assignUInt16((char) 1); |
| delta_minus.shiftLeft(exponent); |
| } |
| } |
| |
| |
| // See comments for InitialScaledStartValues |
| static void initialScaledStartValuesNegativeExponentPositivePower( |
| final long significand, final int exponent, |
| final int estimated_power, final boolean need_boundary_deltas, |
| final Bignum numerator, final Bignum denominator, |
| final Bignum delta_minus, final Bignum delta_plus) { |
| // v = f * 2^e with e < 0, and with estimated_power >= 0. |
| // This means that e is close to 0 (have a look at how estimated_power is |
| // computed). |
| |
| // numerator = significand |
| // since v = significand * 2^exponent this is equivalent to |
| // numerator = v * / 2^-exponent |
| numerator.assignUInt64(significand); |
| // denominator = 10^estimated_power * 2^-exponent (with exponent < 0) |
| denominator.assignPowerUInt16(10, estimated_power); |
| denominator.shiftLeft(-exponent); |
| |
| if (need_boundary_deltas) { |
| // Introduce a common denominator so that the deltas to the boundaries are |
| // integers. |
| denominator.shiftLeft(1); |
| numerator.shiftLeft(1); |
| // Let v = f * 2^e, then m+ - v = 1/2 * 2^e; With the common |
| // denominator (of 2) delta_plus equals 2^e. |
| // Given that the denominator already includes v's exponent the distance |
| // to the boundaries is simply 1. |
| delta_plus.assignUInt16((char) 1); |
| // Same for delta_minus. The adjustments if f == 2^p-1 are done later. |
| delta_minus.assignUInt16((char) 1); |
| } |
| } |
| |
| |
| // See comments for InitialScaledStartValues |
| static void initialScaledStartValuesNegativeExponentNegativePower( |
| final long significand, final int exponent, |
| final int estimated_power, final boolean need_boundary_deltas, |
| final Bignum numerator, final Bignum denominator, |
| final Bignum delta_minus, final Bignum delta_plus) { |
| // Instead of multiplying the denominator with 10^estimated_power we |
| // multiply all values (numerator and deltas) by 10^-estimated_power. |
| |
| // Use numerator as temporary container for power_ten. |
| final Bignum power_ten = numerator; |
| power_ten.assignPowerUInt16(10, -estimated_power); |
| |
| if (need_boundary_deltas) { |
| // Since power_ten == numerator we must make a copy of 10^estimated_power |
| // before we complete the computation of the numerator. |
| // delta_plus = delta_minus = 10^estimated_power |
| delta_plus.assignBignum(power_ten); |
| delta_minus.assignBignum(power_ten); |
| } |
| |
| // numerator = significand * 2 * 10^-estimated_power |
| // since v = significand * 2^exponent this is equivalent to |
| // numerator = v * 10^-estimated_power * 2 * 2^-exponent. |
| // Remember: numerator has been abused as power_ten. So no need to assign it |
| // to itself. |
| assert (numerator == power_ten); |
| numerator.multiplyByUInt64(significand); |
| |
| // denominator = 2 * 2^-exponent with exponent < 0. |
| denominator.assignUInt16((char) 1); |
| denominator.shiftLeft(-exponent); |
| |
| if (need_boundary_deltas) { |
| // Introduce a common denominator so that the deltas to the boundaries are |
| // integers. |
| numerator.shiftLeft(1); |
| denominator.shiftLeft(1); |
| // With this shift the boundaries have their correct value, since |
| // delta_plus = 10^-estimated_power, and |
| // delta_minus = 10^-estimated_power. |
| // These assignments have been done earlier. |
| // The adjustments if f == 2^p-1 (lower boundary is closer) are done later. |
| } |
| } |
| |
| |
| // Let v = significand * 2^exponent. |
| // Computes v / 10^estimated_power exactly, as a ratio of two bignums, numerator |
| // and denominator. The functions GenerateShortestDigits and |
| // GenerateCountedDigits will then convert this ratio to its decimal |
| // representation d, with the required accuracy. |
| // Then d * 10^estimated_power is the representation of v. |
| // (Note: the fraction and the estimated_power might get adjusted before |
| // generating the decimal representation.) |
| // |
| // The initial start values consist of: |
| // - a scaled numerator: s.t. numerator/denominator == v / 10^estimated_power. |
| // - a scaled (common) denominator. |
| // optionally (used by GenerateShortestDigits to decide if it has the shortest |
| // decimal converting back to v): |
| // - v - m-: the distance to the lower boundary. |
| // - m+ - v: the distance to the upper boundary. |
| // |
| // v, m+, m-, and therefore v - m- and m+ - v all share the same denominator. |
| // |
| // Let ep == estimated_power, then the returned values will satisfy: |
| // v / 10^ep = numerator / denominator. |
| // v's boundarys m- and m+: |
| // m- / 10^ep == v / 10^ep - delta_minus / denominator |
| // m+ / 10^ep == v / 10^ep + delta_plus / denominator |
| // Or in other words: |
| // m- == v - delta_minus * 10^ep / denominator; |
| // m+ == v + delta_plus * 10^ep / denominator; |
| // |
| // Since 10^(k-1) <= v < 10^k (with k == estimated_power) |
| // or 10^k <= v < 10^(k+1) |
| // we then have 0.1 <= numerator/denominator < 1 |
| // or 1 <= numerator/denominator < 10 |
| // |
| // It is then easy to kickstart the digit-generation routine. |
| // |
| // The boundary-deltas are only filled if the mode equals BIGNUM_DTOA_SHORTEST |
| // or BIGNUM_DTOA_SHORTEST_SINGLE. |
| |
| static void initialScaledStartValues(final long significand, |
| final int exponent, |
| final boolean lower_boundary_is_closer, |
| final int estimated_power, |
| final boolean need_boundary_deltas, |
| final Bignum numerator, |
| final Bignum denominator, |
| final Bignum delta_minus, |
| final Bignum delta_plus) { |
| if (exponent >= 0) { |
| initialScaledStartValuesPositiveExponent( |
| significand, exponent, estimated_power, need_boundary_deltas, |
| numerator, denominator, delta_minus, delta_plus); |
| } else if (estimated_power >= 0) { |
| initialScaledStartValuesNegativeExponentPositivePower( |
| significand, exponent, estimated_power, need_boundary_deltas, |
| numerator, denominator, delta_minus, delta_plus); |
| } else { |
| initialScaledStartValuesNegativeExponentNegativePower( |
| significand, exponent, estimated_power, need_boundary_deltas, |
| numerator, denominator, delta_minus, delta_plus); |
| } |
| |
| if (need_boundary_deltas && lower_boundary_is_closer) { |
| // The lower boundary is closer at half the distance of "normal" numbers. |
| // Increase the common denominator and adapt all but the delta_minus. |
| denominator.shiftLeft(1); // *2 |
| numerator.shiftLeft(1); // *2 |
| delta_plus.shiftLeft(1); // *2 |
| } |
| } |
| |
| |
| // This routine multiplies numerator/denominator so that its values lies in the |
| // range 1-10. That is after a call to this function we have: |
| // 1 <= (numerator + delta_plus) /denominator < 10. |
| // Let numerator the input before modification and numerator' the argument |
| // after modification, then the output-parameter decimal_point is such that |
| // numerator / denominator * 10^estimated_power == |
| // numerator' / denominator' * 10^(decimal_point - 1) |
| // In some cases estimated_power was too low, and this is already the case. We |
| // then simply adjust the power so that 10^(k-1) <= v < 10^k (with k == |
| // estimated_power) but do not touch the numerator or denominator. |
| // Otherwise the routine multiplies the numerator and the deltas by 10. |
| static int fixupMultiply10(final int estimated_power, final boolean is_even, |
| final Bignum numerator, final Bignum denominator, |
| final Bignum delta_minus, final Bignum delta_plus) { |
| final boolean in_range; |
| final int decimal_point; |
| if (is_even) { |
| // For IEEE doubles half-way cases (in decimal system numbers ending with 5) |
| // are rounded to the closest floating-point number with even significand. |
| in_range = Bignum.plusCompare(numerator, delta_plus, denominator) >= 0; |
| } else { |
| in_range = Bignum.plusCompare(numerator, delta_plus, denominator) > 0; |
| } |
| if (in_range) { |
| // Since numerator + delta_plus >= denominator we already have |
| // 1 <= numerator/denominator < 10. Simply update the estimated_power. |
| decimal_point = estimated_power + 1; |
| } else { |
| decimal_point = estimated_power; |
| numerator.times10(); |
| if (Bignum.equal(delta_minus, delta_plus)) { |
| delta_minus.times10(); |
| delta_plus.assignBignum(delta_minus); |
| } else { |
| delta_minus.times10(); |
| delta_plus.times10(); |
| } |
| } |
| return decimal_point; |
| } |
| |
| |
| } |