[−][src]Trait rug::ops::Pow

pub trait Pow<Rhs> {
    type Output;
    fn pow(self, rhs: Rhs) -> Self::Output;
}

The power operation.

Examples

use rug::ops::Pow;
struct U(u32);
impl Pow<u16> for U {
    type Output = u32;
    fn pow(self, rhs: u16) -> u32 {
        self.0.pow(rhs as u32)
    }
}
let u = U(5);
assert_eq!(u.pow(2_u16), 25);

Associated Types

`type Output`

The resulting type after the power operation.

Loading content...

Required methods

`fn pow(self, rhs: Rhs) -> Self::Output`

Performs the power operation.

Examples

use rug::Integer;
use rug::ops::Pow;
let base = Integer::from(10);
let power = base.pow(5);
assert_eq!(power, 100_000);

Loading content...

Implementations on Foreign Types

`impl Pow<u32> for i8`
[src]

`type Output = i8`

`impl<'a> Pow<u32> for &'a i8`
[src]

`type Output = i8`

`impl<'a> Pow<&'a u32> for i8`
[src]

`type Output = i8`

`impl<'a, 'b> Pow<&'a u32> for &'b i8`
[src]

`type Output = i8`

`impl Pow<u32> for i16`
[src]

`type Output = i16`

`impl<'a> Pow<u32> for &'a i16`
[src]

`type Output = i16`

`impl<'a> Pow<&'a u32> for i16`
[src]

`type Output = i16`

`impl<'a, 'b> Pow<&'a u32> for &'b i16`
[src]

`type Output = i16`

`impl Pow<u32> for i32`
[src]

`type Output = i32`

`impl<'a> Pow<u32> for &'a i32`
[src]

`type Output = i32`

`impl<'a> Pow<&'a u32> for i32`
[src]

`type Output = i32`

`impl<'a, 'b> Pow<&'a u32> for &'b i32`
[src]

`type Output = i32`

`impl Pow<u32> for i64`
[src]

`type Output = i64`

`impl<'a> Pow<u32> for &'a i64`
[src]

`type Output = i64`

`impl<'a> Pow<&'a u32> for i64`
[src]

`type Output = i64`

`impl<'a, 'b> Pow<&'a u32> for &'b i64`
[src]

`type Output = i64`

`impl Pow<u32> for i128`
[src]

`type Output = i128`

`impl<'a> Pow<u32> for &'a i128`
[src]

`type Output = i128`

`impl<'a> Pow<&'a u32> for i128`
[src]

`type Output = i128`

`impl<'a, 'b> Pow<&'a u32> for &'b i128`
[src]

`type Output = i128`

`impl Pow<u32> for isize`
[src]

`type Output = isize`

`impl<'a> Pow<u32> for &'a isize`
[src]

`type Output = isize`

`impl<'a> Pow<&'a u32> for isize`
[src]

`type Output = isize`

`impl<'a, 'b> Pow<&'a u32> for &'b isize`
[src]

`type Output = isize`

`impl Pow<u32> for u8`
[src]

`type Output = u8`

`impl<'a> Pow<u32> for &'a u8`
[src]

`type Output = u8`

`impl<'a> Pow<&'a u32> for u8`
[src]

`type Output = u8`

`impl<'a, 'b> Pow<&'a u32> for &'b u8`
[src]

`type Output = u8`

`impl Pow<u32> for u16`
[src]

`type Output = u16`

`impl<'a> Pow<u32> for &'a u16`
[src]

`type Output = u16`

`impl<'a> Pow<&'a u32> for u16`
[src]

`type Output = u16`

`impl<'a, 'b> Pow<&'a u32> for &'b u16`
[src]

`type Output = u16`

`impl Pow<u32> for u32`
[src]

`type Output = u32`

`impl<'a> Pow<u32> for &'a u32`
[src]

`type Output = u32`

`impl<'a> Pow<&'a u32> for u32`
[src]

`type Output = u32`

`impl<'a, 'b> Pow<&'a u32> for &'b u32`
[src]

`type Output = u32`

`impl Pow<u32> for u64`
[src]

`type Output = u64`

`impl<'a> Pow<u32> for &'a u64`
[src]

`type Output = u64`

`impl<'a> Pow<&'a u32> for u64`
[src]

`type Output = u64`

`impl<'a, 'b> Pow<&'a u32> for &'b u64`
[src]

`type Output = u64`

`impl Pow<u32> for u128`
[src]

`type Output = u128`

`impl<'a> Pow<u32> for &'a u128`
[src]

`type Output = u128`

`impl<'a> Pow<&'a u32> for u128`
[src]

`type Output = u128`

`impl<'a, 'b> Pow<&'a u32> for &'b u128`
[src]

`type Output = u128`

`impl Pow<u32> for usize`
[src]

`type Output = usize`

`impl<'a> Pow<u32> for &'a usize`
[src]

`type Output = usize`

`impl<'a> Pow<&'a u32> for usize`
[src]

`type Output = usize`

`impl<'a, 'b> Pow<&'a u32> for &'b usize`
[src]

`type Output = usize`

`impl Pow<i32> for f32`
[src]

`type Output = f32`

`impl<'a> Pow<i32> for &'a f32`
[src]

`type Output = f32`

`impl<'a> Pow<&'a i32> for f32`
[src]

`type Output = f32`

`impl<'a, 'b> Pow<&'a i32> for &'b f32`
[src]

`type Output = f32`

`impl Pow<f32> for f32`
[src]

`type Output = f32`

`impl<'a> Pow<f32> for &'a f32`
[src]

`type Output = f32`

`impl<'a> Pow<&'a f32> for f32`
[src]

`type Output = f32`

`impl<'a, 'b> Pow<&'a f32> for &'b f32`
[src]

`type Output = f32`

`impl Pow<i32> for f64`
[src]

`type Output = f64`

`impl<'a> Pow<i32> for &'a f64`
[src]

`type Output = f64`

`impl<'a> Pow<&'a i32> for f64`
[src]

`type Output = f64`

`impl<'a, 'b> Pow<&'a i32> for &'b f64`
[src]

`type Output = f64`

`impl Pow<f64> for f64`
[src]

`type Output = f64`

`impl<'a> Pow<f64> for &'a f64`
[src]

`type Output = f64`

`impl<'a> Pow<&'a f64> for f64`
[src]

`type Output = f64`

`impl<'a, 'b> Pow<&'a f64> for &'b f64`
[src]

`type Output = f64`

`impl Pow<Float> for u32`
[src]

`type Output = Float`

`impl<'b> Pow<&'b Float> for u32`
[src]

`type Output = PowFromU32Incomplete<'b>`

`impl<'t> Pow<Float> for &'t u32`
[src]

`type Output = Float`

`impl<'b, 't> Pow<&'b Float> for &'t u32`
[src]

`type Output = PowFromU32Incomplete<'b>`

`impl Pow<Float> for i32`
[src]

`type Output = Float`

`impl<'b> Pow<&'b Float> for i32`
[src]

`type Output = PowFromI32Incomplete<'b>`

`impl<'t> Pow<Float> for &'t i32`
[src]

`type Output = Float`

`impl<'b, 't> Pow<&'b Float> for &'t i32`
[src]

`type Output = PowFromI32Incomplete<'b>`

`impl Pow<Float> for f64`
[src]

`type Output = Float`

`impl<'b> Pow<&'b Float> for f64`
[src]

`type Output = PowFromF64Incomplete<'b>`

`impl<'t> Pow<Float> for &'t f64`
[src]

`type Output = Float`

`impl<'b, 't> Pow<&'b Float> for &'t f64`
[src]

`type Output = PowFromF64Incomplete<'b>`

`impl Pow<Float> for f32`
[src]

`type Output = Float`

`impl<'b> Pow<&'b Float> for f32`
[src]

`type Output = PowFromF32Incomplete<'b>`

`impl<'t> Pow<Float> for &'t f32`
[src]

`type Output = Float`

`impl<'b, 't> Pow<&'b Float> for &'t f32`
[src]

`type Output = PowFromF32Incomplete<'b>`

Loading content...

Implementors

`impl Pow<f32> for Float`
[src]

`type Output = Float`

`impl Pow<f32> for Complex`
[src]

`type Output = Complex`

`impl Pow<f64> for Float`
[src]

`type Output = Float`

`impl Pow<f64> for Complex`
[src]

`type Output = Complex`

`impl Pow<i32> for Rational`
[src]

`type Output = Rational`

`impl Pow<i32> for Float`
[src]

`type Output = Float`

`impl Pow<i32> for Complex`
[src]

`type Output = Complex`

`impl Pow<u32> for Integer`
[src]

`type Output = Integer`

`impl Pow<u32> for Rational`
[src]

`type Output = Rational`

`impl Pow<u32> for Float`
[src]

`type Output = Float`

`impl Pow<u32> for Complex`
[src]

`type Output = Complex`

`impl Pow<Complex> for Complex`
[src]

`type Output = Complex`

`impl Pow<Float> for Complex`
[src]

`type Output = Complex`

`impl Pow<Float> for Float`
[src]

`type Output = Float`

`impl Pow<Integer> for Complex`
[src]

`type Output = Complex`

`impl Pow<Integer> for Float`
[src]

`type Output = Float`

`impl<'a> Pow<&'a Complex> for &'a Complex`
[src]

`type Output = PowIncomplete<'a>`

`impl<'a> Pow<&'a Complex> for Complex`
[src]

`type Output = Complex`

`impl<'a> Pow<&'a Float> for &'a Complex`
[src]

`type Output = PowFloatIncomplete<'a>`

`impl<'a> Pow<&'a Float> for &'a Float`
[src]

`type Output = PowIncomplete<'a>`

`impl<'a> Pow<&'a Float> for Complex`
[src]

`type Output = Complex`

`impl<'a> Pow<&'a Float> for Float`
[src]

`type Output = Float`

`impl<'a> Pow<&'a Integer> for &'a Complex`
[src]

`type Output = PowIntegerIncomplete<'a>`

`impl<'a> Pow<&'a Integer> for &'a Float`
[src]

`type Output = PowIntegerIncomplete<'a>`

`impl<'a> Pow<&'a Integer> for Complex`
[src]

`type Output = Complex`

`impl<'a> Pow<&'a Integer> for Float`
[src]

`type Output = Float`

`impl<'a> Pow<Complex> for &'a Complex`
[src]

`type Output = Complex`

`impl<'a> Pow<Float> for &'a Complex`
[src]

`type Output = PowOwnedFloatIncomplete<'a>`

`impl<'a> Pow<Float> for &'a Float`
[src]

`type Output = Float`

`impl<'a> Pow<Integer> for &'a Complex`
[src]

`type Output = PowOwnedIntegerIncomplete<'a>`

`impl<'a> Pow<Integer> for &'a Float`
[src]

`type Output = PowOwnedIntegerIncomplete<'a>`

`impl<'b> Pow<f32> for &'b Float`
[src]

`type Output = PowF32Incomplete<'b>`

`impl<'b> Pow<f32> for &'b Complex`
[src]

`type Output = PowF32Incomplete<'b>`

`impl<'b> Pow<f64> for &'b Float`
[src]

`type Output = PowF64Incomplete<'b>`

`impl<'b> Pow<f64> for &'b Complex`
[src]

`type Output = PowF64Incomplete<'b>`

`impl<'b> Pow<i32> for &'b Rational`
[src]

`type Output = PowI32Incomplete<'b>`

`impl<'b> Pow<i32> for &'b Float`
[src]

`type Output = PowI32Incomplete<'b>`

`impl<'b> Pow<i32> for &'b Complex`
[src]

`type Output = PowI32Incomplete<'b>`

`impl<'b> Pow<u32> for &'b Integer`
[src]

`type Output = PowU32Incomplete<'b>`

`impl<'b> Pow<u32> for &'b Rational`
[src]

`type Output = PowU32Incomplete<'b>`

`impl<'b> Pow<u32> for &'b Float`
[src]

`type Output = PowU32Incomplete<'b>`

`impl<'b> Pow<u32> for &'b Complex`
[src]

`type Output = PowU32Incomplete<'b>`

`impl<'t> Pow<&'t f32> for Float`
[src]

`type Output = Float`

`impl<'t> Pow<&'t f32> for Complex`
[src]

`type Output = Complex`

`impl<'t> Pow<&'t f64> for Float`
[src]

`type Output = Float`

`impl<'t> Pow<&'t f64> for Complex`
[src]

`type Output = Complex`

`impl<'t> Pow<&'t i32> for Rational`
[src]

`type Output = Rational`

`impl<'t> Pow<&'t i32> for Float`
[src]

`type Output = Float`

`impl<'t> Pow<&'t i32> for Complex`
[src]

`type Output = Complex`

`impl<'t> Pow<&'t u32> for Integer`
[src]

`type Output = Integer`

`impl<'t> Pow<&'t u32> for Rational`
[src]

`type Output = Rational`

`impl<'t> Pow<&'t u32> for Float`
[src]

`type Output = Float`

`impl<'t> Pow<&'t u32> for Complex`
[src]

`type Output = Complex`

`impl<'t, 'b> Pow<&'t f32> for &'b Float`
[src]

`type Output = PowF32Incomplete<'b>`

`impl<'t, 'b> Pow<&'t f32> for &'b Complex`
[src]

`type Output = PowF32Incomplete<'b>`

`impl<'t, 'b> Pow<&'t f64> for &'b Float`
[src]

`type Output = PowF64Incomplete<'b>`

`impl<'t, 'b> Pow<&'t f64> for &'b Complex`
[src]

`type Output = PowF64Incomplete<'b>`

`impl<'t, 'b> Pow<&'t i32> for &'b Rational`
[src]

`type Output = PowI32Incomplete<'b>`

`impl<'t, 'b> Pow<&'t i32> for &'b Float`
[src]

`type Output = PowI32Incomplete<'b>`

`impl<'t, 'b> Pow<&'t i32> for &'b Complex`
[src]

`type Output = PowI32Incomplete<'b>`

`impl<'t, 'b> Pow<&'t u32> for &'b Integer`
[src]

`type Output = PowU32Incomplete<'b>`

`impl<'t, 'b> Pow<&'t u32> for &'b Rational`
[src]

`type Output = PowU32Incomplete<'b>`

`impl<'t, 'b> Pow<&'t u32> for &'b Float`
[src]

`type Output = PowU32Incomplete<'b>`

`impl<'t, 'b> Pow<&'t u32> for &'b Complex`
[src]

`type Output = PowU32Incomplete<'b>`

Loading content...

[−][src]Trait rug::ops::Pow

Examples

Associated Types

type Output

Required methods

fn pow(self, rhs: Rhs) -> Self::Output

Examples

Implementations on Foreign Types

impl Pow<u32> for i8[src]

type Output = i8

fn pow(self, rhs: u32) -> i8[src]

impl<'a> Pow<u32> for &'a i8[src]

type Output = i8

fn pow(self, rhs: u32) -> i8[src]

impl<'a> Pow<&'a u32> for i8[src]

type Output = i8

fn pow(self, rhs: &u32) -> i8[src]

impl<'a, 'b> Pow<&'a u32> for &'b i8[src]

type Output = i8

fn pow(self, rhs: &u32) -> i8[src]

impl Pow<u32> for i16[src]

type Output = i16

fn pow(self, rhs: u32) -> i16[src]

impl<'a> Pow<u32> for &'a i16[src]

type Output = i16

fn pow(self, rhs: u32) -> i16[src]

impl<'a> Pow<&'a u32> for i16[src]

type Output = i16

fn pow(self, rhs: &u32) -> i16[src]

impl<'a, 'b> Pow<&'a u32> for &'b i16[src]

type Output = i16

fn pow(self, rhs: &u32) -> i16[src]

impl Pow<u32> for i32[src]

type Output = i32

fn pow(self, rhs: u32) -> i32[src]

impl<'a> Pow<u32> for &'a i32[src]

type Output = i32

fn pow(self, rhs: u32) -> i32[src]

impl<'a> Pow<&'a u32> for i32[src]

type Output = i32

fn pow(self, rhs: &u32) -> i32[src]

impl<'a, 'b> Pow<&'a u32> for &'b i32[src]

type Output = i32

fn pow(self, rhs: &u32) -> i32[src]

impl Pow<u32> for i64[src]

type Output = i64

fn pow(self, rhs: u32) -> i64[src]

impl<'a> Pow<u32> for &'a i64[src]

type Output = i64

fn pow(self, rhs: u32) -> i64[src]

impl<'a> Pow<&'a u32> for i64[src]

type Output = i64

fn pow(self, rhs: &u32) -> i64[src]

impl<'a, 'b> Pow<&'a u32> for &'b i64[src]

type Output = i64

fn pow(self, rhs: &u32) -> i64[src]

impl Pow<u32> for i128[src]

type Output = i128

fn pow(self, rhs: u32) -> i128[src]

impl<'a> Pow<u32> for &'a i128[src]

type Output = i128

fn pow(self, rhs: u32) -> i128[src]

impl<'a> Pow<&'a u32> for i128[src]

type Output = i128

fn pow(self, rhs: &u32) -> i128[src]

impl<'a, 'b> Pow<&'a u32> for &'b i128[src]

type Output = i128

fn pow(self, rhs: &u32) -> i128[src]

impl Pow<u32> for isize[src]

type Output = isize

fn pow(self, rhs: u32) -> isize[src]

impl<'a> Pow<u32> for &'a isize[src]

type Output = isize

fn pow(self, rhs: u32) -> isize[src]

impl<'a> Pow<&'a u32> for isize[src]

type Output = isize

fn pow(self, rhs: &u32) -> isize[src]

impl<'a, 'b> Pow<&'a u32> for &'b isize[src]

type Output = isize

fn pow(self, rhs: &u32) -> isize[src]

`type Output`

`fn pow(self, rhs: Rhs) -> Self::Output`

`impl Pow<u32> for i8`
[src]

`type Output = i8`

`fn pow(self, rhs: u32) -> i8`
[src]

`impl<'a> Pow<u32> for &'a i8`
[src]

`type Output = i8`

`fn pow(self, rhs: u32) -> i8`
[src]

`impl<'a> Pow<&'a u32> for i8`
[src]

`type Output = i8`

`fn pow(self, rhs: &u32) -> i8`
[src]

`impl<'a, 'b> Pow<&'a u32> for &'b i8`
[src]

`type Output = i8`

`fn pow(self, rhs: &u32) -> i8`
[src]

`impl Pow<u32> for i16`
[src]

`type Output = i16`

`fn pow(self, rhs: u32) -> i16`
[src]

`impl<'a> Pow<u32> for &'a i16`
[src]

`type Output = i16`

`fn pow(self, rhs: u32) -> i16`
[src]

`impl<'a> Pow<&'a u32> for i16`
[src]

`type Output = i16`

`fn pow(self, rhs: &u32) -> i16`
[src]

`impl<'a, 'b> Pow<&'a u32> for &'b i16`
[src]

`type Output = i16`

`fn pow(self, rhs: &u32) -> i16`
[src]

`impl Pow<u32> for i32`
[src]

`type Output = i32`

`fn pow(self, rhs: u32) -> i32`
[src]

`impl<'a> Pow<u32> for &'a i32`
[src]

`type Output = i32`

`fn pow(self, rhs: u32) -> i32`
[src]

`impl<'a> Pow<&'a u32> for i32`
[src]

`type Output = i32`

`fn pow(self, rhs: &u32) -> i32`
[src]

`impl<'a, 'b> Pow<&'a u32> for &'b i32`
[src]

`type Output = i32`

`fn pow(self, rhs: &u32) -> i32`
[src]

`impl Pow<u32> for i64`
[src]

`type Output = i64`

`fn pow(self, rhs: u32) -> i64`
[src]

`impl<'a> Pow<u32> for &'a i64`
[src]

`type Output = i64`

`fn pow(self, rhs: u32) -> i64`
[src]

`impl<'a> Pow<&'a u32> for i64`
[src]

`type Output = i64`

`fn pow(self, rhs: &u32) -> i64`
[src]

`impl<'a, 'b> Pow<&'a u32> for &'b i64`
[src]

`type Output = i64`

`fn pow(self, rhs: &u32) -> i64`
[src]

`impl Pow<u32> for i128`
[src]

`type Output = i128`

`fn pow(self, rhs: u32) -> i128`
[src]

`impl<'a> Pow<u32> for &'a i128`
[src]

`type Output = i128`

`fn pow(self, rhs: u32) -> i128`
[src]

`impl<'a> Pow<&'a u32> for i128`
[src]

`type Output = i128`

`fn pow(self, rhs: &u32) -> i128`
[src]

`impl<'a, 'b> Pow<&'a u32> for &'b i128`
[src]

`type Output = i128`

`fn pow(self, rhs: &u32) -> i128`
[src]

`impl Pow<u32> for isize`
[src]

`type Output = isize`

`fn pow(self, rhs: u32) -> isize`
[src]

`impl<'a> Pow<u32> for &'a isize`
[src]

`type Output = isize`

`fn pow(self, rhs: u32) -> isize`
[src]

`impl<'a> Pow<&'a u32> for isize`
[src]

`type Output = isize`

`fn pow(self, rhs: &u32) -> isize`
[src]

`impl<'a, 'b> Pow<&'a u32> for &'b isize`
[src]

`type Output = isize`

`fn pow(self, rhs: &u32) -> isize`
[src]

`impl Pow<u32> for u8`
[src]

`type Output = u8`

`fn pow(self, rhs: u32) -> u8`
[src]

`impl<'a> Pow<u32> for &'a u8`
[src]

`type Output = u8`

`fn pow(self, rhs: u32) -> u8`
[src]