func math.Float64frombits

44 uses

	math (current package)
		abs.go#L14: 	return Float64frombits(Float64bits(x) &^ (1 << 63))
		bits.go#L27: 	return Float64frombits(v)
		bits.go#L31: func NaN() float64 { return Float64frombits(uvnan) }
		cbrt.go#L57: 	t := Float64frombits(Float64bits(x)/3 + B1<<32)
		cbrt.go#L62: 		t = Float64frombits(Float64bits(t)/3 + B2<<32)
		cbrt.go#L71: 	t = Float64frombits(Float64bits(t)&(0xFFFFFFFFC<<28) + 1<<30)
		copysign.go#L11: 	return Float64frombits(Float64bits(f)&^signBit | Float64bits(sign)&signBit)
		erf.go#L259: 	z := Float64frombits(Float64bits(x) & 0xffffffff00000000) // pseudo-single (20-bit) precision x
		erf.go#L340: 		z := Float64frombits(Float64bits(x) & 0xffffffff00000000) // pseudo-single (20-bit) precision x
		expm1.go#L230: 		y = Float64frombits(Float64bits(y) + uint64(k)<<52) // add k to y's exponent
		expm1.go#L234: 		t := Float64frombits(0x3ff0000000000000 - (0x20000000000000 >> uint(k))) // t=1-2**-k
		expm1.go#L236: 		y = Float64frombits(Float64bits(y) + uint64(k)<<52) // add k to y's exponent
		expm1.go#L239: 	t = Float64frombits(uint64(0x3ff-k) << 52) // 2**-k
		expm1.go#L242: 	y = Float64frombits(Float64bits(y) + uint64(k)<<52) // add k to y's exponent
		floor.go#L111: 	return Float64frombits(bits)
		floor.go#L150: 	return Float64frombits(bits)
		fma.go#L165: 		return Float64frombits(uint64(ps)<<63 | uvinf)
		fma.go#L174: 	return Float64frombits(uint64(ps)<<63 + uint64(pe)<<52 + m)
		frexp.go#L37: 	frac = Float64frombits(x)
		ldexp.go#L50: 	return m * Float64frombits(x)
		log1p.go#L172: 			u = Float64frombits(iu | 0x3ff0000000000000) // normalize u
		log1p.go#L175: 			u = Float64frombits(iu | 0x3fe0000000000000) // normalize u/2
		modf.go#L40: 	int = Float64frombits(x)
		nextafter.go#L44: 		r = Copysign(Float64frombits(1), y)
		nextafter.go#L46: 		r = Float64frombits(Float64bits(x) + 1)
		nextafter.go#L48: 		r = Float64frombits(Float64bits(x) - 1)
		sqrt.go#L144: 	return Float64frombits(ix)
		trig_reduce.go#L66: 	z = Float64frombits(hi)
		unsafe.go#L29: func Float64frombits(b uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }

	math/big
		float.go#L1057: 		return math.Float64frombits(sign | bexp | mant), r.acc

	encoding/binary
		binary.go#L262: 			*data = math.Float64frombits(order.Uint64(bs))
		binary.go#L303: 				data[i] = math.Float64frombits(order.Uint64(bs[8*i:]))
		binary.go#L668: 		v.SetFloat(math.Float64frombits(d.uint64()))
		binary.go#L677: 			math.Float64frombits(d.uint64()),
		binary.go#L678: 			math.Float64frombits(d.uint64()),

	github.com/gotd/td/bin
		decode.go#L171: 	return math.Float64frombits(uint64(v)), nil

	go.opentelemetry.io/otel/internal
		rawhelpers.go#L46: 	return math.Float64frombits(r)

	go.uber.org/atomic
		float64.go#L50: 	return math.Float64frombits(x.v.Load())
		float64.go#L61: 	return math.Float64frombits(x.v.Swap(math.Float64bits(val)))

	go.uber.org/zap/zapcore
		field.go#L137: 		enc.AddFloat64(f.Key, math.Float64frombits(uint64(f.Integer)))

	strconv
		atof.go#L561: 	return math.Float64frombits(bits), err
		atof.go#L661: 	f = math.Float64frombits(b)
		eisel_lemire.go#L32: 			f = math.Float64frombits(0x8000000000000000) // Negative zero.
		eisel_lemire.go#L91: 	return math.Float64frombits(retBits), true