Convertir un entier en un nombre à virgule flottante

Question

Comment convertir une valeur entière en type float64 ?

J'ai essayé

float(valeur_entière)

Mais cela ne fonctionne pas. Et je ne trouve aucun package sur Golang.org qui le fait.

Comment obtenir des valeurs float64 à partir de valeurs entières ?

Answer 1

Il n'y a pas de type float. Il semble que vous voulez float64. Vous pourriez également utiliser float32 si vous avez seulement besoin d'une valeur de point flottant en simple précision.

package main

import "fmt"

func main() {
    i := 5
    f := float64(i)
    fmt.Printf("f est %f\n", f)
}

Answer 2

Pour des raisons de complétude, voici un lien vers la documentation de golang qui décrit tous les types. Dans votre cas, ce sont des types numériques:

uint8       l'ensemble de tous les entiers non signés sur 8 bits (0 à 255)
uint16      l'ensemble de tous les entiers non signés sur 16 bits (0 à 65535)
uint32      l'ensemble de tous les entiers non signés sur 32 bits (0 à 4294967295)
uint64      l'ensemble de tous les entiers non signés sur 64 bits (0 à 18446744073709551615)

int8        l'ensemble de tous les entiers signés sur 8 bits (-128 à 127)
int16       l'ensemble de tous les entiers signés sur 16 bits (-32768 à 32767)
int32       l'ensemble de tous les entiers signés sur 32 bits (-2147483648 à 2147483647)
int64       l'ensemble de tous les entiers signés sur 64 bits (-9223372036854775808 à 9223372036854775807)

float32     l'ensemble de tous les nombres flottants sur 32 bits de la norme IEEE-754
float64     l'ensemble de tous les nombres flottants sur 64 bits de la norme IEEE-754

complex64   l'ensemble de tous les nombres complexes avec des parties réelles et imaginaires en float32
complex128  l'ensemble de tous les nombres complexes avec des parties réelles et imaginaires en float64

byte        alias pour uint8
rune        alias pour int32

Cela signifie que vous devez utiliser float64(valeur_entière).

Answer 3

Simplement faire ces

package main

func main(){
a:= 70
afloat := float64(a)
    fmt.Printf("type de a est %T\n", a) // sera int
    fmt.Printf("type de a est %T\n", afloat) //sera float64
}

Answer 4

intutils.ToFloat32

// ToFloat32 convertit un nombre entier en un nombre float32
fonction ToFloat32(in int) float32 {
    retourner float32(in)
}

// ToFloat64 convertit un nombre entier en un nombre float64
fonction ToFloat64(in int) float64 {
    retourner float64(in)
}

Answer 5

Placement correct des parenthèses est la clé :

package main

import (
    "fmt"
)

func main() {

    var payload uint32
    var fpayload float32
    payload = 1320

    // fonctionne
    fpayload = float32(payload) / 100.0
    fmt.Printf("%T = %d, %T = %f\n", payload, payload, fpayload, fpayload)

    // ne fonctionne pas
    fpayload = float32(payload / 100.0)
    fmt.Printf("%T = %d, %T = %f\n", payload, payload, fpayload, fpayload)
}

résultats :

uint32 = 1320, float32 = 13.200000

uint32 = 1320, float32 = 13.000000

Le Go Playground