// Float64 returns, as a float64, a pseudo-random number in [0.0,1.0).
344670
func (r *Rand) Float64() float64 {
	// A clearer, simpler implementation would be:
	//	return float64(Int63n(1<<53)) / (1<<53)
	// However, Go 1 shipped with
	//	return float64(Int63()) / (1 << 63)
	// and we want to preserve that value stream.
	//
	// There is one bug in the value stream: Int63() may be so close
	// to 1<<63 that the division rounds up to 1.0, and we've guaranteed
	// that the result is always less than 1.0. To fix that, we treat the
	// range as cyclic and map 1 back to 0. This is justified by observing
	// that while some of the values rounded down to 0, nothing was
	// rounding up to 0, so 0 was underrepresented in the results.
	// Mapping 1 back to zero restores some balance.
	// (The balance is not perfect because the implementation
	// returns denormalized numbers for very small Int63(),
	// and those steal from what would normally be 0 results.)
	// The remapping only happens 1/2⁵³ of the time, so most clients
	// will not observe it anyway.
	f := float64(r.Int63()) / (1 << 63)
	if f == 1 {
		f = 0
	}
	return f
}
991559
func (h Hash) Float64(key string) (float64, error) {
	if value, ok := h[key]; ok {
		return value.Float64()
	}
	return 0.0, errors.New(ErrInvalidKey, errorMessages, key)
}
849055
func Float(v float64) *float64 {
	ptr := new(float64)
	*ptr = v
	return ptr
}
729291
func _float64f(v interface{}) (float64, bool) {

	f, ok := _float64(v)
	if ok {
		return f, true
	}

	i, ok := _int64(v)
	if ok {
		return float64(i), true
	}

	s := _string(v)
	f, err := strconv.ParseFloat(s, 64)
	if err == nil {
		return f, true
	}

	return 0, false
}
473355
func Float64(name string, value float64, usage string) *float64 {
	return CommandLine.Float64(name, value, usage)
}
1221470
func (d *Drain) Float64(p Proxy) float64 {
	v, err := p.Float64()
	d.put(err)
	return v
}
534451
func NewFloat64(into *float64, v float64) *Float64Value {
	*into = v
	return (*Float64Value)(into)
}
614239
func _float64(i interface{}) (float64, bool) {

	switch v := i.(type) {

	case float32:
		return float64(v), true
	case float64:
		return v, true
	}

	return 0, false
}
1226259
func (d *Decoder) DecodeFloat64() (float64, error) {
	c, err := d.readCode()
	if err != nil {
		return 0, err
	}
	return d.float64(c)
}
1239108
func (enc *Encoder) Float64(v float64) {
	enc.grow(10)
	r := enc.getPreviousRune()
	if r != '[' {
		enc.writeByte(',')
	}
	enc.buf = strconv.AppendFloat(enc.buf, v, 'f', -1, 64)
}
453663
func (c *Config) Float64(key string) (float64, error) {
	return strconv.ParseFloat(c.get(key), 64)
}
1356964
func (t Section) Float64(k string) float64 {
	return t.values[k].FloatValue()
}
1232271
func (f *FlagSet) Float64(name string, value float64, usage string) *float64 {
	p := new(float64)
	f.Float64Var(p, name, value, usage)
	return p
}
344232
func NewFloat64(v float64) Value {
	return MakeTrusted(Float64, strconv.AppendFloat(nil, v, 'g', -1, 64))
}
1107552
func Float(v float64) *float64 {
	p := new(float64)
	*p = v
	return p
}
39679
func Float64(names []string, value float64, usage string) *float64 {
	return CommandLine.Float64(names, value, usage)
}
859685
func (d *MyDecimal) FromFloat64(f float64) error {
	s := strconv.FormatFloat(f, 'g', -1, 64)
	return d.FromString([]byte(s))
}