arrays - iterating - in array golang

Convertir la matriz de bytes "[] uint8" a float64 en GoLang

Question

Estoy tratando de convertir una matriz de bytes []uint8 en un float64 en GoLang. No puedo encontrar una solución para este problema en línea. He visto sugerencias de convertir primero a una cadena y luego a float64 pero esto no parece funcionar, pierde su valor y float64 con ceros.

Ejemplo:

metric.Value, _ = strconv.ParseFloat(string(column.Value), 64)

Y no funciona ...

Answer 1

A medida que los comentarios se leen, todo depende del tipo de datos que tenga en su []uint8 .

Si son bytes que representan un valor de punto flotante IEEE 754 en el orden de Little Endian, entonces use la respuesta de Kluyg o peterSo (mejor rendimiento sin uso de reflexión).

Si es una representación textual en la codificación Latin-1 / UTF-8, entonces debería poder hacer lo que acaba de hacer:

package main
import (
"fmt"
"strconv"
)
func main() {
var f float64
text := []uint8("1.23") // A decimal value represented as Latin-1 text
f, err := strconv.ParseFloat(string(text), 64)
if err != nil {
panic(err)
}
fmt.Println(f)
}

Resultado:

1.23

Área de juegos: http://play.golang.org/p/-7iKRDG_ZM

Answer 2

Creo que este ejemplo de la documentación de Go es lo que está buscando: http://golang.org/pkg/encoding/binary/#example_Read

var pi float64
b := []byte{0x18, 0x2d, 0x44, 0x54, 0xfb, 0x21, 0x09, 0x40}
buf := bytes.NewReader(b)
err := binary.Read(buf, binary.LittleEndian, &pi)
if err != nil {
fmt.Println("binary.Read failed:", err)
}
fmt.Print(pi)

Impresiones 3.141592653589793

Answer 3

Espero que este hack te ayude. El propósito de esto es convertir el flujo largo de números binarios a flotar.

Por ejemplo: 01101111000100101000001111000011001010001000010000100111000000 -> -3.1415

func binFloat(bin string) float64 {
var s1 []byte
var result float64
if len(bin) % 8 == 0 {
for i := 0; i < len(bin) / 8; i++ {
//Chop the strings into a segment with a length of 8.
//Convert the string to Integer and to byte
num, _ := strconv.ParseInt(bin[8*i: 8*(i + 1)], 2, 64)
//Store the byte into a slice s1
s1 = append(s1, byte(num))
}
}
//convert the byte slice to a float64.
//The algorithm below are copied from golang binary examples.
buf := bytes.NewReader(s1)
//You can also change binary.LittleEndian to binary.BigEndian
//For the details of Endianness, please google Endianness
err := binary.Read(buf, binary.LittleEndian, &result)
if err != nil {
panic(err)
fmt.Println("Length of the binary is not in the length of 8")
}
return result
}

Answer 4

Por ejemplo,

package main
import (
"encoding/binary"
"fmt"
"math"
)
func Float64frombytes(bytes []byte) float64 {
bits := binary.LittleEndian.Uint64(bytes)
float := math.Float64frombits(bits)
return float
}
func Float64bytes(float float64) []byte {
bits := math.Float64bits(float)
bytes := make([]byte, 8)
binary.LittleEndian.PutUint64(bytes, bits)
return bytes
}
func main() {
bytes := Float64bytes(math.Pi)
fmt.Println(bytes)
float := Float64frombytes(bytes)
fmt.Println(float)
}

Salida:

[24 45 68 84 251 33 9 64]
3.141592653589793