// GetFloat32 returns the float32 value with the colIdx.
969992
func (r Row) GetFloat32(colIdx int) float32 {
	col := r.c.columns[colIdx]
	return *(*float32)(unsafe.Pointer(&col.data[r.idx*4]))
}
187810
func (c *Config) GetFloat64(key string) (f float64) {
	f, _ = c.GetFloat64Ok(key)
	return
}
1340704
func (s *Session) PopFloat32(key string) float32 {
	r, _ := s.Pop(key).(float32)
	return r
}
433927
func (r *Reader) ReadFloat32() float32 {
	tag := r.readByte()
	decoder := float32Decoders[tag]
	if decoder == nil {
		castError(tag, "float32")
	}
	return decoder(r)
}
801387
func (fa *Float32Array) Float32ArrayOr(or []float32) []float32 {
	switch {
	case fa == nil:
		return or
	case !fa.Valid:
		return or
	default:
		return fa.Float32Array
	}
}
421162
func GetFloat64OrDefault(key string, defVal float64) float64 {
	viperLock.RLock()
	defer viperLock.RUnlock()

	if val := viper.GetFloat64(key); val != 0 {
		return val
	}

	return defVal
}
1143755
func Float32(v float32) *float32 {
	p := new(float32)
	*p = v
	return p
}
1352039
func ReadFloatFrom(data []byte) (Argument, int64, error) {
	var f Float
	if err := binary.Read(bytes.NewReader(data), byteOrder, &f); err != nil {
		return nil, 0, errors.Wrap(err, "read float argument")
	}
	return f, 4, nil
}
541406
func (f *Flash) GetFloat64(key string) float64 {
	r, _ := f.Get(key).(float64)
	return r
}
1030998
func GetFloat(key string) (float64, error) {
	value, err := Get(key)
	if err != nil {
		return 0, err
	}
	switch v := value.(type) {
	case float64:
		return v, nil
	case float32:
		return float64(v), nil
	case int:
		return float64(v), nil
	case string:
		if floatVal, err := strconv.ParseFloat(v, 64); err == nil {
			return floatVal, nil
		}
	}
	return 0, &InvalidValue{key, "float"}
}
208395
func getFloat(unk interface{}) float64 {
	switch i := unk.(type) {
	case float64:
		return i
	case string:
		f, err := strconv.ParseFloat(i, 64)
		if err != nil || math.IsNaN(f) {
			return float64(0)
		}
		return f
	default:
		return float64(0)
	}
}
153429
func (r *Encoder) EncodeFloat32(f float32) error {
	_, err := r.w.Write([]byte{CHR_FLOAT32})
	if err != nil {
		return err
	}
	return binary.Write(r.w, binary.BigEndian, f)
}
1275197
func SumFloat32(s []float32) (sum float32) {
	for _, v := range s {
		sum += v
	}
	return
}
74786
func GetFloatField(r *http.Request, fieldName string) (float64, error) {
	stringField, err := GetStringField(r, fieldName)
	if err != nil {
		return 0, err
	}
	floatField, err := strconv.ParseFloat(stringField, 64)
	if err != nil {
		return 0, InvalidFormatError{fieldName, stringField}
	}
	return floatField, nil
}
1216219
func ContainsFloat32(s []float32, v float32) bool {
	for _, vv := range s {
		if vv == v {
			return true
		}
	}
	return false
}
420349
func (context *BaseContext) GetFloat(
	key string, defaultValue ...float64) float64 {
	if value, ok := context.userData[key]; ok {
		if value, ok := value.(float64); ok {
			return value
		}
	}
	if len(defaultValue) > 0 {
		return defaultValue[0]
	}
	return 0
}
121920
func (dec *Decoder) DecodeFloat32(v *float32) error {
	if dec.isPooled == 1 {
		panic(InvalidUsagePooledDecoderError("Invalid usage of pooled decoder"))
	}
	return dec.decodeFloat32(v)
}