func math.Float64frombits

88 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#L51: 	t := Float64frombits(Float64bits(x)/3 + B1<<32)
		cbrt.go#L56: 		t = Float64frombits(Float64bits(t)/3 + B2<<32)
		cbrt.go#L65: 	t = Float64frombits(Float64bits(t)&(0xFFFFFFFFC<<28) + 1<<30)
		copysign.go#L11: 	return Float64frombits(Float64bits(x)&^sign | Float64bits(y)&sign)
		erf.go#L253: 	z := Float64frombits(Float64bits(x) & 0xffffffff00000000) // pseudo-single (20-bit) precision x
		erf.go#L328: 		z := Float64frombits(Float64bits(x) & 0xffffffff00000000) // pseudo-single (20-bit) precision x
		expm1.go#L223: 		y = Float64frombits(Float64bits(y) + uint64(k)<<52) // add k to y's exponent
		expm1.go#L227: 		t := Float64frombits(0x3ff0000000000000 - (0x20000000000000 >> uint(k))) // t=1-2**-k
		expm1.go#L229: 		y = Float64frombits(Float64bits(y) + uint64(k)<<52) // add k to y's exponent
		expm1.go#L232: 	t = Float64frombits(uint64(0x3ff-k) << 52) // 2**-k
		expm1.go#L235: 	y = Float64frombits(Float64bits(y) + uint64(k)<<52) // add k to y's exponent
		floor.go#L92: 	return Float64frombits(bits)
		floor.go#L130: 	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#L31: 	frac = Float64frombits(x)
		ldexp.go#L44: 	return m * Float64frombits(x)
		log1p.go#L166: 			u = Float64frombits(iu | 0x3ff0000000000000) // normalize u
		log1p.go#L169: 			u = Float64frombits(iu | 0x3fe0000000000000) // normalize u/2
		modf.go#L34: 	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#L143: 	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#L1049: 		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()),

	encoding/gob
		decode.go#L318: 	return math.Float64frombits(v)

	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/jackc/pgtype
		box.go#L102: 			{math.Float64frombits(x1), math.Float64frombits(y1)},
		box.go#L103: 			{math.Float64frombits(x2), math.Float64frombits(y2)},
		circle.go#L90: 		P:      Vec2{math.Float64frombits(x), math.Float64frombits(y)},
		circle.go#L91: 		R:      math.Float64frombits(r),
		float8.go#L212: 	*dst = Float8{Float: math.Float64frombits(uint64(n)), Status: Present}
		line.go#L87: 		A:      math.Float64frombits(a),
		line.go#L88: 		B:      math.Float64frombits(b),
		line.go#L89: 		C:      math.Float64frombits(c),
		lseg.go#L102: 			{math.Float64frombits(x1), math.Float64frombits(y1)},
		lseg.go#L103: 			{math.Float64frombits(x2), math.Float64frombits(y2)},
		path.go#L107: 		points[i] = Vec2{math.Float64frombits(x), math.Float64frombits(y)}
		pgtype.go#L717: 		*p = float64(math.Float64frombits(uint64(n)))
		point.go#L134: 		P:      Vec2{math.Float64frombits(x), math.Float64frombits(y)},
		polygon.go#L153: 		points[i] = Vec2{math.Float64frombits(x), math.Float64frombits(y)}

	github.com/prometheus/client_golang/prometheus
		counter.go#L99: 		newBits := math.Float64bits(math.Float64frombits(oldBits) + v)
		counter.go#L111: 	fval := math.Float64frombits(atomic.LoadUint64(&c.valBits))
		gauge.go#L113: 		newBits := math.Float64bits(math.Float64frombits(oldBits) + val)
		gauge.go#L125: 	val := math.Float64frombits(atomic.LoadUint64(&g.valBits))
		histogram.go#L286: 		newBits := math.Float64bits(math.Float64frombits(oldBits) + v)
		histogram.go#L323: 		SampleSum:   proto.Float64(math.Float64frombits(atomic.LoadUint64(&coldCounts.sumBits))),
		histogram.go#L342: 		newBits := math.Float64bits(math.Float64frombits(oldBits) + his.GetSampleSum())
		summary.go#L439: 		newBits := math.Float64bits(math.Float64frombits(oldBits) + v)
		summary.go#L475: 		SampleSum:   proto.Float64(math.Float64frombits(atomic.LoadUint64(&coldCounts.sumBits))),
		summary.go#L486: 		newBits := math.Float64bits(math.Float64frombits(oldBits) + sum.GetSampleSum())

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

	golang.org/x/pkgsite/internal/godoc/codec
		codec.go#L316: 	return math.Float64frombits(d.DecodeUint())

	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#L277: 		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(0x80000000_00000000) // Negative zero.
		eisel_lemire.go#L91: 	return math.Float64frombits(retBits), true