Line data Source code
1 : // Copyright 2010 the V8 project authors. All rights reserved.
2 : // Redistribution and use in source and binary forms, with or without
3 : // modification, are permitted provided that the following conditions are
4 : // met:
5 : //
6 : // * Redistributions of source code must retain the above copyright
7 : // notice, this list of conditions and the following disclaimer.
8 : // * Redistributions in binary form must reproduce the above
9 : // copyright notice, this list of conditions and the following
10 : // disclaimer in the documentation and/or other materials provided
11 : // with the distribution.
12 : // * Neither the name of Google Inc. nor the names of its
13 : // contributors may be used to endorse or promote products derived
14 : // from this software without specific prior written permission.
15 : //
16 : // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17 : // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18 : // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19 : // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20 : // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21 : // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22 : // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 : // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 : // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 : // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26 : // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 :
28 : #include <math.h>
29 :
30 : #include "bignum-dtoa.h"
31 :
32 : #include "bignum.h"
33 : #include "ieee.h"
34 :
35 : namespace double_conversion {
36 :
37 0 : static int NormalizedExponent(uint64_t significand, int exponent) {
38 0 : ASSERT(significand != 0);
39 0 : while ((significand & Double::kHiddenBit) == 0) {
40 0 : significand = significand << 1;
41 0 : exponent = exponent - 1;
42 : }
43 0 : return exponent;
44 : }
45 :
46 :
47 : // Forward declarations:
48 : // Returns an estimation of k such that 10^(k-1) <= v < 10^k.
49 : static int EstimatePower(int exponent);
50 : // Computes v / 10^estimated_power exactly, as a ratio of two bignums, numerator
51 : // and denominator.
52 : static void InitialScaledStartValues(uint64_t significand,
53 : int exponent,
54 : bool lower_boundary_is_closer,
55 : int estimated_power,
56 : bool need_boundary_deltas,
57 : Bignum* numerator,
58 : Bignum* denominator,
59 : Bignum* delta_minus,
60 : Bignum* delta_plus);
61 : // Multiplies numerator/denominator so that its values lies in the range 1-10.
62 : // Returns decimal_point s.t.
63 : // v = numerator'/denominator' * 10^(decimal_point-1)
64 : // where numerator' and denominator' are the values of numerator and
65 : // denominator after the call to this function.
66 : static void FixupMultiply10(int estimated_power, bool is_even,
67 : int* decimal_point,
68 : Bignum* numerator, Bignum* denominator,
69 : Bignum* delta_minus, Bignum* delta_plus);
70 : // Generates digits from the left to the right and stops when the generated
71 : // digits yield the shortest decimal representation of v.
72 : static void GenerateShortestDigits(Bignum* numerator, Bignum* denominator,
73 : Bignum* delta_minus, Bignum* delta_plus,
74 : bool is_even,
75 : Vector<char> buffer, int* length);
76 : // Generates 'requested_digits' after the decimal point.
77 : static void BignumToFixed(int requested_digits, int* decimal_point,
78 : Bignum* numerator, Bignum* denominator,
79 : Vector<char>(buffer), int* length);
80 : // Generates 'count' digits of numerator/denominator.
81 : // Once 'count' digits have been produced rounds the result depending on the
82 : // remainder (remainders of exactly .5 round upwards). Might update the
83 : // decimal_point when rounding up (for example for 0.9999).
84 : static void GenerateCountedDigits(int count, int* decimal_point,
85 : Bignum* numerator, Bignum* denominator,
86 : Vector<char>(buffer), int* length);
87 :
88 :
89 0 : void BignumDtoa(double v, BignumDtoaMode mode, int requested_digits,
90 : Vector<char> buffer, int* length, int* decimal_point) {
91 0 : ASSERT(v > 0);
92 0 : ASSERT(!Double(v).IsSpecial());
93 : uint64_t significand;
94 : int exponent;
95 : bool lower_boundary_is_closer;
96 0 : if (mode == BIGNUM_DTOA_SHORTEST_SINGLE) {
97 0 : float f = static_cast<float>(v);
98 0 : ASSERT(f == v);
99 0 : significand = Single(f).Significand();
100 0 : exponent = Single(f).Exponent();
101 0 : lower_boundary_is_closer = Single(f).LowerBoundaryIsCloser();
102 : } else {
103 0 : significand = Double(v).Significand();
104 0 : exponent = Double(v).Exponent();
105 0 : lower_boundary_is_closer = Double(v).LowerBoundaryIsCloser();
106 : }
107 : bool need_boundary_deltas =
108 0 : (mode == BIGNUM_DTOA_SHORTEST || mode == BIGNUM_DTOA_SHORTEST_SINGLE);
109 :
110 0 : bool is_even = (significand & 1) == 0;
111 0 : int normalized_exponent = NormalizedExponent(significand, exponent);
112 : // estimated_power might be too low by 1.
113 0 : int estimated_power = EstimatePower(normalized_exponent);
114 :
115 : // Shortcut for Fixed.
116 : // The requested digits correspond to the digits after the point. If the
117 : // number is much too small, then there is no need in trying to get any
118 : // digits.
119 0 : if (mode == BIGNUM_DTOA_FIXED && -estimated_power - 1 > requested_digits) {
120 0 : buffer[0] = '\0';
121 0 : *length = 0;
122 : // Set decimal-point to -requested_digits. This is what Gay does.
123 : // Note that it should not have any effect anyways since the string is
124 : // empty.
125 0 : *decimal_point = -requested_digits;
126 0 : return;
127 : }
128 :
129 0 : Bignum numerator;
130 0 : Bignum denominator;
131 0 : Bignum delta_minus;
132 0 : Bignum delta_plus;
133 : // Make sure the bignum can grow large enough. The smallest double equals
134 : // 4e-324. In this case the denominator needs fewer than 324*4 binary digits.
135 : // The maximum double is 1.7976931348623157e308 which needs fewer than
136 : // 308*4 binary digits.
137 : ASSERT(Bignum::kMaxSignificantBits >= 324*4);
138 0 : InitialScaledStartValues(significand, exponent, lower_boundary_is_closer,
139 : estimated_power, need_boundary_deltas,
140 : &numerator, &denominator,
141 0 : &delta_minus, &delta_plus);
142 : // We now have v = (numerator / denominator) * 10^estimated_power.
143 0 : FixupMultiply10(estimated_power, is_even, decimal_point,
144 : &numerator, &denominator,
145 0 : &delta_minus, &delta_plus);
146 : // We now have v = (numerator / denominator) * 10^(decimal_point-1), and
147 : // 1 <= (numerator + delta_plus) / denominator < 10
148 0 : switch (mode) {
149 : case BIGNUM_DTOA_SHORTEST:
150 : case BIGNUM_DTOA_SHORTEST_SINGLE:
151 0 : GenerateShortestDigits(&numerator, &denominator,
152 : &delta_minus, &delta_plus,
153 0 : is_even, buffer, length);
154 0 : break;
155 : case BIGNUM_DTOA_FIXED:
156 : BignumToFixed(requested_digits, decimal_point,
157 : &numerator, &denominator,
158 0 : buffer, length);
159 0 : break;
160 : case BIGNUM_DTOA_PRECISION:
161 : GenerateCountedDigits(requested_digits, decimal_point,
162 : &numerator, &denominator,
163 0 : buffer, length);
164 0 : break;
165 : default:
166 0 : UNREACHABLE();
167 : }
168 0 : buffer[*length] = '\0';
169 : }
170 :
171 :
172 : // The procedure starts generating digits from the left to the right and stops
173 : // when the generated digits yield the shortest decimal representation of v. A
174 : // decimal representation of v is a number lying closer to v than to any other
175 : // double, so it converts to v when read.
176 : //
177 : // This is true if d, the decimal representation, is between m- and m+, the
178 : // upper and lower boundaries. d must be strictly between them if !is_even.
179 : // m- := (numerator - delta_minus) / denominator
180 : // m+ := (numerator + delta_plus) / denominator
181 : //
182 : // Precondition: 0 <= (numerator+delta_plus) / denominator < 10.
183 : // If 1 <= (numerator+delta_plus) / denominator < 10 then no leading 0 digit
184 : // will be produced. This should be the standard precondition.
185 0 : static void GenerateShortestDigits(Bignum* numerator, Bignum* denominator,
186 : Bignum* delta_minus, Bignum* delta_plus,
187 : bool is_even,
188 : Vector<char> buffer, int* length) {
189 : // Small optimization: if delta_minus and delta_plus are the same just reuse
190 : // one of the two bignums.
191 0 : if (Bignum::Equal(*delta_minus, *delta_plus)) {
192 0 : delta_plus = delta_minus;
193 : }
194 0 : *length = 0;
195 : for (;;) {
196 : uint16_t digit;
197 0 : digit = numerator->DivideModuloIntBignum(*denominator);
198 0 : ASSERT(digit <= 9); // digit is a uint16_t and therefore always positive.
199 : // digit = numerator / denominator (integer division).
200 : // numerator = numerator % denominator.
201 0 : buffer[(*length)++] = static_cast<char>(digit + '0');
202 :
203 : // Can we stop already?
204 : // If the remainder of the division is less than the distance to the lower
205 : // boundary we can stop. In this case we simply round down (discarding the
206 : // remainder).
207 : // Similarly we test if we can round up (using the upper boundary).
208 : bool in_delta_room_minus;
209 : bool in_delta_room_plus;
210 0 : if (is_even) {
211 0 : in_delta_room_minus = Bignum::LessEqual(*numerator, *delta_minus);
212 : } else {
213 0 : in_delta_room_minus = Bignum::Less(*numerator, *delta_minus);
214 : }
215 0 : if (is_even) {
216 0 : in_delta_room_plus =
217 0 : Bignum::PlusCompare(*numerator, *delta_plus, *denominator) >= 0;
218 : } else {
219 0 : in_delta_room_plus =
220 0 : Bignum::PlusCompare(*numerator, *delta_plus, *denominator) > 0;
221 : }
222 0 : if (!in_delta_room_minus && !in_delta_room_plus) {
223 : // Prepare for next iteration.
224 0 : numerator->Times10();
225 0 : delta_minus->Times10();
226 : // We optimized delta_plus to be equal to delta_minus (if they share the
227 : // same value). So don't multiply delta_plus if they point to the same
228 : // object.
229 0 : if (delta_minus != delta_plus) {
230 0 : delta_plus->Times10();
231 : }
232 0 : } else if (in_delta_room_minus && in_delta_room_plus) {
233 : // Let's see if 2*numerator < denominator.
234 : // If yes, then the next digit would be < 5 and we can round down.
235 0 : int compare = Bignum::PlusCompare(*numerator, *numerator, *denominator);
236 0 : if (compare < 0) {
237 : // Remaining digits are less than .5. -> Round down (== do nothing).
238 0 : } else if (compare > 0) {
239 : // Remaining digits are more than .5 of denominator. -> Round up.
240 : // Note that the last digit could not be a '9' as otherwise the whole
241 : // loop would have stopped earlier.
242 : // We still have an assert here in case the preconditions were not
243 : // satisfied.
244 0 : ASSERT(buffer[(*length) - 1] != '9');
245 0 : buffer[(*length) - 1]++;
246 : } else {
247 : // Halfway case.
248 : // TODO(floitsch): need a way to solve half-way cases.
249 : // For now let's round towards even (since this is what Gay seems to
250 : // do).
251 :
252 0 : if ((buffer[(*length) - 1] - '0') % 2 == 0) {
253 : // Round down => Do nothing.
254 : } else {
255 0 : ASSERT(buffer[(*length) - 1] != '9');
256 0 : buffer[(*length) - 1]++;
257 : }
258 : }
259 0 : return;
260 0 : } else if (in_delta_room_minus) {
261 : // Round down (== do nothing).
262 0 : return;
263 : } else { // in_delta_room_plus
264 : // Round up.
265 : // Note again that the last digit could not be '9' since this would have
266 : // stopped the loop earlier.
267 : // We still have an ASSERT here, in case the preconditions were not
268 : // satisfied.
269 0 : ASSERT(buffer[(*length) -1] != '9');
270 0 : buffer[(*length) - 1]++;
271 0 : return;
272 : }
273 0 : }
274 : }
275 :
276 :
277 : // Let v = numerator / denominator < 10.
278 : // Then we generate 'count' digits of d = x.xxxxx... (without the decimal point)
279 : // from left to right. Once 'count' digits have been produced we decide wether
280 : // to round up or down. Remainders of exactly .5 round upwards. Numbers such
281 : // as 9.999999 propagate a carry all the way, and change the
282 : // exponent (decimal_point), when rounding upwards.
283 0 : static void GenerateCountedDigits(int count, int* decimal_point,
284 : Bignum* numerator, Bignum* denominator,
285 : Vector<char> buffer, int* length) {
286 0 : ASSERT(count >= 0);
287 0 : for (int i = 0; i < count - 1; ++i) {
288 : uint16_t digit;
289 0 : digit = numerator->DivideModuloIntBignum(*denominator);
290 0 : ASSERT(digit <= 9); // digit is a uint16_t and therefore always positive.
291 : // digit = numerator / denominator (integer division).
292 : // numerator = numerator % denominator.
293 0 : buffer[i] = static_cast<char>(digit + '0');
294 : // Prepare for next iteration.
295 0 : numerator->Times10();
296 : }
297 : // Generate the last digit.
298 : uint16_t digit;
299 0 : digit = numerator->DivideModuloIntBignum(*denominator);
300 0 : if (Bignum::PlusCompare(*numerator, *numerator, *denominator) >= 0) {
301 0 : digit++;
302 : }
303 0 : ASSERT(digit <= 10);
304 0 : buffer[count - 1] = static_cast<char>(digit + '0');
305 : // Correct bad digits (in case we had a sequence of '9's). Propagate the
306 : // carry until we hat a non-'9' or til we reach the first digit.
307 0 : for (int i = count - 1; i > 0; --i) {
308 0 : if (buffer[i] != '0' + 10) break;
309 0 : buffer[i] = '0';
310 0 : buffer[i - 1]++;
311 : }
312 0 : if (buffer[0] == '0' + 10) {
313 : // Propagate a carry past the top place.
314 0 : buffer[0] = '1';
315 0 : (*decimal_point)++;
316 : }
317 0 : *length = count;
318 0 : }
319 :
320 :
321 : // Generates 'requested_digits' after the decimal point. It might omit
322 : // trailing '0's. If the input number is too small then no digits at all are
323 : // generated (ex.: 2 fixed digits for 0.00001).
324 : //
325 : // Input verifies: 1 <= (numerator + delta) / denominator < 10.
326 0 : static void BignumToFixed(int requested_digits, int* decimal_point,
327 : Bignum* numerator, Bignum* denominator,
328 : Vector<char>(buffer), int* length) {
329 : // Note that we have to look at more than just the requested_digits, since
330 : // a number could be rounded up. Example: v=0.5 with requested_digits=0.
331 : // Even though the power of v equals 0 we can't just stop here.
332 0 : if (-(*decimal_point) > requested_digits) {
333 : // The number is definitively too small.
334 : // Ex: 0.001 with requested_digits == 1.
335 : // Set decimal-point to -requested_digits. This is what Gay does.
336 : // Note that it should not have any effect anyways since the string is
337 : // empty.
338 0 : *decimal_point = -requested_digits;
339 0 : *length = 0;
340 0 : return;
341 0 : } else if (-(*decimal_point) == requested_digits) {
342 : // We only need to verify if the number rounds down or up.
343 : // Ex: 0.04 and 0.06 with requested_digits == 1.
344 0 : ASSERT(*decimal_point == -requested_digits);
345 : // Initially the fraction lies in range (1, 10]. Multiply the denominator
346 : // by 10 so that we can compare more easily.
347 0 : denominator->Times10();
348 0 : if (Bignum::PlusCompare(*numerator, *numerator, *denominator) >= 0) {
349 : // If the fraction is >= 0.5 then we have to include the rounded
350 : // digit.
351 0 : buffer[0] = '1';
352 0 : *length = 1;
353 0 : (*decimal_point)++;
354 : } else {
355 : // Note that we caught most of similar cases earlier.
356 0 : *length = 0;
357 : }
358 0 : return;
359 : } else {
360 : // The requested digits correspond to the digits after the point.
361 : // The variable 'needed_digits' includes the digits before the point.
362 0 : int needed_digits = (*decimal_point) + requested_digits;
363 : GenerateCountedDigits(needed_digits, decimal_point,
364 : numerator, denominator,
365 0 : buffer, length);
366 : }
367 : }
368 :
369 :
370 : // Returns an estimation of k such that 10^(k-1) <= v < 10^k where
371 : // v = f * 2^exponent and 2^52 <= f < 2^53.
372 : // v is hence a normalized double with the given exponent. The output is an
373 : // approximation for the exponent of the decimal approimation .digits * 10^k.
374 : //
375 : // The result might undershoot by 1 in which case 10^k <= v < 10^k+1.
376 : // Note: this property holds for v's upper boundary m+ too.
377 : // 10^k <= m+ < 10^k+1.
378 : // (see explanation below).
379 : //
380 : // Examples:
381 : // EstimatePower(0) => 16
382 : // EstimatePower(-52) => 0
383 : //
384 : // Note: e >= 0 => EstimatedPower(e) > 0. No similar claim can be made for e<0.
385 0 : static int EstimatePower(int exponent) {
386 : // This function estimates log10 of v where v = f*2^e (with e == exponent).
387 : // Note that 10^floor(log10(v)) <= v, but v <= 10^ceil(log10(v)).
388 : // Note that f is bounded by its container size. Let p = 53 (the double's
389 : // significand size). Then 2^(p-1) <= f < 2^p.
390 : //
391 : // Given that log10(v) == log2(v)/log2(10) and e+(len(f)-1) is quite close
392 : // to log2(v) the function is simplified to (e+(len(f)-1)/log2(10)).
393 : // The computed number undershoots by less than 0.631 (when we compute log3
394 : // and not log10).
395 : //
396 : // Optimization: since we only need an approximated result this computation
397 : // can be performed on 64 bit integers. On x86/x64 architecture the speedup is
398 : // not really measurable, though.
399 : //
400 : // Since we want to avoid overshooting we decrement by 1e10 so that
401 : // floating-point imprecisions don't affect us.
402 : //
403 : // Explanation for v's boundary m+: the computation takes advantage of
404 : // the fact that 2^(p-1) <= f < 2^p. Boundaries still satisfy this requirement
405 : // (even for denormals where the delta can be much more important).
406 :
407 0 : const double k1Log10 = 0.30102999566398114; // 1/lg(10)
408 :
409 : // For doubles len(f) == 53 (don't forget the hidden bit).
410 0 : const int kSignificandSize = Double::kSignificandSize;
411 0 : double estimate = ceil((exponent + kSignificandSize - 1) * k1Log10 - 1e-10);
412 0 : return static_cast<int>(estimate);
413 : }
414 :
415 :
416 : // See comments for InitialScaledStartValues.
417 0 : static void InitialScaledStartValuesPositiveExponent(
418 : uint64_t significand, int exponent,
419 : int estimated_power, bool need_boundary_deltas,
420 : Bignum* numerator, Bignum* denominator,
421 : Bignum* delta_minus, Bignum* delta_plus) {
422 : // A positive exponent implies a positive power.
423 0 : ASSERT(estimated_power >= 0);
424 : // Since the estimated_power is positive we simply multiply the denominator
425 : // by 10^estimated_power.
426 :
427 : // numerator = v.
428 0 : numerator->AssignUInt64(significand);
429 0 : numerator->ShiftLeft(exponent);
430 : // denominator = 10^estimated_power.
431 0 : denominator->AssignPowerUInt16(10, estimated_power);
432 :
433 0 : if (need_boundary_deltas) {
434 : // Introduce a common denominator so that the deltas to the boundaries are
435 : // integers.
436 0 : denominator->ShiftLeft(1);
437 0 : numerator->ShiftLeft(1);
438 : // Let v = f * 2^e, then m+ - v = 1/2 * 2^e; With the common
439 : // denominator (of 2) delta_plus equals 2^e.
440 0 : delta_plus->AssignUInt16(1);
441 0 : delta_plus->ShiftLeft(exponent);
442 : // Same for delta_minus. The adjustments if f == 2^p-1 are done later.
443 0 : delta_minus->AssignUInt16(1);
444 0 : delta_minus->ShiftLeft(exponent);
445 : }
446 0 : }
447 :
448 :
449 : // See comments for InitialScaledStartValues
450 0 : static void InitialScaledStartValuesNegativeExponentPositivePower(
451 : uint64_t significand, int exponent,
452 : int estimated_power, bool need_boundary_deltas,
453 : Bignum* numerator, Bignum* denominator,
454 : Bignum* delta_minus, Bignum* delta_plus) {
455 : // v = f * 2^e with e < 0, and with estimated_power >= 0.
456 : // This means that e is close to 0 (have a look at how estimated_power is
457 : // computed).
458 :
459 : // numerator = significand
460 : // since v = significand * 2^exponent this is equivalent to
461 : // numerator = v * / 2^-exponent
462 0 : numerator->AssignUInt64(significand);
463 : // denominator = 10^estimated_power * 2^-exponent (with exponent < 0)
464 0 : denominator->AssignPowerUInt16(10, estimated_power);
465 0 : denominator->ShiftLeft(-exponent);
466 :
467 0 : if (need_boundary_deltas) {
468 : // Introduce a common denominator so that the deltas to the boundaries are
469 : // integers.
470 0 : denominator->ShiftLeft(1);
471 0 : numerator->ShiftLeft(1);
472 : // Let v = f * 2^e, then m+ - v = 1/2 * 2^e; With the common
473 : // denominator (of 2) delta_plus equals 2^e.
474 : // Given that the denominator already includes v's exponent the distance
475 : // to the boundaries is simply 1.
476 0 : delta_plus->AssignUInt16(1);
477 : // Same for delta_minus. The adjustments if f == 2^p-1 are done later.
478 0 : delta_minus->AssignUInt16(1);
479 : }
480 0 : }
481 :
482 :
483 : // See comments for InitialScaledStartValues
484 0 : static void InitialScaledStartValuesNegativeExponentNegativePower(
485 : uint64_t significand, int exponent,
486 : int estimated_power, bool need_boundary_deltas,
487 : Bignum* numerator, Bignum* denominator,
488 : Bignum* delta_minus, Bignum* delta_plus) {
489 : // Instead of multiplying the denominator with 10^estimated_power we
490 : // multiply all values (numerator and deltas) by 10^-estimated_power.
491 :
492 : // Use numerator as temporary container for power_ten.
493 0 : Bignum* power_ten = numerator;
494 0 : power_ten->AssignPowerUInt16(10, -estimated_power);
495 :
496 0 : if (need_boundary_deltas) {
497 : // Since power_ten == numerator we must make a copy of 10^estimated_power
498 : // before we complete the computation of the numerator.
499 : // delta_plus = delta_minus = 10^estimated_power
500 0 : delta_plus->AssignBignum(*power_ten);
501 0 : delta_minus->AssignBignum(*power_ten);
502 : }
503 :
504 : // numerator = significand * 2 * 10^-estimated_power
505 : // since v = significand * 2^exponent this is equivalent to
506 : // numerator = v * 10^-estimated_power * 2 * 2^-exponent.
507 : // Remember: numerator has been abused as power_ten. So no need to assign it
508 : // to itself.
509 0 : ASSERT(numerator == power_ten);
510 0 : numerator->MultiplyByUInt64(significand);
511 :
512 : // denominator = 2 * 2^-exponent with exponent < 0.
513 0 : denominator->AssignUInt16(1);
514 0 : denominator->ShiftLeft(-exponent);
515 :
516 0 : if (need_boundary_deltas) {
517 : // Introduce a common denominator so that the deltas to the boundaries are
518 : // integers.
519 0 : numerator->ShiftLeft(1);
520 0 : denominator->ShiftLeft(1);
521 : // With this shift the boundaries have their correct value, since
522 : // delta_plus = 10^-estimated_power, and
523 : // delta_minus = 10^-estimated_power.
524 : // These assignments have been done earlier.
525 : // The adjustments if f == 2^p-1 (lower boundary is closer) are done later.
526 : }
527 0 : }
528 :
529 :
530 : // Let v = significand * 2^exponent.
531 : // Computes v / 10^estimated_power exactly, as a ratio of two bignums, numerator
532 : // and denominator. The functions GenerateShortestDigits and
533 : // GenerateCountedDigits will then convert this ratio to its decimal
534 : // representation d, with the required accuracy.
535 : // Then d * 10^estimated_power is the representation of v.
536 : // (Note: the fraction and the estimated_power might get adjusted before
537 : // generating the decimal representation.)
538 : //
539 : // The initial start values consist of:
540 : // - a scaled numerator: s.t. numerator/denominator == v / 10^estimated_power.
541 : // - a scaled (common) denominator.
542 : // optionally (used by GenerateShortestDigits to decide if it has the shortest
543 : // decimal converting back to v):
544 : // - v - m-: the distance to the lower boundary.
545 : // - m+ - v: the distance to the upper boundary.
546 : //
547 : // v, m+, m-, and therefore v - m- and m+ - v all share the same denominator.
548 : //
549 : // Let ep == estimated_power, then the returned values will satisfy:
550 : // v / 10^ep = numerator / denominator.
551 : // v's boundarys m- and m+:
552 : // m- / 10^ep == v / 10^ep - delta_minus / denominator
553 : // m+ / 10^ep == v / 10^ep + delta_plus / denominator
554 : // Or in other words:
555 : // m- == v - delta_minus * 10^ep / denominator;
556 : // m+ == v + delta_plus * 10^ep / denominator;
557 : //
558 : // Since 10^(k-1) <= v < 10^k (with k == estimated_power)
559 : // or 10^k <= v < 10^(k+1)
560 : // we then have 0.1 <= numerator/denominator < 1
561 : // or 1 <= numerator/denominator < 10
562 : //
563 : // It is then easy to kickstart the digit-generation routine.
564 : //
565 : // The boundary-deltas are only filled if the mode equals BIGNUM_DTOA_SHORTEST
566 : // or BIGNUM_DTOA_SHORTEST_SINGLE.
567 :
568 0 : static void InitialScaledStartValues(uint64_t significand,
569 : int exponent,
570 : bool lower_boundary_is_closer,
571 : int estimated_power,
572 : bool need_boundary_deltas,
573 : Bignum* numerator,
574 : Bignum* denominator,
575 : Bignum* delta_minus,
576 : Bignum* delta_plus) {
577 0 : if (exponent >= 0) {
578 0 : InitialScaledStartValuesPositiveExponent(
579 : significand, exponent, estimated_power, need_boundary_deltas,
580 0 : numerator, denominator, delta_minus, delta_plus);
581 0 : } else if (estimated_power >= 0) {
582 0 : InitialScaledStartValuesNegativeExponentPositivePower(
583 : significand, exponent, estimated_power, need_boundary_deltas,
584 0 : numerator, denominator, delta_minus, delta_plus);
585 : } else {
586 0 : InitialScaledStartValuesNegativeExponentNegativePower(
587 : significand, exponent, estimated_power, need_boundary_deltas,
588 0 : numerator, denominator, delta_minus, delta_plus);
589 : }
590 :
591 0 : if (need_boundary_deltas && lower_boundary_is_closer) {
592 : // The lower boundary is closer at half the distance of "normal" numbers.
593 : // Increase the common denominator and adapt all but the delta_minus.
594 0 : denominator->ShiftLeft(1); // *2
595 0 : numerator->ShiftLeft(1); // *2
596 0 : delta_plus->ShiftLeft(1); // *2
597 : }
598 0 : }
599 :
600 :
601 : // This routine multiplies numerator/denominator so that its values lies in the
602 : // range 1-10. That is after a call to this function we have:
603 : // 1 <= (numerator + delta_plus) /denominator < 10.
604 : // Let numerator the input before modification and numerator' the argument
605 : // after modification, then the output-parameter decimal_point is such that
606 : // numerator / denominator * 10^estimated_power ==
607 : // numerator' / denominator' * 10^(decimal_point - 1)
608 : // In some cases estimated_power was too low, and this is already the case. We
609 : // then simply adjust the power so that 10^(k-1) <= v < 10^k (with k ==
610 : // estimated_power) but do not touch the numerator or denominator.
611 : // Otherwise the routine multiplies the numerator and the deltas by 10.
612 0 : static void FixupMultiply10(int estimated_power, bool is_even,
613 : int* decimal_point,
614 : Bignum* numerator, Bignum* denominator,
615 : Bignum* delta_minus, Bignum* delta_plus) {
616 : bool in_range;
617 0 : if (is_even) {
618 : // For IEEE doubles half-way cases (in decimal system numbers ending with 5)
619 : // are rounded to the closest floating-point number with even significand.
620 0 : in_range = Bignum::PlusCompare(*numerator, *delta_plus, *denominator) >= 0;
621 : } else {
622 0 : in_range = Bignum::PlusCompare(*numerator, *delta_plus, *denominator) > 0;
623 : }
624 0 : if (in_range) {
625 : // Since numerator + delta_plus >= denominator we already have
626 : // 1 <= numerator/denominator < 10. Simply update the estimated_power.
627 0 : *decimal_point = estimated_power + 1;
628 : } else {
629 0 : *decimal_point = estimated_power;
630 0 : numerator->Times10();
631 0 : if (Bignum::Equal(*delta_minus, *delta_plus)) {
632 0 : delta_minus->Times10();
633 0 : delta_plus->AssignBignum(*delta_minus);
634 : } else {
635 0 : delta_minus->Times10();
636 0 : delta_plus->Times10();
637 : }
638 : }
639 0 : }
640 :
641 : } // namespace double_conversion
|
