Exponenciación en Rust: mejores prácticas 2025 (no Python)

«¿Se puede simplemente escribir a ** b en Rust?» — Preguntarás y… te equivocarás

Si vienes a Rust desde Python, el primer shock es la ausencia del operador **. El segundo shock es que el compilador no perdona las libertades con los tipos. El tercero (agradable) es que Rust ofrece todo un arsenal de herramientas para la exponenciación, cada una diseñada para una tarea específica.

En 2025, cuando Rust está desplazando activamente a C++ en sistemas de alta carga y desarrollo embebido, la pregunta «How to raise a number to a power?» (que ha acumulado miles de visitas en Stack Overflow) se ha vuelto aún más relevante. Analicemos de una vez por todas: cómo elevar números a una potencia de forma correcta, rápida y segura en Rust.

¿Por qué no hay operador ** en Rust?

Rust es un lenguaje de sistemas. No permite la sobrecarga de operadores «sobre la marcha» (aunque existen los traits std::ops, pero no para la exponenciación). En su lugar, los desarrolladores propusieron métodos-función que indican explícitamente el tipo de operación. Esto elimina la confusión entre la exponenciación de enteros y la aritmética de punto flotante.

Regla clave: elige el método según el tipo de datos. No intentes elevar un i32 a una potencia f64 — el compilador no te entenderá, y si lo hace (mediante conversión), corres el riesgo de perder rendimiento o precisión.

Método pow() — el rey de los enteros

La forma más popular para i32, u64 y otros tipos enteros:

fn main() {\n    let base: i32 = 5;\n    let exponent: u32 = 3;\n    let result = base.pow(exponent);\n    println!("5^3 = {}", result); // 125\n}

Observa: exponent siempre debe ser u32 (sin signo). Es lógico: la potencia no puede ser negativa para números enteros (de lo contrario obtendrías una fracción).

Cuándo usarlo: siempre para cálculos con enteros. Funciona rápido, sin asignaciones, a nivel de instrucciones de máquina.

¿Y si la potencia es negativa?

Para enteros, de ninguna manera. Rust no admite potencias negativas para tipos enteros porque el resultado sería fraccionario. Si necesitas 2^-3 — pasa a números de punto flotante.

powi() — la elección ideal para f64 y f32

Este método acepta un exponente entero (tipo i32), pero trabaja con números de punto flotante:

fn main() {\n    let base: f64 = 2.0;\n    let result = base.powi(-3);\n    println!("2.0^-3 = {}", result); // 0.125\n\n    // También se puede con potencia positiva\n    let result2 = base.powi(10);\n    println!("2.0^10 = {}", result2); // 1024.0\n}

Novedad 2025: powi() está optimizado para exponentes enteros. Utiliza el algoritmo de exponenciación rápida (exponentiation by squaring). Si tu exponente es una constante o un número entero, esta es la forma más rápida para f64/f32.

powf() — cuando la potencia también es fraccionaria

Si tanto la base como el exponente son números de punto flotante, usa powf():

fn main() {\n    let base: f64 = 9.0;\n    let exponent: f64 = 0.5;\n    let result = base.powf(exponent);\n    println!("9.0^0.5 = {}", result); // 3.0 (raíz cuadrada)\n\n    // Caso complejo\n    let base2 = 2.0_f64;\n    let exp2 = 3.14_f64;\n    println!("2.0^3.14 = {}", base2.powf(exp2)); // ~8.815\n}

Importante: powf() utiliza una biblioteca matemática lenta pero precisa (generalmente libm o una instrucción de hardware). Para gráficos o juegos donde la velocidad es importante, considera powi().

Crate num — el soldado universal

En 2025, el ecosistema de Rust ofrece el crate num (y num-