125

I was trying to raise an integer to a power using the caret operator (^), but I am getting surprising results, e.g.:

assert_eq!(2^10, 8);

How can I perform exponentiation in Rust?

Zombo
  • 1
  • 62
  • 391
  • 407
Matthias Braun
  • 32,039
  • 22
  • 142
  • 171

6 Answers6

155

Rust provides exponentiation via methods pow and checked_pow. The latter guards against overflows. Thus, to raise 2 to the power of 10, do:

let base: i32 = 2; // an explicit type is required
assert_eq!(base.pow(10), 1024);

The caret operator ^ is not used for exponentiation, it's the bitwise XOR operator.

alexh
  • 354
  • 2
  • 10
Matthias Braun
  • 32,039
  • 22
  • 142
  • 171
  • 1
    is this optimized by `2 << 9` ? – Stargateur Jul 06 '18 at 11:16
  • 5
    @Stargateur In such cases the compiler optimizes the whole operation away, but it doesn't seem like it when the base is not known: [godbolt](https://godbolt.org/g/VJKgn1). – ljedrz Jul 06 '18 at 11:18
  • just tried this as a part of a constant and got the error that it is unstable for use in a constant. Putting it out in case someone else is trying the same. I'm on `rustc 1.54.0 (a178d0322 2021-07-26)` – unixia Sep 07 '21 at 12:17
38

Here is the simplest method which you can use:

let a = 2; // Can also explicitly define type i.e. i32
let a = i32::pow(a, 10);

It will output "2 raised to the power of 10", i.e.:

1024

Matthias Braun
  • 32,039
  • 22
  • 142
  • 171
Rohan
  • 389
  • 3
  • 2
13

For integers:

fn main() {
   let n = u32::pow(2, 10);
   println!("{}", n == 1024);
}

For floats:

fn main() {
   // example 1
   let f = f32::powf(2.0, 10.0);
   // example 2
   let g = f32::powi(2.0, 10);
   // print
   println!("{}", f == 1024.0 && g == 1024.0);
}

or, since your base is 2, you can also use shift:

fn main() {
   let n = 2 << 9;
   println!("{}", n == 1024);
}
Zombo
  • 1
  • 62
  • 391
  • 407
  • 1
    `2<<9` is an odd choice; why not `4<<8` or `64<<4`? If what you want is 2 to the _10th_ power, to me it seems that the most logical expression is the one with a 10 in it: `1<<10`. – Mark Reed Feb 23 '23 at 00:55
9

I was trying the same thing as the OP. Thanks to the other answer authors.

Here's a variation that works for me:

let n = 2u32.pow(10);

This uses a literal unsigned 32 bit integer to set the type and base, then calls the pow() function on it.

MorganGalpin
  • 685
  • 6
  • 7
3

Bit shifting is a good way to do this particular case:

assert_eq!(1 << 10, 1024);
Christian Oudard
  • 48,140
  • 25
  • 66
  • 69
1

There's a shortcut for a literal in scientific notation. The number 1e9 is a literal for 1 * i32::pow(10, 9).

Danny Staple
  • 7,101
  • 4
  • 43
  • 56