dexblog.ro
GO Toate comenzile Go

float32 și float64 în Go

Tipuri predefinite Go 1.0

Numere reale în virgulă mobilă: float64 (precizie dublă, tipul implicit) și float32 (precizie simplă).

Sintaxă 
var x float64 = 3.14
y := 2.5          // float64 implicit
var z float32 = 1.5
f := float64(n)

Ce face float32 și float64

float64 ține numere reale cu aproximativ 15–16 cifre semnificative și este tipul implicit pentru constantele cu zecimale (x := 2.5). float32 are circa 7 cifre și ocupă jumătate din memorie; se folosește în grafică, rețele neuronale sau când ai milioane de valori. Toate funcțiile din pachetul math lucrează cu float64.

Numerele reale sunt aproximări binare: 0.1 + 0.2 nu este exact 0.3. Compară-le cu o toleranță (math.Abs(a-b) < 1e-9), nu cu ==. Pentru sume de bani, calculează în bani întregi (int64, în bani nu în lei) sau rotunjește la afișare cu %.2f.

Împărțirea la zero cu numere reale nu dă panic, ci +Inf, -Inf sau NaN (care nu este egal nici cu el însuși). Conversia la întreg (int(x)) taie zecimalele; pentru rotunjire folosește math.Round.

Exemple

Exemplul 1: Calcule și afișare

package main

import (
    "fmt"
    "math"
)

func main() {
    note := []float64{9.5, 8.25, 10}
    suma := 0.0
    for _, n := range note {
        suma += n
    }
    medie := suma / float64(len(note))
    fmt.Println("media:", medie)
    fmt.Printf("media rotunjită: %.2f\n", medie)
    fmt.Println("int(medie):", int(medie), "math.Round:", math.Round(medie))
    fmt.Println("rădăcina lui 2:", math.Sqrt(2))
}

Rezultat

media: 9.25
media rotunjită: 9.25
int(medie): 9 math.Round: 9
rădăcina lui 2: 1.4142135623730951

Exemplul 2: Precizie, float32 și valori speciale

package main

import (
    "fmt"
    "math"
)

func main() {
    x, y := 0.1, 0.2
    a := x + y
    fmt.Println(a, a == 0.3, math.Abs(a-0.3) < 1e-9)

    var simplu float32 = 1.0 / 3
    var dublu float64 = 1.0 / 3
    fmt.Println(simplu, dublu)

    zero := 0.0
    fmt.Println(1/zero, -1/zero, zero/zero)
    nan := math.NaN()
    fmt.Println(nan == nan, math.IsNaN(nan))
}

Rezultat

0.30000000000000004 false true
0.33333334 0.3333333333333333
+Inf -Inf NaN
false true

Exemplul 3: Bani: calcul în bani întregi

Adunarea de 10 ori a lui 0.10 lei în float64 nu dă exact 1; în bani (int64) rezultatul este exact.

package main

import "fmt"

func main() {
    total := 0.0
    var totalBani int64
    for range 10 {
        total += 0.10
        totalBani += 10
    }
    fmt.Println("float64:", total, total == 1.0)
    fmt.Printf("în bani: %d.%02d lei\n", totalBani/100, totalBani%100)
}

Rezultat

float64: 0.9999999999999999 false
în bani: 1.00 lei

Greșeli frecvente

  • Compararea cu == după calcule: cu variabilele x, y := 0.1, 0.2, x+y == 0.3 este false. (Scris direct ca 0.1+0.2 == 0.3, cu constante, este true, pentru că constantele se calculează exact la compilare.)
  • Amestecarea cu int fără conversie: mismatched types float64 and int.
  • float32 pentru sume mari sau precise: pierde cifre după a 7-a.

Comenzi înrudite