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