math.Pow în Go

import "math"

func Pow(x, y float64) float64
func Pow10(n int) float64

Ce face math.Pow

Go nu are operator pentru putere (^ este SAU exclusiv pe biți, nu putere). Pentru x la puterea y folosești math.Pow(x, y): math.Pow(2, 10) dă 1024. Exponentul poate fi zecimal sau negativ: math.Pow(4, 0.5) este 2, math.Pow(2, -1) este 0.5.

math.Pow10(n) primește un int și returnează 10ⁿ. Este util pentru rotunjirea la un număr de zecimale sau pentru unități (kilo, mega).

Pentru o bază negativă și un exponent zecimal, rezultatul nu este real și Pow returnează NaN. Pentru puteri mici de întregi, o înmulțire simplă (x*x) este mai rapidă și exactă.

Parametri

Parametru	Descriere
x	Baza.
y	Exponentul (float64, poate fi negativ sau zecimal).
n	Pentru Pow10: exponentul întreg al lui 10.

Ce returnează

Rezultatul ridicării la putere, ca float64. Dacă depășește limita lui float64, rezultatul este +Inf.

Exemple

Exemplul 1: Puteri obișnuite

package main

import (
    "fmt"
    "math"
)

func main() {
    fmt.Println(math.Pow(2, 10))
    fmt.Println(math.Pow(4, 0.5))
    fmt.Println(math.Pow(2, -2))
    fmt.Println(math.Pow10(3))
    fmt.Println(math.Pow(-8, 1.0/3))
}

Rezultat

1024
2
0.25
1000
NaN

Exemplul 2: Dobândă compusă

Ana depune 1000 de lei la 5% pe an. După n ani suma este 1000 * 1.05n.

package main

import (
    "fmt"
    "math"
)

func main() {
    depozit := 1000.0
    for _, ani := range []float64{1, 5, 10} {
        suma := depozit * math.Pow(1.05, ani)
        fmt.Printf("După %2.0f ani: %.2f lei\n", ani, suma)
    }
}

Rezultat

După  1 ani: 1050.00 lei
După  5 ani: 1276.28 lei
După 10 ani: 1628.89 lei

Exemplul 3: Rotunjire la n zecimale cu Pow10

package main

import (
    "fmt"
    "math"
)

func rotunjeste(x float64, zecimale int) float64 {
    f := math.Pow10(zecimale)
    return math.Round(x*f) / f
}

func main() {
    fmt.Println(rotunjeste(3.14159, 2))
    fmt.Println(rotunjeste(2.71828, 3))
}

Rezultat

3.14
2.718

Greșeli frecvente

• Scrii 2 ^ 10 și aștepți 1024: în Go ^ este XOR pe biți, iar rezultatul este 8.
• Folosești Pow pentru puteri ale lui 2 la întregi: 1 << n este exact și mult mai rapid.

Comenzi înrudite

• math.Sqrt: math.Sqrt calculează rădăcina pătrată, iar math.Cbrt rădăcina cubică a unui număr float64.
• math.Exp: math.Exp calculează e la puterea x, math.Exp2 calculează 2 la puterea x, iar math.Expm1 calculează e^x – 1 precis.
• math.Log: Logaritmii din Go: Log (natural, baza e), Log10 (baza 10), Log2 (baza 2) și Log1p (ln(1+x) precis lângă 0).
• math.Round: math.Round rotunjește la cel mai apropiat întreg (jumătățile se duc departe de zero); RoundToEven duce jumătățile la par.