func math.Float64frombits

58 uses

	math (current package)
		abs.go#L13: 	return Float64frombits(Float64bits(x) &^ (1 << 63))
		bits.go#L27: 	return Float64frombits(v)
		bits.go#L31: func NaN() float64 { return Float64frombits(uvnan) }
		cbrt.go#L56: 	t := Float64frombits(Float64bits(x)/3 + B1<<32)
		cbrt.go#L61: 		t = Float64frombits(Float64bits(t)/3 + B2<<32)
		cbrt.go#L70: 	t = Float64frombits(Float64bits(t)&(0xFFFFFFFFC<<28) + 1<<30)
		copysign.go#L11: 	return Float64frombits(Float64bits(x)&^sign | Float64bits(y)&sign)
		erf.go#L258: 	z := Float64frombits(Float64bits(x) & 0xffffffff00000000) // pseudo-single (20-bit) precision x
		erf.go#L338: 		z := Float64frombits(Float64bits(x) & 0xffffffff00000000) // pseudo-single (20-bit) precision x
		expm1.go#L228: 		y = Float64frombits(Float64bits(y) + uint64(k)<<52) // add k to y's exponent
		expm1.go#L232: 		t := Float64frombits(0x3ff0000000000000 - (0x20000000000000 >> uint(k))) // t=1-2**-k
		expm1.go#L234: 		y = Float64frombits(Float64bits(y) + uint64(k)<<52) // add k to y's exponent
		expm1.go#L237: 	t = Float64frombits(uint64(0x3ff-k) << 52) // 2**-k
		expm1.go#L240: 	y = Float64frombits(Float64bits(y) + uint64(k)<<52) // add k to y's exponent
		floor.go#L107: 	return Float64frombits(bits)
		floor.go#L145: 	return Float64frombits(bits)
		fma.go#L160: 		return Float64frombits(uint64(ps)<<63 | uvinf)
		fma.go#L169: 	return Float64frombits(uint64(ps)<<63 + uint64(pe)<<52 + m)
		frexp.go#L36: 	frac = Float64frombits(x)
		ldexp.go#L49: 	return m * Float64frombits(x)
		log1p.go#L171: 			u = Float64frombits(iu | 0x3ff0000000000000) // normalize u
		log1p.go#L174: 			u = Float64frombits(iu | 0x3fe0000000000000) // normalize u/2
		modf.go#L39: 	int = Float64frombits(x)
		nextafter.go#L42: 		r = Copysign(Float64frombits(1), y)
		nextafter.go#L44: 		r = Float64frombits(Float64bits(x) + 1)
		nextafter.go#L46: 		r = Float64frombits(Float64bits(x) - 1)
		sqrt.go#L148: 	return Float64frombits(ix)
		trig_reduce.go#L64: 	z = Float64frombits(hi)
		unsafe.go#L29: func Float64frombits(b uint64) float64 { return *(*float64)(unsafe.Pointer(&b)) }

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

	encoding/binary
		binary.go#L191: 			*data = math.Float64frombits(order.Uint64(bs))
		binary.go#L232: 				data[i] = math.Float64frombits(order.Uint64(bs[8*i:]))
		binary.go#L594: 		v.SetFloat(math.Float64frombits(d.uint64()))
		binary.go#L603: 			math.Float64frombits(d.uint64()),
		binary.go#L604: 			math.Float64frombits(d.uint64()),

	expvar
		expvar.go#L74: 	return math.Float64frombits(atomic.LoadUint64(&v.f))
		expvar.go#L79: 		math.Float64frombits(atomic.LoadUint64(&v.f)), 'g', -1, 64)
		expvar.go#L86: 		curVal := math.Float64frombits(cur)

	github.com/vmihailenco/msgpack/v5
		decode_number.go#L211: 		return math.Float64frombits(n), nil

	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)))

	golang.org/x/tools/internal/event/keys
		keys.go#L459: 	return math.Float64frombits(t.Unpack64())

	google.golang.org/protobuf/internal/impl
		codec_gen.go#L4626: 	*p.Float64() = math.Float64frombits(v)
		codec_gen.go#L4695: 	**vp = math.Float64frombits(v)
		codec_gen.go#L4738: 			s = append(s, math.Float64frombits(v))
		codec_gen.go#L4752: 	*sp = append(*sp, math.Float64frombits(v))
		codec_gen.go#L4818: 	return protoreflect.ValueOfFloat64(math.Float64frombits(v)), out, nil
		codec_gen.go#L4859: 			list.Append(protoreflect.ValueOfFloat64(math.Float64frombits(v)))
		codec_gen.go#L4872: 	list.Append(protoreflect.ValueOfFloat64(math.Float64frombits(v)))

	google.golang.org/protobuf/proto
		decode_gen.go#L149: 		return protoreflect.ValueOfFloat64(math.Float64frombits(v)), n, nil
		decode_gen.go#L533: 				list.Append(protoreflect.ValueOfFloat64(math.Float64frombits(v)))
		decode_gen.go#L544: 		list.Append(protoreflect.ValueOfFloat64(math.Float64frombits(v)))

	google.golang.org/protobuf/reflect/protoreflect
		value_union.go#L303: 		return math.Float64frombits(uint64(v.num))

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