// Float32s returns a slice of float32 without any duplicates in it.
358046
func Float32s(input []float32) []float32 {
	u := make([]float32, 0, len(input))
	m := make(map[float32]bool)

	for _, val := range input {
		if _, ok := m[val]; !ok {
			m[val] = true
			u = append(u, val)
		}
	}

	return u
}
707054
func PackFloat32(cmd BufferEx, val float32) (int, error) {
	return packFloat32(cmd, val)
}
1019255
func WriteFloat32Lossy(space []byte, val float32) []byte {
	if val < 0 {
		space = append(space, '-')
		val = -val
	}
	if val > 0x4ffffff {
		return WriteFloat32(space, val)
	}
	precision := 6
	exp := uint64(1000000) // 6
	lval := uint64(float64(val)*float64(exp) + 0.5)
	space = WriteUint64(space, lval / exp)
	fval := lval % exp
	if fval == 0 {
		return space
	}
	space = append(space, '.')
	for p := precision - 1; p > 0 && fval < pow10[p]; p-- {
		space = append(space, '0')
	}
	space = WriteUint64(space, fval)
	for space[len(space)-1] == '0' {
		space = space[:len(space) - 1]
	}
	return space
}
725400
func FilterFloat32(s []float32, cb func(s float32) bool) []float32 {
	results := []float32{}

	for _, i := range s {
		result := cb(i)

		if result {
			results = append(results, i)
		}
	}

	return results
}
454724
func (ctx *Context) FormFloat32(key string, defaults ...float32) float32 {
	return (*Forms)(ctx.req).MustFloat32(key, defaults...)
}
893007
func (p *Params) Float32(key string) (float32, error) {
	v, err := strconv.ParseFloat(p.Get(key), 32)
	return float32(v), err
}
903815
func (c Context) Float32(key string, f float32) Context {
	c.l.context = enc.AppendFloat32(enc.AppendKey(c.l.context, key), f)
	return c
}
267742
func Uint32s(b0, b1 []uint32) int {
	d := 0
	for i, x := range b0 {
		d += Uint32(x, b1[i])
	}
	return d
}
54045
func (f *Queries) MustFloat32(key string, defaults ...float32) float32 {
	if v, ok := f.Values()[key]; ok {
		i, err := strconv.ParseFloat(v[0], 32)
		if err == nil {
			return float32(i)
		}
	}
	if len(defaults) > 0 {
		return defaults[0]
	}
	return 0
}
884312
func Float32Array(name string, values []float32) FieldOpt {
	return func(em *eventMetadata, ed *eventData) {
		em.writeArray(name, inTypeFloat, outTypeDefault, 0)
		ed.writeUint16(uint16(len(values)))
		for _, v := range values {
			ed.writeUint32(math.Float32bits(v))
		}
	}
}
1354361
func (dec *Decoder) Float32(v *float32) error {
	err := dec.decodeFloat32(v)
	if err != nil {
		return err
	}
	dec.called |= 1
	return nil
}
852035
func (ctx *Context) ParamFloat32(key string, defaults ...float32) float32 {
	return ctx.Params().MustFloat32(key, defaults...)
}
295595
func StringToFloat32(from string) (float32, error) {
	val, err := strconv.ParseFloat(from, 32)
	return float32(val), err
}
613500
func Float32P(val string) (*float32, error) {
	f, err := Float32(val)
	if err != nil {
		return nil, err
	}
	return proto.Float32(f), nil
}
1351259
func (k *Key) Float64s(delim string) []float64 {
	vals, _ := k.parseFloat64s(k.Strings(delim), true, false)
	return vals
}
879939
func (w *ByteWriter) WriteFloat32(val float32, offset int) (int, error) {
	return w.WriteVal(val, offset)
}
410235
func (Encoder) AppendFloats32(dst []byte, vals []float32) []byte {
	if len(vals) == 0 {
		return append(dst, '[', ']')
	}
	dst = append(dst, '[')
	dst = appendFloat(dst, float64(vals[0]), 32)
	if len(vals) > 1 {
		for _, val := range vals[1:] {
			dst = appendFloat(append(dst, ','), float64(val), 32)
		}
	}
	dst = append(dst, ']')
	return dst
}