`f64::powi` în Rust

powi ridică la o putere întreagă (poate fi negativă), powf la o putere cu zecimale.

Sintaxă

fn powi(self, n: i32) -> f64
fn powf(self, n: f64) -> f64

Ce face `f64::powi`

x.powi(n) calculează x la puterea n, unde n este i32, deci poate fi și negativ: 2.0.powi(-1) == 0.5. De obicei este mai rapid decât powf, dar poate avea o eroare de rotunjire puțin mai mare.

x.powf(y) acceptă orice exponent f64: 8.0.powf(1.0 / 3.0) este rădăcina cubică, iar x.powf(0.5) este rădăcina pătrată. Pentru bază negativă și exponent cu zecimale, rezultatul este NaN.

Parametri

Parametru	Descriere
`n`	Exponentul: `i32` la `powi`, `f64` la `powf`.

Ce returnează

f64.

Exemple

Exemplul 1: Dobândă compusă

1000 de lei la 5% pe an, timp de n ani: 1000 * 1.05^n.

fn main() {
    let suma = 1000.0_f64;
    let dobanda = 0.05_f64;
    for ani in [1, 5, 10, 20] {
        let final_ = suma * (1.0 + dobanda).powi(ani);
        println!("după {ani:2} ani: {final_:.2} lei");
    }
    println!("valoarea de azi a 1000 lei peste 10 ani: {:.2} lei", suma * (1.0 + dobanda).powi(-10));
}

Rezultat

după  1 ani: 1050.00 lei
după  5 ani: 1276.28 lei
după 10 ani: 1628.89 lei
după 20 ani: 2653.30 lei
valoarea de azi a 1000 lei peste 10 ani: 613.91 lei

Exemplul 2: Exponenți cu zecimale

fn main() {
    println!("2^10 = {}", 2.0_f64.powi(10));
    println!("2^0.5 = {}", 2.0_f64.powf(0.5));
    println!("8^(1/3) = {}", 8.0_f64.powf(1.0 / 3.0));
    println!("27^(1/3) = {}", 27.0_f64.powf(1.0 / 3.0));
    println!("(-8)^(1/3) = {}", (-8.0_f64).powf(1.0 / 3.0));
    println!("cbrt(-8) = {}", (-8.0_f64).cbrt());
}