// Copyright 2011 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package strconv

import (
	
)

// An extFloat represents an extended floating-point number, with more
// precision than a float64. It does not try to save bits: the
// number represented by the structure is mant*(2^exp), with a negative
// sign if neg is true.
type extFloat struct {
	mant uint64
	exp  int
	neg  bool
}

// Powers of ten taken from double-conversion library.
// https://code.google.com/p/double-conversion/
const (
	firstPowerOfTen = -348
	stepPowerOfTen  = 8
)

var smallPowersOfTen = [...]extFloat{
	{1 << 63, -63, false},        // 1
	{0xa << 60, -60, false},      // 1e1
	{0x64 << 57, -57, false},     // 1e2
	{0x3e8 << 54, -54, false},    // 1e3
	{0x2710 << 50, -50, false},   // 1e4
	{0x186a0 << 47, -47, false},  // 1e5
	{0xf4240 << 44, -44, false},  // 1e6
	{0x989680 << 40, -40, false}, // 1e7
}

var powersOfTen = [...]extFloat{
	{0xfa8fd5a0081c0288, -1220, false}, // 10^-348
	{0xbaaee17fa23ebf76, -1193, false}, // 10^-340
	{0x8b16fb203055ac76, -1166, false}, // 10^-332
	{0xcf42894a5dce35ea, -1140, false}, // 10^-324
	{0x9a6bb0aa55653b2d, -1113, false}, // 10^-316
	{0xe61acf033d1a45df, -1087, false}, // 10^-308
	{0xab70fe17c79ac6ca, -1060, false}, // 10^-300
	{0xff77b1fcbebcdc4f, -1034, false}, // 10^-292
	{0xbe5691ef416bd60c, -1007, false}, // 10^-284
	{0x8dd01fad907ffc3c, -980, false},  // 10^-276
	{0xd3515c2831559a83, -954, false},  // 10^-268
	{0x9d71ac8fada6c9b5, -927, false},  // 10^-260
	{0xea9c227723ee8bcb, -901, false},  // 10^-252
	{0xaecc49914078536d, -874, false},  // 10^-244
	{0x823c12795db6ce57, -847, false},  // 10^-236
	{0xc21094364dfb5637, -821, false},  // 10^-228
	{0x9096ea6f3848984f, -794, false},  // 10^-220
	{0xd77485cb25823ac7, -768, false},  // 10^-212
	{0xa086cfcd97bf97f4, -741, false},  // 10^-204
	{0xef340a98172aace5, -715, false},  // 10^-196
	{0xb23867fb2a35b28e, -688, false},  // 10^-188
	{0x84c8d4dfd2c63f3b, -661, false},  // 10^-180
	{0xc5dd44271ad3cdba, -635, false},  // 10^-172
	{0x936b9fcebb25c996, -608, false},  // 10^-164
	{0xdbac6c247d62a584, -582, false},  // 10^-156
	{0xa3ab66580d5fdaf6, -555, false},  // 10^-148
	{0xf3e2f893dec3f126, -529, false},  // 10^-140
	{0xb5b5ada8aaff80b8, -502, false},  // 10^-132
	{0x87625f056c7c4a8b, -475, false},  // 10^-124
	{0xc9bcff6034c13053, -449, false},  // 10^-116
	{0x964e858c91ba2655, -422, false},  // 10^-108
	{0xdff9772470297ebd, -396, false},  // 10^-100
	{0xa6dfbd9fb8e5b88f, -369, false},  // 10^-92
	{0xf8a95fcf88747d94, -343, false},  // 10^-84
	{0xb94470938fa89bcf, -316, false},  // 10^-76
	{0x8a08f0f8bf0f156b, -289, false},  // 10^-68
	{0xcdb02555653131b6, -263, false},  // 10^-60
	{0x993fe2c6d07b7fac, -236, false},  // 10^-52
	{0xe45c10c42a2b3b06, -210, false},  // 10^-44
	{0xaa242499697392d3, -183, false},  // 10^-36
	{0xfd87b5f28300ca0e, -157, false},  // 10^-28
	{0xbce5086492111aeb, -130, false},  // 10^-20
	{0x8cbccc096f5088cc, -103, false},  // 10^-12
	{0xd1b71758e219652c, -77, false},   // 10^-4
	{0x9c40000000000000, -50, false},   // 10^4
	{0xe8d4a51000000000, -24, false},   // 10^12
	{0xad78ebc5ac620000, 3, false},     // 10^20
	{0x813f3978f8940984, 30, false},    // 10^28
	{0xc097ce7bc90715b3, 56, false},    // 10^36
	{0x8f7e32ce7bea5c70, 83, false},    // 10^44
	{0xd5d238a4abe98068, 109, false},   // 10^52
	{0x9f4f2726179a2245, 136, false},   // 10^60
	{0xed63a231d4c4fb27, 162, false},   // 10^68
	{0xb0de65388cc8ada8, 189, false},   // 10^76
	{0x83c7088e1aab65db, 216, false},   // 10^84
	{0xc45d1df942711d9a, 242, false},   // 10^92
	{0x924d692ca61be758, 269, false},   // 10^100
	{0xda01ee641a708dea, 295, false},   // 10^108
	{0xa26da3999aef774a, 322, false},   // 10^116
	{0xf209787bb47d6b85, 348, false},   // 10^124
	{0xb454e4a179dd1877, 375, false},   // 10^132
	{0x865b86925b9bc5c2, 402, false},   // 10^140
	{0xc83553c5c8965d3d, 428, false},   // 10^148
	{0x952ab45cfa97a0b3, 455, false},   // 10^156
	{0xde469fbd99a05fe3, 481, false},   // 10^164
	{0xa59bc234db398c25, 508, false},   // 10^172
	{0xf6c69a72a3989f5c, 534, false},   // 10^180
	{0xb7dcbf5354e9bece, 561, false},   // 10^188
	{0x88fcf317f22241e2, 588, false},   // 10^196
	{0xcc20ce9bd35c78a5, 614, false},   // 10^204
	{0x98165af37b2153df, 641, false},   // 10^212
	{0xe2a0b5dc971f303a, 667, false},   // 10^220
	{0xa8d9d1535ce3b396, 694, false},   // 10^228
	{0xfb9b7cd9a4a7443c, 720, false},   // 10^236
	{0xbb764c4ca7a44410, 747, false},   // 10^244
	{0x8bab8eefb6409c1a, 774, false},   // 10^252
	{0xd01fef10a657842c, 800, false},   // 10^260
	{0x9b10a4e5e9913129, 827, false},   // 10^268
	{0xe7109bfba19c0c9d, 853, false},   // 10^276
	{0xac2820d9623bf429, 880, false},   // 10^284
	{0x80444b5e7aa7cf85, 907, false},   // 10^292
	{0xbf21e44003acdd2d, 933, false},   // 10^300
	{0x8e679c2f5e44ff8f, 960, false},   // 10^308
	{0xd433179d9c8cb841, 986, false},   // 10^316
	{0x9e19db92b4e31ba9, 1013, false},  // 10^324
	{0xeb96bf6ebadf77d9, 1039, false},  // 10^332
	{0xaf87023b9bf0ee6b, 1066, false},  // 10^340
}

// AssignComputeBounds sets f to the floating point value
// defined by mant, exp and precision given by flt. It returns
// lower, upper such that any number in the closed interval
// [lower, upper] is converted back to the same floating point number.
func ( *extFloat) ( uint64,  int,  bool,  *floatInfo) (,  extFloat) {
	.mant = 
	.exp =  - int(.mantbits)
	.neg = 
	if .exp <= 0 &&  == (>>uint(-.exp))<<uint(-.exp) {
		// An exact integer
		.mant >>= uint(-.exp)
		.exp = 0
		return *, *
	}
	 :=  - .bias

	 = extFloat{mant: 2*.mant + 1, exp: .exp - 1, neg: .neg}
	if  != 1<<.mantbits ||  == 1 {
		 = extFloat{mant: 2*.mant - 1, exp: .exp - 1, neg: .neg}
	} else {
		 = extFloat{mant: 4*.mant - 1, exp: .exp - 2, neg: .neg}
	}
	return
}

// Normalize normalizes f so that the highest bit of the mantissa is
// set, and returns the number by which the mantissa was left-shifted.
func ( *extFloat) () uint {
	// bits.LeadingZeros64 would return 64
	if .mant == 0 {
		return 0
	}
	 := bits.LeadingZeros64(.mant)
	.mant <<= uint()
	.exp -= 
	return uint()
}

// Multiply sets f to the product f*g: the result is correctly rounded,
// but not normalized.
func ( *extFloat) ( extFloat) {
	,  := bits.Mul64(.mant, .mant)
	// Round up.
	.mant =  + ( >> 63)
	.exp = .exp + .exp + 64
}

var uint64pow10 = [...]uint64{
	1, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9,
	1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,
}

// Frexp10 is an analogue of math.Frexp for decimal powers. It scales
// f by an approximate power of ten 10^-exp, and returns exp10, so
// that f*10^exp10 has the same value as the old f, up to an ulp,
// as well as the index of 10^-exp in the powersOfTen table.
func ( *extFloat) () (,  int) {
	// The constants expMin and expMax constrain the final value of the
	// binary exponent of f. We want a small integral part in the result
	// because finding digits of an integer requires divisions, whereas
	// digits of the fractional part can be found by repeatedly multiplying
	// by 10.
	const  = -60
	const  = -32
	// Find power of ten such that x * 10^n has a binary exponent
	// between expMin and expMax.
	 := ((+)/2 - .exp) * 28 / 93 // log(10)/log(2) is close to 93/28.
	 := ( - firstPowerOfTen) / stepPowerOfTen
:
	for {
		 := .exp + powersOfTen[].exp + 64
		switch {
		case  < :
			++
		case  > :
			--
		default:
			break 
		}
	}
	// Apply the desired decimal shift on f. It will have exponent
	// in the desired range. This is multiplication by 10^-exp10.
	.Multiply(powersOfTen[])

	return -(firstPowerOfTen + *stepPowerOfTen), 
}

// frexp10Many applies a common shift by a power of ten to a, b, c.
func frexp10Many(, ,  *extFloat) ( int) {
	,  := .frexp10()
	.Multiply(powersOfTen[])
	.Multiply(powersOfTen[])
	return
}

// 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.
func ( *extFloat) ( *decimalSlice,  int) bool {
	if .mant == 0 {
		.nd = 0
		.dp = 0
		.neg = .neg
		return true
	}
	if  == 0 {
		panic("strconv: internal error: extFloat.FixedDecimal called with n == 0")
	}
	// Multiply by an appropriate power of ten to have a reasonable
	// number to process.
	.Normalize()
	,  := .frexp10()

	 := uint(-.exp)
	 := uint32(.mant >> )
	 := .mant - (uint64() << )
	 := uint64(1) // ε is the uncertainty we have on the mantissa of f.

	// Write exactly n digits to d.
	 :=         // how many digits are left to write.
	 := 0 // the number of decimal digits of integer.
	 := uint64(1) // the power of ten by which f was scaled.
	for ,  := 0, uint64(1);  < 20; ++ {
		if  > uint64() {
			 = 
			break
		}
		 *= 10
	}
	 := 
	if  >  {
		// the integral part is already large, trim the last digits.
		 = uint64pow10[-]
		 /= uint32()
		 -=  * uint32()
	} else {
		 = 0
	}

	// Write the digits of integer: the digits of rest are omitted.
	var  [32]byte
	 := len()
	for  := ;  > 0; {
		 :=  / 10
		 -= 10 * 
		--
		[] = byte( + '0')
		 = 
	}
	for  := ;  < len(); ++ {
		.d[-] = []
	}
	 := len() - 
	.nd = 
	.dp =  + 
	 -= 

	if  > 0 {
		if  != 0 ||  != 1 {
			panic("strconv: internal error, rest != 0 but needed > 0")
		}
		// Emit digits for the fractional part. Each time, 10*fraction
		// fits in a uint64 without overflow.
		for  > 0 {
			 *= 10
			 *= 10 // the uncertainty scales as we multiply by ten.
			if 2* > 1<< {
				// the error is so large it could modify which digit to write, abort.
				return false
			}
			 :=  >> 
			.d[] = byte( + '0')
			 -=  << 
			++
			--
		}
		.nd = 
	}

	// We have written a truncation of f (a numerator / 10^d.dp). The remaining part
	// can be interpreted as a small number (< 1) to be added to the last digit of the
	// numerator.
	//
	// If rest > 0, the amount is:
	//    (rest<<shift | fraction) / (pow10 << shift)
	//    fraction being known with a ±ε uncertainty.
	//    The fact that n > 0 guarantees that pow10 << shift does not overflow a uint64.
	//
	// If rest = 0, pow10 == 1 and the amount is
	//    fraction / (1 << shift)
	//    fraction being known with a ±ε uncertainty.
	//
	// We pass this information to the rounding routine for adjustment.

	 := adjustLastDigitFixed(, uint64()<<|, , , )
	if ! {
		return false
	}
	// Trim trailing zeros.
	for  := .nd - 1;  >= 0; -- {
		if .d[] != '0' {
			.nd =  + 1
			break
		}
	}
	return true
}

// adjustLastDigitFixed assumes d contains the representation of the integral part
// of some number, whose fractional part is num / (den << shift). The numerator
// num is only known up to an uncertainty of size ε, assumed to be less than
// (den << shift)/2.
//
// It will increase the last digit by one to account for correct rounding, typically
// when the fractional part is greater than 1/2, and will return false if ε is such
// that no correct answer can be given.
func adjustLastDigitFixed( *decimalSlice, ,  uint64,  uint,  uint64) bool {
	if  > << {
		panic("strconv: num > den<<shift in adjustLastDigitFixed")
	}
	if 2* > << {
		panic("strconv: ε > (den<<shift)/2")
	}
	if 2*(+) < << {
		return true
	}
	if 2*(-) > << {
		// increment d by 1.
		 := .nd - 1
		for ;  >= 0; -- {
			if .d[] == '9' {
				.nd--
			} else {
				break
			}
		}
		if  < 0 {
			.d[0] = '1'
			.nd = 1
			.dp++
		} else {
			.d[]++
		}
		return true
	}
	return false
}

// ShortestDecimal stores in d the shortest decimal representation of f
// which belongs to the open interval (lower, upper), where f is supposed
// to lie. It returns false whenever the result is unsure. The implementation
// uses the Grisu3 algorithm.
func ( *extFloat) ( *decimalSlice, ,  *extFloat) bool {
	if .mant == 0 {
		.nd = 0
		.dp = 0
		.neg = .neg
		return true
	}
	if .exp == 0 && * == * && * == * {
		// an exact integer.
		var  [24]byte
		 := len() - 1
		for  := .mant;  > 0; {
			 :=  / 10
			 -= 10 * 
			[] = byte( + '0')
			--
			 = 
		}
		 := len() -  - 1
		for  := 0;  < ; ++ {
			.d[] = [+1+]
		}
		.nd, .dp = , 
		for .nd > 0 && .d[.nd-1] == '0' {
			.nd--
		}
		if .nd == 0 {
			.dp = 0
		}
		.neg = .neg
		return true
	}
	.Normalize()
	// Uniformize exponents.
	if .exp > .exp {
		.mant <<= uint(.exp - .exp)
		.exp = .exp
	}
	if .exp > .exp {
		.mant <<= uint(.exp - .exp)
		.exp = .exp
	}

	 := frexp10Many(, , )
	// Take a safety margin due to rounding in frexp10Many, but we lose precision.
	.mant++
	.mant--

	// The shortest representation of f is either rounded up or down, but
	// in any case, it is a truncation of upper.
	 := uint(-.exp)
	 := uint32(.mant >> )
	 := .mant - (uint64() << )

	// How far we can go down from upper until the result is wrong.
	 := .mant - .mant
	// How far we should go to get a very precise result.
	 := .mant - .mant

	// Count integral digits: there are at most 10.
	var  int
	for ,  := 0, uint64(1);  < 20; ++ {
		if  > uint64() {
			 = 
			break
		}
		 *= 10
	}
	for  := 0;  < ; ++ {
		 := uint64pow10[--1]
		 :=  / uint32()
		.d[] = byte( + '0')
		 -=  * uint32()
		// evaluate whether we should stop.
		if  := uint64()<< + ;  <  {
			.nd =  + 1
			.dp =  + 
			.neg = .neg
			// Sometimes allowance is so large the last digit might need to be
			// decremented to get closer to f.
			return adjustLastDigit(, , , , <<, 2)
		}
	}
	.nd = 
	.dp = .nd + 
	.neg = .neg

	// Compute digits of the fractional part. At each step fraction does not
	// overflow. The choice of minExp implies that fraction is less than 2^60.
	var  int
	 := uint64(1)
	for {
		 *= 10
		 *= 10
		 = int( >> )
		.d[.nd] = byte( + '0')
		.nd++
		 -= uint64() << 
		if  < * {
			// We are in the admissible range. Note that if allowance is about to
			// overflow, that is, allowance > 2^64/10, the condition is automatically
			// true due to the limited range of fraction.
			return adjustLastDigit(,
				, *, *,
				1<<, *2)
		}
	}
}

// adjustLastDigit modifies d = x-currentDiff*ε, to get closest to
// d = x-targetDiff*ε, without becoming smaller than x-maxDiff*ε.
// It assumes that a decimal digit is worth ulpDecimal*ε, and that
// all data is known with an error estimate of ulpBinary*ε.
func adjustLastDigit( *decimalSlice, , , , ,  uint64) bool {
	if  < 2* {
		// Approximation is too wide.
		return false
	}
	for +/2+ <  {
		.d[.nd-1]--
		 += 
	}
	if + <= +/2+ {
		// we have two choices, and don't know what to do.
		return false
	}
	if  <  ||  > - {
		// we went too far
		return false
	}
	if .nd == 1 && .d[0] == '0' {
		// the number has actually reached zero.
		.nd = 0
		.dp = 0
	}
	return true
}