`i32::pow` în Rust

Ridică numărul la o putere întreagă nenegativă: 2.pow(10) = 1024.

Sintaxă

const fn pow(self, exp: u32) -> i32
const fn checked_pow(self, exp: u32) -> Option<i32>

Ce face `i32::pow`

x.pow(n) calculează x la puterea n. Exponentul are tipul u32, deci nu poate fi negativ. Rust nu are operator de putere (^ este SAU exclusiv pe biți), așa că se folosește această metodă.

Puterile cresc repede: 10_i32.pow(10) depășește deja i32::MAX. Ca orice operație, depășirea dă panică în debug. checked_pow returnează None în loc, iar saturating_pow se oprește la limită. Pentru puteri cu zecimale sau negative, folosește f64::powi / f64::powf.

Parametri

Parametru	Descriere
`exp`	Exponentul, de tip `u32`.

Ce returnează

i32 (la checked_pow: Option<i32>).

Exemple

Exemplul 1: Puteri ale lui 2 și ale lui 10

fn main() {
    for n in [0, 1, 8, 10, 16] {
        println!("2^{n} = {}", 2_i32.pow(n));
    }
    println!("(-3)^3 = {}", (-3_i32).pow(3));
    println!("10^9 = {}", 10_i32.pow(9));
    println!("10^10 cu checked_pow: {:?}", 10_i32.checked_pow(10));
    println!("10^10 cu i64: {}", 10_i64.pow(10));
}

Rezultat

2^0 = 1
2^1 = 2
2^8 = 256
2^10 = 1024
2^16 = 65536
(-3)^3 = -27
10^9 = 1000000000
10^10 cu checked_pow: None
10^10 cu i64: 10000000000

Exemplul 2: Câte combinații are un PIN

Un PIN de n cifre are 10^n combinații. Ne oprim când rezultatul nu mai încape în i32.

fn main() {
    for cifre in 4..=11 {
        match 10_i32.checked_pow(cifre) {
            Some(c) => println!("PIN de {cifre} cifre: {c} combinații"),
            None => {
                println!("PIN de {cifre} cifre: prea multe pentru i32");
                break;
            }
        }
    }
}