gofront 1.8.0 → 1.9.0

package/stdlib/strconv/float.go

@@ -0,0 +1,1699 @@
+//go:build gofront
+
+//gofront:target both
+
+package strconv
+
+import "math"
+
+
+type decimal struct {
+	d     [800]byte // digits, big-endian representation
+	nd    int       // number of digits used
+	dp    int       // decimal point
+	neg   bool      // negative flag
+	trunc bool      // discarded nonzero digits beyond d[:nd]
+}
+
+func (a *decimal) String() string {
+	n := 10 + a.nd
+	if a.dp > 0 {
+		n += a.dp
+	}
+	if a.dp < 0 {
+		n += -a.dp
+	}
+
+	buf := make([]byte, n)
+	w := 0
+	switch {
+	case a.nd == 0:
+		return "0"
+
+	case a.dp <= 0:
+		// zeros fill space between decimal point and digits
+		buf[w] = '0'
+		w++
+		buf[w] = '.'
+		w++
+		w += digitZero(buf[w : w+-a.dp])
+		w += copy(buf[w:], a.d[0:a.nd])
+
+	case a.dp < a.nd:
+		// decimal point in middle of digits
+		w += copy(buf[w:], a.d[0:a.dp])
+		buf[w] = '.'
+		w++
+		w += copy(buf[w:], a.d[a.dp:a.nd])
+
+	default:
+		// zeros fill space between digits and decimal point
+		w += copy(buf[w:], a.d[0:a.nd])
+		w += digitZero(buf[w : w+a.dp-a.nd])
+	}
+	return string(buf[0:w])
+}
+
+func digitZero(dst []byte) int {
+	for i := range dst {
+		dst[i] = '0'
+	}
+	return len(dst)
+}
+
+// trim trailing zeros from number.
+// (They are meaningless; the decimal point is tracked
+// independent of the number of digits.)
+func trim(a *decimal) {
+	for a.nd > 0 && a.d[a.nd-1] == '0' {
+		a.nd--
+	}
+	if a.nd == 0 {
+		a.dp = 0
+	}
+}
+
+// Assign v to a.
+func (a *decimal) Assign(v uint64) {
+	var buf [24]byte
+
+	// Write reversed decimal in buf.
+	n := 0
+	for v > 0 {
+		v1 := v / 10
+		v -= 10 * v1
+		buf[n] = byte(v + '0')
+		n++
+		v = v1
+	}
+
+	// Reverse again to produce forward decimal in a.d.
+	a.nd = 0
+	for n--; n >= 0; n-- {
+		a.d[a.nd] = buf[n]
+		a.nd++
+	}
+	a.dp = a.nd
+	trim(a)
+}
+
+// Maximum shift that we can do in one pass without overflow.
+// A uint has 32 or 64 bits, and we have to be able to accommodate 9<<k.
+const uintSize = 64
+const maxShift = uintSize - 4
+
+// Binary shift right (/ 2) by k bits.  k <= maxShift to avoid overflow.
+func rightShift(a *decimal, k uint) {
+	r := 0 // read pointer
+	w := 0 // write pointer
+
+	// Pick up enough leading digits to cover first shift.
+	var n uint64
+	for ; n>>k == 0; r++ {
+		if r >= a.nd {
+			if n == 0 {
+				// a == 0; shouldn't get here, but handle anyway.
+				a.nd = 0
+				return
+			}
+			for n>>k == 0 {
+				n = n * 10
+				r++
+			}
+			break
+		}
+		c := uint64(a.d[r])
+		n = n*10 + c - '0'
+	}
+	a.dp -= r - 1
+
+	mask := uint64(1)<<k - 1
+
+	// Pick up a digit, put down a digit.
+	for ; r < a.nd; r++ {
+		c := uint64(a.d[r])
+		dig := n >> k
+		n &= mask
+		a.d[w] = byte(dig + '0')
+		w++
+		n = n*10 + c - '0'
+	}
+
+	// Put down extra digits.
+	for n > 0 {
+		dig := n >> k
+		n &= mask
+		if w < len(a.d) {
+			a.d[w] = byte(dig + '0')
+			w++
+		} else if dig > 0 {
+			a.trunc = true
+		}
+		n = n * 10
+	}
+
+	a.nd = w
+	trim(a)
+}
+
+// Cheat sheet for left shift: table indexed by shift count giving
+// number of new digits that will be introduced by that shift.
+//
+// For example, leftcheats[4] = {2, "625"}.  That means that
+// if we are shifting by 4 (multiplying by 16), it will add 2 digits
+// when the string prefix is "625" through "999", and one fewer digit
+// if the string prefix is "000" through "624".
+//
+// Credit for this trick goes to Ken.
+
+type leftCheat struct {
+	delta  int    // number of new digits
+	cutoff string // minus one digit if original < a.
+}
+
+var leftcheats = []leftCheat{
+	// Leading digits of 1/2^i = 5^i.
+	// 5^23 is not an exact 64-bit floating point number,
+	// so have to use bc for the math.
+	// Go up to 60 to be large enough for 32bit and 64bit platforms.
+	/*
+		seq 60 | sed 's/^/5^/' | bc |
+		awk 'BEGIN{ print "\t{ 0, \"\" }," }
+		{
+			log2 = log(2)/log(10)
+			printf("\t{ %d, \"%s\" },\t// * %d\n",
+				int(log2*NR+1), $0, 2**NR)
+		}'
+	*/
+	{0, ""},
+	{1, "5"},                                           // * 2
+	{1, "25"},                                          // * 4
+	{1, "125"},                                         // * 8
+	{2, "625"},                                         // * 16
+	{2, "3125"},                                        // * 32
+	{2, "15625"},                                       // * 64
+	{3, "78125"},                                       // * 128
+	{3, "390625"},                                      // * 256
+	{3, "1953125"},                                     // * 512
+	{4, "9765625"},                                     // * 1024
+	{4, "48828125"},                                    // * 2048
+	{4, "244140625"},                                   // * 4096
+	{4, "1220703125"},                                  // * 8192
+	{5, "6103515625"},                                  // * 16384
+	{5, "30517578125"},                                 // * 32768
+	{5, "152587890625"},                                // * 65536
+	{6, "762939453125"},                                // * 131072
+	{6, "3814697265625"},                               // * 262144
+	{6, "19073486328125"},                              // * 524288
+	{7, "95367431640625"},                              // * 1048576
+	{7, "476837158203125"},                             // * 2097152
+	{7, "2384185791015625"},                            // * 4194304
+	{7, "11920928955078125"},                           // * 8388608
+	{8, "59604644775390625"},                           // * 16777216
+	{8, "298023223876953125"},                          // * 33554432
+	{8, "1490116119384765625"},                         // * 67108864
+	{9, "7450580596923828125"},                         // * 134217728
+	{9, "37252902984619140625"},                        // * 268435456
+	{9, "186264514923095703125"},                       // * 536870912
+	{10, "931322574615478515625"},                      // * 1073741824
+	{10, "4656612873077392578125"},                     // * 2147483648
+	{10, "23283064365386962890625"},                    // * 4294967296
+	{10, "116415321826934814453125"},                   // * 8589934592
+	{11, "582076609134674072265625"},                   // * 17179869184
+	{11, "2910383045673370361328125"},                  // * 34359738368
+	{11, "14551915228366851806640625"},                 // * 68719476736
+	{12, "72759576141834259033203125"},                 // * 137438953472
+	{12, "363797880709171295166015625"},                // * 274877906944
+	{12, "1818989403545856475830078125"},               // * 549755813888
+	{13, "9094947017729282379150390625"},               // * 1099511627776
+	{13, "45474735088646411895751953125"},              // * 2199023255552
+	{13, "227373675443232059478759765625"},             // * 4398046511104
+	{13, "1136868377216160297393798828125"},            // * 8796093022208
+	{14, "5684341886080801486968994140625"},            // * 17592186044416
+	{14, "28421709430404007434844970703125"},           // * 35184372088832
+	{14, "142108547152020037174224853515625"},          // * 70368744177664
+	{15, "710542735760100185871124267578125"},          // * 140737488355328
+	{15, "3552713678800500929355621337890625"},         // * 281474976710656
+	{15, "17763568394002504646778106689453125"},        // * 562949953421312
+	{16, "88817841970012523233890533447265625"},        // * 1125899906842624
+	{16, "444089209850062616169452667236328125"},       // * 2251799813685248
+	{16, "2220446049250313080847263336181640625"},      // * 4503599627370496
+	{16, "11102230246251565404236316680908203125"},     // * 9007199254740992
+	{17, "55511151231257827021181583404541015625"},     // * 18014398509481984
+	{17, "277555756156289135105907917022705078125"},    // * 36028797018963968
+	{17, "1387778780781445675529539585113525390625"},   // * 72057594037927936
+	{18, "6938893903907228377647697925567626953125"},   // * 144115188075855872
+	{18, "34694469519536141888238489627838134765625"},  // * 288230376151711744
+	{18, "173472347597680709441192448139190673828125"}, // * 576460752303423488
+	{19, "867361737988403547205962240695953369140625"}, // * 1152921504606846976
+}
+
+// Is the leading prefix of b lexicographically less than s?
+func prefixIsLessThan(b []byte, s string) bool {
+	for i := 0; i < len(s); i++ {
+		if i >= len(b) {
+			return true
+		}
+		if b[i] != s[i] {
+			return b[i] < s[i]
+		}
+	}
+	return false
+}
+
+// Binary shift left (* 2) by k bits.  k <= maxShift to avoid overflow.
+func leftShift(a *decimal, k uint) {
+	delta := leftcheats[k].delta
+	if prefixIsLessThan(a.d[0:a.nd], leftcheats[k].cutoff) {
+		delta--
+	}
+
+	r := a.nd         // read index
+	w := a.nd + delta // write index
+
+	// Pick up a digit, put down a digit.
+	var n uint64
+	for r--; r >= 0; r-- {
+		n += (uint64(a.d[r]) - '0') << k
+		quo := n / 10
+		rem := n - 10*quo
+		w--
+		if w < len(a.d) {
+			a.d[w] = byte(rem + '0')
+		} else if rem != 0 {
+			a.trunc = true
+		}
+		n = quo
+	}
+
+	// Put down extra digits.
+	for n > 0 {
+		quo := n / 10
+		rem := n - 10*quo
+		w--
+		if w < len(a.d) {
+			a.d[w] = byte(rem + '0')
+		} else if rem != 0 {
+			a.trunc = true
+		}
+		n = quo
+	}
+
+	a.nd += delta
+	if a.nd >= len(a.d) {
+		a.nd = len(a.d)
+	}
+	a.dp += delta
+	trim(a)
+}
+
+// Binary shift left (k > 0) or right (k < 0).
+func (a *decimal) Shift(k int) {
+	switch {
+	case a.nd == 0:
+		// nothing to do: a == 0
+	case k > 0:
+		for k > maxShift {
+			leftShift(a, maxShift)
+			k -= maxShift
+		}
+		leftShift(a, uint(k))
+	case k < 0:
+		for k < -maxShift {
+			rightShift(a, maxShift)
+			k += maxShift
+		}
+		rightShift(a, uint(-k))
+	}
+}
+
+// If we chop a at nd digits, should we round up?
+func shouldRoundUp(a *decimal, nd int) bool {
+	if nd < 0 || nd >= a.nd {
+		return false
+	}
+	if a.d[nd] == '5' && nd+1 == a.nd { // exactly halfway - round to even
+		// if we truncated, a little higher than what's recorded - always round up
+		if a.trunc {
+			return true
+		}
+		return nd > 0 && (a.d[nd-1]-'0')%2 != 0
+	}
+	// not halfway - digit tells all
+	return a.d[nd] >= '5'
+}
+
+// Round a to nd digits (or fewer).
+// If nd is zero, it means we're rounding
+// just to the left of the digits, as in
+// 0.09 -> 0.1.
+func (a *decimal) Round(nd int) {
+	if nd < 0 || nd >= a.nd {
+		return
+	}
+	if shouldRoundUp(a, nd) {
+		a.RoundUp(nd)
+	} else {
+		a.RoundDown(nd)
+	}
+}
+
+// Round a down to nd digits (or fewer).
+func (a *decimal) RoundDown(nd int) {
+	if nd < 0 || nd >= a.nd {
+		return
+	}
+	a.nd = nd
+	trim(a)
+}
+
+// Round a up to nd digits (or fewer).
+func (a *decimal) RoundUp(nd int) {
+	if nd < 0 || nd >= a.nd {
+		return
+	}
+
+	// round up
+	for i := nd - 1; i >= 0; i-- {
+		c := a.d[i]
+		if c < '9' { // can stop after this digit
+			a.d[i]++
+			a.nd = i + 1
+			return
+		}
+	}
+
+	// Number is all 9s.
+	// Change to single 1 with adjusted decimal point.
+	a.d[0] = '1'
+	a.nd = 1
+	a.dp++
+}
+
+// Extract integer part, rounded appropriately.
+// No guarantees about overflow.
+func (a *decimal) RoundedInteger() uint64 {
+	if a.dp > 20 {
+		return 0xFFFFFFFFFFFFFFFF
+	}
+	var i int
+	n := uint64(0)
+	for i = 0; i < a.dp && i < a.nd; i++ {
+		n = n*10 + uint64(a.d[i]-'0')
+	}
+	for ; i < a.dp; i++ {
+		n *= 10
+	}
+	if shouldRoundUp(a, a.dp) {
+		n++
+	}
+	return n
+}
+
+
+const (
+	upperhex = "0123456789ABCDEF"
+)
+
+type floatInfo struct {
+	mantbits uint
+	expbits  uint
+	bias     int
+}
+
+const (
+	float32MantBits = 23
+	float32ExpBits  = 8
+	float32Bias     = -127
+	float64MantBits = 52
+	float64ExpBits  = 11
+	float64Bias     = -1023
+)
+
+func float32info() *floatInfo {
+	return &floatInfo{float32MantBits, float32ExpBits, float32Bias}
+}
+
+func float64info() *floatInfo {
+	return &floatInfo{float64MantBits, float64ExpBits, float64Bias}
+}
+
+// FormatFloat converts the floating-point number f to a string,
+// according to the format fmt and precision prec. It rounds the
+// result assuming that the original was obtained from a floating-point
+// value of bitSize bits (32 for float32, 64 for float64).
+//
+// The format fmt is one of
+//   - 'b' (-ddddp±ddd, a binary exponent),
+//   - 'e' (-d.dddde±dd, a decimal exponent),
+//   - 'E' (-d.ddddE±dd, a decimal exponent),
+//   - 'f' (-ddd.dddd, no exponent),
+//   - 'g' ('e' for large exponents, 'f' otherwise),
+//   - 'G' ('E' for large exponents, 'f' otherwise),
+//   - 'x' (-0xd.ddddp±ddd, a hexadecimal fraction and binary exponent), or
+//   - 'X' (-0Xd.ddddP±ddd, a hexadecimal fraction and binary exponent).
+//
+// The precision prec controls the number of digits (excluding the exponent)
+// printed by the 'e', 'E', 'f', 'g', 'G', 'x', and 'X' formats.
+// For 'e', 'E', 'f', 'x', and 'X', it is the number of digits after the decimal point.
+// For 'g' and 'G' it is the maximum number of significant digits (trailing
+// zeros are removed).
+// The special precision -1 uses the smallest number of digits
+// necessary such that ParseFloat will return f exactly.
+// The exponent is written as a decimal integer;
+// for all formats other than 'b', it will be at least two digits.
+func FormatFloat(f float64, fmt byte, prec, bitSize int) string {
+	return string(genericFtoa(make([]byte, 0, max(prec+4, 24)), f, fmt, prec, bitSize))
+}
+
+// AppendFloat appends the string form of the floating-point number f,
+// as generated by [FormatFloat], to dst and returns the extended buffer.
+func AppendFloat(dst []byte, f float64, fmt byte, prec, bitSize int) []byte {
+	return genericFtoa(dst, f, fmt, prec, bitSize)
+}
+
+func genericFtoa(dst []byte, val float64, fmt byte, prec, bitSize int) []byte {
+	if fmt == 'f' && prec >= 0 && prec <= 60 && bitSize == 64 && val-val == 0 {
+		// The host's fixed-point printer, which the Go body declines.
+		if s := fixed(math.Abs(val), prec); s != "" {
+			if math.Signbit(val) {
+				dst = append(dst, '-')
+			}
+			return append(dst, s...)
+		}
+	}
+	var bits uint64
+	var flt *floatInfo
+	switch bitSize {
+	case 32:
+		bits = uint64(math.Float32bits(float32(val)))
+		flt = float32info()
+	case 64:
+		bits = math.Float64bits(val)
+		flt = float64info()
+	default:
+		panic("strconv: illegal AppendFloat/FormatFloat bitSize")
+	}
+
+	neg := bits>>(flt.expbits+flt.mantbits) != 0
+	exp := int(bits>>flt.mantbits) & (1<<flt.expbits - 1)
+	mant := bits & (uint64(1)<<flt.mantbits - 1)
+
+	switch exp {
+	case 1<<flt.expbits - 1:
+		// Inf, NaN
+		var s string
+		switch {
+		case mant != 0:
+			s = "NaN"
+		case neg:
+			s = "-Inf"
+		default:
+			s = "+Inf"
+		}
+		return append(dst, s...)
+
+	case 0:
+		// denormalized
+		exp++
+
+	default:
+		// add implicit top bit
+		mant |= uint64(1) << flt.mantbits
+	}
+	exp += flt.bias
+
+	// Pick off easy binary, hex formats.
+	if fmt == 'b' {
+		return fmtB(dst, neg, mant, exp, flt)
+	}
+	if fmt == 'x' || fmt == 'X' {
+		return fmtX(dst, prec, fmt, neg, mant, exp, flt)
+	}
+
+	if prec < 0 && bitSize == 64 && mant != 0 {
+		// The host's number printer gives the shortest digits.
+		digs := shortestDigits(math.Abs(val))
+		switch fmt {
+		case 'e', 'E':
+			prec = digs.nd - 1
+		case 'f':
+			prec = max(digs.nd-digs.dp, 0)
+		case 'g', 'G':
+			prec = digs.nd
+		}
+		return formatDigits(dst, true, neg, digs, prec, fmt)
+	}
+	return bigFtoa(dst, prec, fmt, neg, mant, exp, flt)
+}
+
+// fixed formats f, a finite float64 of at least zero, with prec digits after
+// the point as %f does, rounding exact ties to even; "" when the host cannot
+// (f is 1e21 or more). The Go body always declines, and the caller then uses
+// bigFtoa.
+//
+//gofront:native strconv.fixed
+func fixed(f float64, prec int) string {
+	return ""
+}
+
+// shortestDigits returns the fewest digits that read back as f, a finite
+// float64 above zero.
+func shortestDigits(f float64) decimalSlice {
+	s := shortest(f)
+	buf := make([]byte, 0, 17)
+	e := 0
+	for i := 0; i < len(s); i++ {
+		c := byte(s[i])
+		if c == 'e' {
+			e, _ = Atoi(s[i+1:])
+			break
+		}
+		if c != '.' {
+			buf = append(buf, c)
+		}
+	}
+	return decimalSlice{d: buf, nd: len(buf), dp: e + 1}
+}
+
+// shortest formats f, a finite float64 above zero, as the shortest digits
+// that read back as f, in the form d.ddde+x of a host number printer.
+//
+//gofront:native strconv.shortest
+func shortest(f float64) string {
+	bits := math.Float64bits(f)
+	flt := float64info()
+	exp := int(bits>>flt.mantbits) & (1<<flt.expbits - 1)
+	mant := bits & (uint64(1)<<flt.mantbits - 1)
+	if exp == 0 {
+		exp++
+	} else {
+		mant |= uint64(1) << flt.mantbits
+	}
+	exp += flt.bias
+	d := new(decimal)
+	d.Assign(mant)
+	d.Shift(exp - int(flt.mantbits))
+	roundShortest(d, mant, exp, flt)
+	out := make([]byte, 0, 32)
+	out = append(out, d.d[0])
+	if d.nd > 1 {
+		out = append(out, '.')
+		out = append(out, d.d[1:d.nd]...)
+	}
+	out = append(out, 'e')
+	e := d.dp - 1
+	if e < 0 {
+		out = append(out, '-')
+		e = -e
+	} else {
+		out = append(out, '+')
+	}
+	out = AppendInt(out, int64(e), 10)
+	return string(out)
+}
+
+// bigFtoa uses multiprecision computations to format a float.
+func bigFtoa(dst []byte, prec int, fmt byte, neg bool, mant uint64, exp int, flt *floatInfo) []byte {
+	d := new(decimal)
+	d.Assign(mant)
+	d.Shift(exp - int(flt.mantbits))
+	var digs decimalSlice
+	shortest := prec < 0
+	if shortest {
+		roundShortest(d, mant, exp, flt)
+		digs = decimalSlice{d: d.d[:], nd: d.nd, dp: d.dp}
+		// Precision for shortest representation mode.
+		switch fmt {
+		case 'e', 'E':
+			prec = digs.nd - 1
+		case 'f':
+			prec = max(digs.nd-digs.dp, 0)
+		case 'g', 'G':
+			prec = digs.nd
+		}
+	} else {
+		// Round appropriately.
+		switch fmt {
+		case 'e', 'E':
+			d.Round(prec + 1)
+		case 'f':
+			d.Round(d.dp + prec)
+		case 'g', 'G':
+			if prec == 0 {
+				prec = 1
+			}
+			d.Round(prec)
+		}
+		digs = decimalSlice{d: d.d[:], nd: d.nd, dp: d.dp}
+	}
+	return formatDigits(dst, shortest, neg, digs, prec, fmt)
+}
+
+func formatDigits(dst []byte, shortest bool, neg bool, digs decimalSlice, prec int, fmt byte) []byte {
+	switch fmt {
+	case 'e', 'E':
+		return fmtE(dst, neg, digs, prec, fmt)
+	case 'f':
+		return fmtF(dst, neg, digs, prec)
+	case 'g', 'G':
+		// trailing fractional zeros in 'e' form will be trimmed.
+		eprec := prec
+		if eprec > digs.nd && digs.nd >= digs.dp {
+			eprec = digs.nd
+		}
+		// %e is used if the exponent from the conversion
+		// is less than -4 or greater than or equal to the precision.
+		// if precision was the shortest possible, use precision 6 for this decision.
+		if shortest {
+			eprec = 6
+		}
+		exp := digs.dp - 1
+		if exp < -4 || exp >= eprec {
+			if prec > digs.nd {
+				prec = digs.nd
+			}
+			return fmtE(dst, neg, digs, prec-1, fmt+'e'-'g')
+		}
+		if prec > digs.dp {
+			prec = digs.nd
+		}
+		return fmtF(dst, neg, digs, max(prec-digs.dp, 0))
+	}
+
+	// unknown format
+	return append(dst, '%', fmt)
+}
+
+// roundShortest rounds d (= mant * 2^exp) to the shortest number of digits
+// that will let the original floating point value be precisely reconstructed.
+func roundShortest(d *decimal, mant uint64, exp int, flt *floatInfo) {
+	// If mantissa is zero, the number is zero; stop now.
+	if mant == 0 {
+		d.nd = 0
+		return
+	}
+
+	// Compute upper and lower such that any decimal number
+	// between upper and lower (possibly inclusive)
+	// will round to the original floating point number.
+
+	// We may see at once that the number is already shortest.
+	//
+	// Suppose d is not denormal, so that 2^exp <= d < 10^dp.
+	// The closest shorter number is at least 10^(dp-nd) away.
+	// The lower/upper bounds computed below are at distance
+	// at most 2^(exp-mantbits).
+	//
+	// So the number is already shortest if 10^(dp-nd) > 2^(exp-mantbits),
+	// or equivalently log2(10)*(dp-nd) > exp-mantbits.
+	// It is true if 332/100*(dp-nd) >= exp-mantbits (log2(10) > 3.32).
+	minexp := flt.bias + 1 // minimum possible exponent
+	if exp > minexp && 332*(d.dp-d.nd) >= 100*(exp-int(flt.mantbits)) {
+		// The number is already shortest.
+		return
+	}
+
+	// d = mant << (exp - mantbits)
+	// Next highest floating point number is mant+1 << exp-mantbits.
+	// Our upper bound is halfway between, mant*2+1 << exp-mantbits-1.
+	upper := new(decimal)
+	upper.Assign(mant*2 + 1)
+	upper.Shift(exp - int(flt.mantbits) - 1)
+
+	// d = mant << (exp - mantbits)
+	// Next lowest floating point number is mant-1 << exp-mantbits,
+	// unless mant-1 drops the significant bit and exp is not the minimum exp,
+	// in which case the next lowest is mant*2-1 << exp-mantbits-1.
+	// Either way, call it mantlo << explo-mantbits.
+	// Our lower bound is halfway between, mantlo*2+1 << explo-mantbits-1.
+	var mantlo uint64
+	var explo int
+	if mant > uint64(1)<<flt.mantbits || exp == minexp {
+		mantlo = mant - 1
+		explo = exp
+	} else {
+		mantlo = mant*2 - 1
+		explo = exp - 1
+	}
+	lower := new(decimal)
+	lower.Assign(mantlo*2 + 1)
+	lower.Shift(explo - int(flt.mantbits) - 1)
+
+	// The upper and lower bounds are possible outputs only if
+	// the original mantissa is even, so that IEEE round-to-even
+	// would round to the original mantissa and not the neighbors.
+	inclusive := mant%2 == 0
+
+	// As we walk the digits we want to know whether rounding up would fall
+	// within the upper bound. This is tracked by upperdelta:
+	//
+	// If upperdelta == 0, the digits of d and upper are the same so far.
+	//
+	// If upperdelta == 1, we saw a difference of 1 between d and upper on a
+	// previous digit and subsequently only 9s for d and 0s for upper.
+	// (Thus rounding up may fall outside the bound, if it is exclusive.)
+	//
+	// If upperdelta == 2, then the difference is greater than 1
+	// and we know that rounding up falls within the bound.
+	var upperdelta uint8
+
+	// Now we can figure out the minimum number of digits required.
+	// Walk along until d has distinguished itself from upper and lower.
+	for ui := 0; ; ui++ {
+		// lower, d, and upper may have the decimal points at different
+		// places. In this case upper is the longest, so we iterate from
+		// ui==0 and start li and mi at (possibly) -1.
+		mi := ui - upper.dp + d.dp
+		if mi >= d.nd {
+			break
+		}
+		li := ui - upper.dp + lower.dp
+		l := byte('0') // lower digit
+		if li >= 0 && li < lower.nd {
+			l = lower.d[li]
+		}
+		m := byte('0') // middle digit
+		if mi >= 0 {
+			m = d.d[mi]
+		}
+		u := byte('0') // upper digit
+		if ui < upper.nd {
+			u = upper.d[ui]
+		}
+
+		// Okay to round down (truncate) if lower has a different digit
+		// or if lower is inclusive and is exactly the result of rounding
+		// down (i.e., and we have reached the final digit of lower).
+		okdown := l != m || inclusive && li+1 == lower.nd
+
+		switch {
+		case upperdelta == 0 && m+1 < u:
+			// Example:
+			// m = 12345xxx
+			// u = 12347xxx
+			upperdelta = 2
+		case upperdelta == 0 && m != u:
+			// Example:
+			// m = 12345xxx
+			// u = 12346xxx
+			upperdelta = 1
+		case upperdelta == 1 && (m != '9' || u != '0'):
+			// Example:
+			// m = 1234598x
+			// u = 1234600x
+			upperdelta = 2
+		}
+		// Okay to round up if upper has a different digit and either upper
+		// is inclusive or upper is bigger than the result of rounding up.
+		okup := upperdelta > 0 && (inclusive || upperdelta > 1 || ui+1 < upper.nd)
+
+		// If it's okay to do either, then round to the nearest one.
+		// If it's okay to do only one, do it.
+		switch {
+		case okdown && okup:
+			d.Round(mi + 1)
+			return
+		case okdown:
+			d.RoundDown(mi + 1)
+			return
+		case okup:
+			d.RoundUp(mi + 1)
+			return
+		}
+	}
+}
+
+type decimalSlice struct {
+	d      []byte
+	nd, dp int
+}
+
+// %e: -d.ddddde±dd
+func fmtE(dst []byte, neg bool, d decimalSlice, prec int, fmt byte) []byte {
+	// sign
+	if neg {
+		dst = append(dst, '-')
+	}
+
+	// first digit
+	ch := byte('0')
+	if d.nd != 0 {
+		ch = d.d[0]
+	}
+	dst = append(dst, ch)
+
+	// .moredigits
+	if prec > 0 {
+		dst = append(dst, '.')
+		i := 1
+		m := min(d.nd, prec+1)
+		if i < m {
+			dst = append(dst, d.d[i:m]...)
+			i = m
+		}
+		for ; i <= prec; i++ {
+			dst = append(dst, '0')
+		}
+	}
+
+	// e±
+	dst = append(dst, fmt)
+	exp := d.dp - 1
+	if d.nd == 0 { // special case: 0 has exponent 0
+		exp = 0
+	}
+	if exp < 0 {
+		ch = '-'
+		exp = -exp
+	} else {
+		ch = '+'
+	}
+	dst = append(dst, ch)
+
+	// dd or ddd
+	switch {
+	case exp < 10:
+		dst = append(dst, '0', byte(exp)+'0')
+	case exp < 100:
+		dst = append(dst, byte(exp/10)+'0', byte(exp%10)+'0')
+	default:
+		dst = append(dst, byte(exp/100)+'0', byte(exp/10)%10+'0', byte(exp%10)+'0')
+	}
+
+	return dst
+}
+
+// %f: -ddddddd.ddddd
+func fmtF(dst []byte, neg bool, d decimalSlice, prec int) []byte {
+	// sign
+	if neg {
+		dst = append(dst, '-')
+	}
+
+	// integer, padded with zeros as needed.
+	if d.dp > 0 {
+		m := min(d.nd, d.dp)
+		dst = append(dst, d.d[:m]...)
+		for ; m < d.dp; m++ {
+			dst = append(dst, '0')
+		}
+	} else {
+		dst = append(dst, '0')
+	}
+
+	// fraction
+	if prec > 0 {
+		dst = append(dst, '.')
+		for i := 0; i < prec; i++ {
+			ch := byte('0')
+			if j := d.dp + i; 0 <= j && j < d.nd {
+				ch = d.d[j]
+			}
+			dst = append(dst, ch)
+		}
+	}
+
+	return dst
+}
+
+// %b: -ddddddddp±ddd
+func fmtB(dst []byte, neg bool, mant uint64, exp int, flt *floatInfo) []byte {
+	// sign
+	if neg {
+		dst = append(dst, '-')
+	}
+
+	// mantissa
+	dst = AppendUint(dst, mant, 10)
+
+	// p
+	dst = append(dst, 'p')
+
+	// ±exponent
+	exp -= int(flt.mantbits)
+	if exp >= 0 {
+		dst = append(dst, '+')
+	}
+	dst = AppendInt(dst, int64(exp), 10)
+
+	return dst
+}
+
+// %x: -0x1.yyyyyyyyp±ddd or -0x0p+0. (y is hex digit, d is decimal digit)
+func fmtX(dst []byte, prec int, fmt byte, neg bool, mant uint64, exp int, flt *floatInfo) []byte {
+	if mant == 0 {
+		exp = 0
+	}
+
+	// Shift digits so leading 1 (if any) is at bit 1<<60.
+	mant <<= 60 - flt.mantbits
+	for mant != 0 && mant&(1<<60) == 0 {
+		mant <<= 1
+		exp--
+	}
+
+	// Round if requested.
+	if prec >= 0 && prec < 15 {
+		shift := uint(prec * 4)
+		extra := (mant << shift) & (1<<60 - 1)
+		mant >>= 60 - shift
+		if extra|(mant&1) > 1<<59 {
+			mant++
+		}
+		mant <<= 60 - shift
+		if mant&(1<<61) != 0 {
+			// Wrapped around.
+			mant >>= 1
+			exp++
+		}
+	}
+
+	hex := lowerhex
+	if fmt == 'X' {
+		hex = upperhex
+	}
+
+	// sign, 0x, leading digit
+	if neg {
+		dst = append(dst, '-')
+	}
+	dst = append(dst, '0', fmt, '0'+byte((mant>>60)&1))
+
+	// .fraction
+	mant <<= 4 // remove leading 0 or 1
+	if prec < 0 && mant != 0 {
+		dst = append(dst, '.')
+		for mant != 0 {
+			dst = append(dst, hex[(mant>>60)&15])
+			mant <<= 4
+		}
+	} else if prec > 0 {
+		dst = append(dst, '.')
+		for i := 0; i < prec; i++ {
+			dst = append(dst, hex[(mant>>60)&15])
+			mant <<= 4
+		}
+	}
+
+	// p±
+	ch := byte('P')
+	if fmt == lower(fmt) {
+		ch = 'p'
+	}
+	dst = append(dst, ch)
+	if exp < 0 {
+		ch = '-'
+		exp = -exp
+	} else {
+		ch = '+'
+	}
+	dst = append(dst, ch)
+
+	// dd or ddd or dddd
+	switch {
+	case exp < 100:
+		dst = append(dst, byte(exp/10)+'0', byte(exp%10)+'0')
+	case exp < 1000:
+		dst = append(dst, byte(exp/100)+'0', byte((exp/10)%10)+'0', byte(exp%10)+'0')
+	default:
+		dst = append(dst, byte(exp/1000)+'0', byte(exp/100)%10+'0', byte((exp/10)%10)+'0', byte(exp%10)+'0')
+	}
+
+	return dst
+}
+
+
+// decimal to binary floating point conversion.
+// Algorithm:
+//   1) Store input in multiprecision decimal.
+//   2) Multiply/divide decimal by powers of two until in range [0.5, 1)
+//   3) Multiply by 2^precision and round to get mantissa.
+
+
+// commonPrefixLenIgnoreCase returns the length of the common
+// prefix of s and prefix, with the character case of s ignored.
+// The prefix argument must be all lower-case.
+func commonPrefixLenIgnoreCase(s, prefix string) int {
+	n := min(len(prefix), len(s))
+	for i := 0; i < n; i++ {
+		c := s[i]
+		if 'A' <= c && c <= 'Z' {
+			c += 'a' - 'A'
+		}
+		if c != prefix[i] {
+			return i
+		}
+	}
+	return n
+}
+
+// special returns the floating-point value for the special,
+// possibly signed floating-point representations inf, infinity,
+// and NaN. The result is ok if a prefix of s contains one
+// of these representations and n is the length of that prefix.
+// The character case is ignored.
+func special(s string) (f float64, n int, ok bool) {
+	if len(s) == 0 {
+		return 0, 0, false
+	}
+	sign := 1
+	nsign := 0
+	switch s[0] {
+	case '+', '-':
+		if s[0] == '-' {
+			sign = -1
+		}
+		nsign = 1
+		s = s[1:]
+		fallthrough
+	case 'i', 'I':
+		n := commonPrefixLenIgnoreCase(s, "infinity")
+		// Anything longer than "inf" is ok, but if we
+		// don't have "infinity", only consume "inf".
+		if 3 < n && n < 8 {
+			n = 3
+		}
+		if n == 3 || n == 8 {
+			return math.Inf(sign), nsign + n, true
+		}
+	case 'n', 'N':
+		if commonPrefixLenIgnoreCase(s, "nan") == 3 {
+			return math.NaN(), 3, true
+		}
+	}
+	return 0, 0, false
+}
+
+func (b *decimal) set(s string) (ok bool) {
+	i := 0
+	b.neg = false
+	b.trunc = false
+
+	// optional sign
+	if i >= len(s) {
+		return
+	}
+	switch s[i] {
+	case '+':
+		i++
+	case '-':
+		i++
+		b.neg = true
+	}
+
+	// digits
+	sawdot := false
+	sawdigits := false
+	for ; i < len(s); i++ {
+		switch {
+		case s[i] == '_':
+			// readFloat already checked underscores
+			continue
+		case s[i] == '.':
+			if sawdot {
+				return
+			}
+			sawdot = true
+			b.dp = b.nd
+			continue
+
+		case '0' <= s[i] && s[i] <= '9':
+			sawdigits = true
+			if s[i] == '0' && b.nd == 0 { // ignore leading zeros
+				b.dp--
+				continue
+			}
+			if b.nd < len(b.d) {
+				b.d[b.nd] = byte(s[i])
+				b.nd++
+			} else if s[i] != '0' {
+				b.trunc = true
+			}
+			continue
+		}
+		break
+	}
+	if !sawdigits {
+		return
+	}
+	if !sawdot {
+		b.dp = b.nd
+	}
+
+	// optional exponent moves decimal point.
+	// if we read a very large, very long number,
+	// just be sure to move the decimal point by
+	// a lot (say, 100000).  it doesn't matter if it's
+	// not the exact number.
+	if i < len(s) && lowerS(s[i]) == 'e' {
+		i++
+		if i >= len(s) {
+			return
+		}
+		esign := 1
+		switch s[i] {
+		case '+':
+			i++
+		case '-':
+			i++
+			esign = -1
+		}
+		if i >= len(s) || s[i] < '0' || s[i] > '9' {
+			return
+		}
+		e := 0
+		for ; i < len(s) && ('0' <= s[i] && s[i] <= '9' || s[i] == '_'); i++ {
+			if s[i] == '_' {
+				// readFloat already checked underscores
+				continue
+			}
+			if e < 10000 {
+				e = e*10 + int(s[i]) - '0'
+			}
+		}
+		b.dp += e * esign
+	}
+
+	if i != len(s) {
+		return
+	}
+
+	ok = true
+	return
+}
+
+// readFloat reads a decimal or hexadecimal mantissa and exponent from a float
+// string representation in s; the number may be followed by other characters.
+// readFloat reports the number of bytes consumed (i), and whether the number
+// is valid (ok).
+func readFloat(s string) (mantissa uint64, exp int, neg, trunc, hex bool, i int, ok bool) {
+	underscores := false
+
+	// optional sign
+	if i >= len(s) {
+		return
+	}
+	switch s[i] {
+	case '+':
+		i++
+	case '-':
+		i++
+		neg = true
+	}
+
+	// digits
+	base := uint64(10)
+	maxMantDigits := 19 // 10^19 fits in uint64
+	expChar := byte('e')
+	if i+2 < len(s) && s[i] == '0' && lowerS(s[i+1]) == 'x' {
+		base = 16
+		maxMantDigits = 16 // 16^16 fits in uint64
+		i += 2
+		expChar = 'p'
+		hex = true
+	}
+	sawdot := false
+	sawdigits := false
+	nd := 0
+	ndMant := 0
+	dp := 0
+loop:
+	for ; i < len(s); i++ {
+		switch c := s[i]; true {
+		case c == '_':
+			underscores = true
+			continue
+
+		case c == '.':
+			if sawdot {
+				break loop
+			}
+			sawdot = true
+			dp = nd
+			continue
+
+		case '0' <= c && c <= '9':
+			sawdigits = true
+			if c == '0' && nd == 0 { // ignore leading zeros
+				dp--
+				continue
+			}
+			nd++
+			if ndMant < maxMantDigits {
+				mantissa *= base
+				mantissa += uint64(c - '0')
+				ndMant++
+			} else if c != '0' {
+				trunc = true
+			}
+			continue
+
+		case base == 16 && 'a' <= lowerS(c) && lowerS(c) <= 'f':
+			sawdigits = true
+			nd++
+			if ndMant < maxMantDigits {
+				mantissa *= 16
+				mantissa += uint64(lowerS(c) - 'a' + 10)
+				ndMant++
+			} else {
+				trunc = true
+			}
+			continue
+		}
+		break
+	}
+	if !sawdigits {
+		return
+	}
+	if !sawdot {
+		dp = nd
+	}
+
+	if base == 16 {
+		dp *= 4
+		ndMant *= 4
+	}
+
+	// optional exponent moves decimal point.
+	// if we read a very large, very long number,
+	// just be sure to move the decimal point by
+	// a lot (say, 100000).  it doesn't matter if it's
+	// not the exact number.
+	if i < len(s) && lowerS(s[i]) == expChar {
+		i++
+		if i >= len(s) {
+			return
+		}
+		esign := 1
+		switch s[i] {
+		case '+':
+			i++
+		case '-':
+			i++
+			esign = -1
+		}
+		if i >= len(s) || s[i] < '0' || s[i] > '9' {
+			return
+		}
+		e := 0
+		for ; i < len(s) && ('0' <= s[i] && s[i] <= '9' || s[i] == '_'); i++ {
+			if s[i] == '_' {
+				underscores = true
+				continue
+			}
+			if e < 10000 {
+				e = e*10 + int(s[i]) - '0'
+			}
+		}
+		dp += e * esign
+	} else if base == 16 {
+		// Must have exponent.
+		return
+	}
+
+	if mantissa != 0 {
+		exp = dp - ndMant
+	}
+
+	if underscores && !underscoreOK(s[:i]) {
+		return
+	}
+
+	ok = true
+	return
+}
+
+// decimal power of ten to binary power of two.
+var powtab = []int{1, 3, 6, 9, 13, 16, 19, 23, 26}
+
+func (d *decimal) floatBits(flt *floatInfo) (b uint64, overflow bool) {
+	mant, exp, overflow := d.floatParts(flt)
+	// Assemble bits.
+	bits := mant & (uint64(1)<<flt.mantbits - 1)
+	bits |= uint64((exp-flt.bias)&(1<<flt.expbits-1)) << flt.mantbits
+	if d.neg {
+		bits |= uint64(1) << flt.mantbits << flt.expbits
+	}
+	return bits, overflow
+}
+
+// floatParts is floatBits before the assembly: the mantissa, the exponent
+// and whether the value overflows to infinity.
+func (d *decimal) floatParts(flt *floatInfo) (mant uint64, exp int, overflow bool) {
+	inf := 1<<flt.expbits - 1 + flt.bias
+
+	// Zero is always a special case.
+	if d.nd == 0 {
+		return 0, flt.bias, false
+	}
+
+	// Obvious overflow/underflow.
+	// These bounds are for 64-bit floats.
+	// Will have to change if we want to support 80-bit floats in the future.
+	if d.dp > 310 {
+		return 0, inf, true
+	}
+	if d.dp < -330 {
+		// zero
+		return 0, flt.bias, false
+	}
+
+	// Scale by powers of two until in range [0.5, 1.0)
+	exp = 0
+	for d.dp > 0 {
+		var n int
+		if d.dp >= len(powtab) {
+			n = 27
+		} else {
+			n = powtab[d.dp]
+		}
+		d.Shift(-n)
+		exp += n
+	}
+	for d.dp < 0 || d.dp == 0 && d.d[0] < '5' {
+		var n int
+		if -d.dp >= len(powtab) {
+			n = 27
+		} else {
+			n = powtab[-d.dp]
+		}
+		d.Shift(n)
+		exp -= n
+	}
+
+	// Our range is [0.5,1) but floating point range is [1,2).
+	exp--
+
+	// Minimum representable exponent is flt.bias+1.
+	// If the exponent is smaller, move it up and
+	// adjust d accordingly.
+	if exp < flt.bias+1 {
+		n := flt.bias + 1 - exp
+		d.Shift(-n)
+		exp += n
+	}
+
+	if exp-flt.bias >= 1<<flt.expbits-1 {
+		return 0, inf, true
+	}
+
+	// Extract 1+flt.mantbits bits.
+	d.Shift(int(1 + flt.mantbits))
+	mant = d.RoundedInteger()
+
+	// Rounding might have added a bit; shift down.
+	if mant == uint64(2)<<flt.mantbits {
+		mant >>= 1
+		exp++
+		if exp-flt.bias >= 1<<flt.expbits-1 {
+			return 0, inf, true
+		}
+	}
+
+	// Denormalized?
+	if mant&(uint64(1)<<flt.mantbits) == 0 {
+		exp = flt.bias
+	}
+	return mant, exp, false
+}
+
+// Exact powers of 10.
+var float64pow10 = []float64{
+	1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9,
+	1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,
+	1e20, 1e21, 1e22,
+}
+var float32pow10 = []float32{1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 1e10}
+
+// If possible to convert decimal representation to 64-bit float f exactly,
+// entirely in floating-point math, do so, avoiding the expense of decimalToFloatBits.
+// Three common cases:
+//
+//	value is exact integer
+//	value is exact integer * exact power of ten
+//	value is exact integer / exact power of ten
+//
+// These all produce potentially inexact but correctly rounded answers.
+func atof64exact(mantissa uint64, exp int, neg bool) (f float64, ok bool) {
+	if mantissa>>float64MantBits != 0 {
+		return
+	}
+	f = float64(mantissa)
+	if neg {
+		f = -f
+	}
+	switch {
+	case exp == 0:
+		// an integer.
+		return f, true
+	// Exact integers are <= 10^15.
+	// Exact powers of ten are <= 10^22.
+	case exp > 0 && exp <= 15+22: // int * 10^k
+		// If exponent is big but number of digits is not,
+		// can move a few zeros into the integer part.
+		if exp > 22 {
+			f *= float64pow10[exp-22]
+			exp = 22
+		}
+		if f > 1e15 || f < -1e15 {
+			// the exponent was really too large.
+			return
+		}
+		return f * float64pow10[exp], true
+	case exp < 0 && exp >= -22: // int / 10^k
+		return f / float64pow10[-exp], true
+	}
+	return
+}
+
+// If possible to compute mantissa*10^exp to 32-bit float f exactly,
+// entirely in floating-point math, do so, avoiding the machinery above.
+func atof32exact(mantissa uint64, exp int, neg bool) (f float32, ok bool) {
+	if mantissa>>float32MantBits != 0 {
+		return
+	}
+	f = float32(mantissa)
+	if neg {
+		f = -f
+	}
+	switch {
+	case exp == 0:
+		return f, true
+	// Exact integers are <= 10^7.
+	// Exact powers of ten are <= 10^10.
+	case exp > 0 && exp <= 7+10: // int * 10^k
+		// If exponent is big but number of digits is not,
+		// can move a few zeros into the integer part.
+		if exp > 10 {
+			f *= float32pow10[exp-10]
+			exp = 10
+		}
+		if f > 1e7 || f < -1e7 {
+			// the exponent was really too large.
+			return
+		}
+		return f * float32pow10[exp], true
+	case exp < 0 && exp >= -10: // int / 10^k
+		return f / float32pow10[-exp], true
+	}
+	return
+}
+
+// atofHex converts the hex floating-point string s
+// to a rounded float32 or float64 value (depending on flt==float32info() or flt==float64info())
+// and returns it as a float64.
+// The string s has already been parsed into a mantissa, exponent, and sign (neg==true for negative).
+// If trunc is true, trailing non-zero bits have been omitted from the mantissa.
+func atofHex(s string, flt *floatInfo, mantissa uint64, exp int, neg, trunc bool) (float64, error) {
+	maxExp := 1<<flt.expbits + flt.bias - 2
+	minExp := flt.bias + 1
+	exp += int(flt.mantbits) // mantissa now implicitly divided by 2^mantbits.
+
+	// Shift mantissa and exponent to bring representation into float range.
+	// Eventually we want a mantissa with a leading 1-bit followed by mantbits other bits.
+	// For rounding, we need two more, where the bottom bit represents
+	// whether that bit or any later bit was non-zero.
+	// (If the mantissa has already lost non-zero bits, trunc is true,
+	// and we OR in a 1 below after shifting left appropriately.)
+	for mantissa != 0 && mantissa>>(flt.mantbits+2) == 0 {
+		mantissa <<= 1
+		exp--
+	}
+	if trunc {
+		mantissa |= 1
+	}
+	for mantissa>>(1+flt.mantbits+2) != 0 {
+		mantissa = mantissa>>1 | mantissa&1
+		exp++
+	}
+
+	// If exponent is too negative,
+	// denormalize in hopes of making it representable.
+	// (The -2 is for the rounding bits.)
+	for mantissa > 1 && exp < minExp-2 {
+		mantissa = mantissa>>1 | mantissa&1
+		exp++
+	}
+
+	// Round using two bottom bits.
+	round := mantissa & 3
+	mantissa >>= 2
+	round |= mantissa & 1 // round to even (round up if mantissa is odd)
+	exp += 2
+	if round == 3 {
+		mantissa++
+		if mantissa == uint64(1)<<(1+flt.mantbits) {
+			mantissa >>= 1
+			exp++
+		}
+	}
+
+	if mantissa>>flt.mantbits == 0 { // Denormal or zero.
+		exp = flt.bias
+	}
+	var err error
+	if exp > maxExp { // infinity and range error
+		mantissa = uint64(1) << flt.mantbits
+		exp = maxExp + 1
+		err = ErrRange
+	}
+
+	bits := mantissa & (uint64(1)<<flt.mantbits - 1)
+	bits |= uint64((exp-flt.bias)&(1<<flt.expbits-1)) << flt.mantbits
+	if neg {
+		bits |= uint64(1) << flt.mantbits << flt.expbits
+	}
+	if flt.mantbits == float32MantBits {
+		return float64(math.Float32frombits(uint32(bits))), err
+	}
+	return math.Float64frombits(bits), err
+}
+
+const fnParseFloat = "ParseFloat"
+
+func atof32(s string) (f float32, n int, err error) {
+	if val, n, ok := special(s); ok {
+		return float32(val), n, nil
+	}
+
+	mantissa, exp, neg, trunc, hex, n, ok := readFloat(s)
+	if !ok {
+		return 0, n, ErrSyntax
+	}
+
+	if hex {
+		f, err := atofHex(s[:n], float32info(), mantissa, exp, neg, trunc)
+		return float32(f), n, err
+	}
+
+	// Try pure floating-point arithmetic conversion.
+	if !trunc {
+		if f, ok := atof32exact(mantissa, exp, neg); ok {
+			return f, n, nil
+		}
+	}
+
+	// Slow fallback.
+	var d decimal
+	if !d.set(s[:n]) {
+		return 0, n, ErrSyntax
+	}
+	b, ovf := d.floatBits(float32info())
+	f = math.Float32frombits(uint32(b))
+	if ovf {
+		err = ErrRange
+	}
+	return f, n, err
+}
+
+func atof64(s string) (f float64, n int, err error) {
+	if val, n, ok := special(s); ok {
+		return val, n, nil
+	}
+
+	mantissa, exp, neg, trunc, hex, n, ok := readFloat(s)
+	if !ok {
+		return 0, n, ErrSyntax
+	}
+
+	if hex {
+		f, err := atofHex(s[:n], float64info(), mantissa, exp, neg, trunc)
+		return f, n, err
+	}
+
+	// Try pure floating-point arithmetic conversion.
+	if !trunc {
+		if f, ok := atof64exact(mantissa, exp, neg); ok {
+			return f, n, nil
+		}
+	}
+
+	// The host's correctly rounded conversion.
+	f = parseDecimal(s[:n])
+	if math.IsInf(f, 0) {
+		err = ErrRange
+	}
+	return f, n, err
+}
+
+// parseDecimal is the float64 nearest to s, a decimal number already
+// checked for its syntax (underscores allowed).
+//
+//gofront:native strconv.parseDecimal
+func parseDecimal(s string) float64 {
+	var d decimal
+	d.set(s)
+	b, _ := d.floatBits(float64info())
+	return math.Float64frombits(b)
+}
+
+// ParseFloat converts the string s to a floating-point number
+// with the precision specified by bitSize: 32 for float32, or 64 for float64.
+// When bitSize=32, the result still has type float64, but it will be
+// convertible to float32 without changing its value.
+//
+// ParseFloat accepts decimal and hexadecimal floating-point numbers
+// as defined by the Go syntax for [floating-point literals].
+// If s is well-formed and near a valid floating-point number,
+// ParseFloat returns the nearest floating-point number rounded
+// using IEEE754 unbiased rounding.
+// (Parsing a hexadecimal floating-point value only rounds when
+// there are more bits in the hexadecimal representation than
+// will fit in the mantissa.)
+//
+// The errors that ParseFloat returns have concrete type *NumError
+// and include err.Num = s.
+//
+// If s is not syntactically well-formed, ParseFloat returns err.Err = ErrSyntax.
+//
+// If s is syntactically well-formed but is more than 1/2 ULP
+// away from the largest floating point number of the given size,
+// ParseFloat returns f = ±Inf, err.Err = ErrRange.
+//
+// ParseFloat recognizes the string "NaN", and the (possibly signed) strings "Inf" and "Infinity"
+// as their respective special floating point values. It ignores case when matching.
+//
+// [floating-point literals]: https://go.dev/ref/spec#Floating-point_literals
+func ParseFloat(s string, bitSize int) (float64, error) {
+	f, n, err := parseFloatPrefix(s, bitSize)
+	if n != len(s) {
+		err = ErrSyntax
+		f = 0
+	}
+	if err != nil {
+		if err == ErrSyntax {
+			return f, syntaxError("ParseFloat", s)
+		}
+		return f, rangeError("ParseFloat", s)
+	}
+	return f, nil
+}
+
+func parseFloatPrefix(s string, bitSize int) (float64, int, error) {
+	if bitSize == 32 {
+		f, n, err := atof32(s)
+		return float64(f), n, err
+	}
+	return atof64(s)
+}