FixedDecimal stores in d the first n significant digits of the decimal representation of f. It returns false if it cannot be sure of the answer.
(d *decimalSlice, n int)
| 376 | // of the decimal representation of f. It returns false |
| 377 | // if it cannot be sure of the answer. |
| 378 | func (f *extFloat) FixedDecimal(d *decimalSlice, n int) bool { |
| 379 | if f.mant == 0 { |
| 380 | d.nd = 0 |
| 381 | d.dp = 0 |
| 382 | d.neg = f.neg |
| 383 | return true |
| 384 | } |
| 385 | if n == 0 { |
| 386 | panic("strconv: internal error: extFloat.FixedDecimal called with n == 0") |
| 387 | } |
| 388 | // Multiply by an appropriate power of ten to have a reasonable |
| 389 | // number to process. |
| 390 | f.Normalize() |
| 391 | exp10, _ := f.frexp10() |
| 392 | |
| 393 | shift := uint(-f.exp) |
| 394 | integer := uint32(f.mant >> shift) |
| 395 | fraction := f.mant - (uint64(integer) << shift) |
| 396 | ε := uint64(1) // ε is the uncertainty we have on the mantissa of f. |
| 397 | |
| 398 | // Write exactly n digits to d. |
| 399 | needed := n // how many digits are left to write. |
| 400 | integerDigits := 0 // the number of decimal digits of integer. |
| 401 | pow10 := uint64(1) // the power of ten by which f was scaled. |
| 402 | for i, pow := 0, uint64(1); i < 20; i++ { |
| 403 | if pow > uint64(integer) { |
| 404 | integerDigits = i |
| 405 | break |
| 406 | } |
| 407 | pow *= 10 |
| 408 | } |
| 409 | rest := integer |
| 410 | if integerDigits > needed { |
| 411 | // the integral part is already large, trim the last digits. |
| 412 | pow10 = uint64pow10[integerDigits-needed] |
| 413 | integer /= uint32(pow10) |
| 414 | rest -= integer * uint32(pow10) |
| 415 | } else { |
| 416 | rest = 0 |
| 417 | } |
| 418 | |
| 419 | // Write the digits of integer: the digits of rest are omitted. |
| 420 | var buf [32]byte |
| 421 | pos := len(buf) |
| 422 | for v := integer; v > 0; { |
| 423 | v1 := v / 10 |
| 424 | v -= 10 * v1 |
| 425 | pos-- |
| 426 | buf[pos] = byte(v + '0') |
| 427 | v = v1 |
| 428 | } |
| 429 | for i := pos; i < len(buf); i++ { |
| 430 | d.d[i-pos] = buf[i] |
| 431 | } |
| 432 | nd := len(buf) - pos |
| 433 | d.nd = nd |
| 434 | d.dp = integerDigits + exp10 |
| 435 | needed -= nd |
no test coverage detected