`math.Gamma` în Go

Funcția Gamma (factorialul extins la numere reale) și Lgamma, logaritmul ei, util pentru valori mari.

Sintaxă

import "math"

func Gamma(x float64) float64
func Lgamma(x float64) (lgamma float64, sign int)

Ce face `math.Gamma`

Funcția Gamma extinde factorialul: pentru un întreg pozitiv n, Gamma(n) = (n−1)!. Deci math.Gamma(5) este 24 (4!). Funcționează și pentru numere zecimale: Gamma(0.5) este √π.

Factorialul crește foarte repede: peste Gamma(171.62) rezultatul nu mai încape în float64 și devine +Inf. math.Lgamma(x) returnează logaritmul natural al lui |Gamma(x)| și semnul lui Gamma(x) (+1 sau −1), ca să poți lucra cu valori uriașe, de exemplu la combinări.

Parametri

Parametru	Descriere
`x`	Numărul de intrare. Pentru 0 și întregi negativi Gamma nu este definită.

Ce returnează

Gamma: valoarea funcției. Lgamma: logaritmul valorii absolute și semnul.

Exemple

Exemplul 1: Gamma ca factorial

package main

import (
    "fmt"
    "math"
)

func main() {
    for n := 1.0; n <= 6; n++ {
        fmt.Printf("%v! = %v\n", n, math.Gamma(n+1))
    }
    fmt.Printf("Gamma(0.5) = %.4f, sqrt(pi) = %.4f\n", math.Gamma(0.5), math.Sqrt(math.Pi))
    fmt.Println(math.Gamma(200))
}

Rezultat

1! = 1
2! = 2
3! = 6
4! = 24
5! = 120
6! = 720
Gamma(0.5) = 1.7725, sqrt(pi) = 1.7725
+Inf

Exemplul 2: Combinări mari cu Lgamma

Numărul de variante la loto 6 din 49 este C(49, 6) = 49! / (6! · 43!). Cu logaritmi, factorialele uriașe nu depășesc limita.

package main

import (
    "fmt"
    "math"
)

func lnFactorial(n float64) float64 {
    v, _ := math.Lgamma(n + 1)
    return v
}

func main() {
    ln := lnFactorial(49) - lnFactorial(6) - lnFactorial(43)
    fmt.Printf("Variante la 6 din 49: %.0f\n", math.Round(math.Exp(ln)))

    v, semn := math.Lgamma(-0.5)
    fmt.Printf("Lgamma(-0.5) = %.4f, semn %d\n", v, semn)
}