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

type Output = i8

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

impl<'_> Pow<u32> for &'_ i8

type Output = i8

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

impl<'_> Pow<&'_ u32> for i8

type Output = i8

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

impl<'_, '_> Pow<&'_ u32> for &'_ i8

type Output = i8

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

impl Pow<u32> for i16

type Output = i16

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

impl<'_> Pow<u32> for &'_ i16

type Output = i16

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

impl<'_> Pow<&'_ u32> for i16

type Output = i16

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

impl<'_, '_> Pow<&'_ u32> for &'_ i16

type Output = i16

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

impl Pow<u32> for i32

type Output = i32

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

impl<'_> Pow<u32> for &'_ i32

type Output = i32

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

impl<'_> Pow<&'_ u32> for i32

type Output = i32

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

impl<'_, '_> Pow<&'_ u32> for &'_ i32

type Output = i32

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

impl Pow<u32> for i64

type Output = i64

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

impl<'_> Pow<u32> for &'_ i64

type Output = i64

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

impl<'_> Pow<&'_ u32> for i64

type Output = i64

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

impl<'_, '_> Pow<&'_ u32> for &'_ i64

type Output = i64

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

impl Pow<u32> for i128

type Output = i128

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

impl<'_> Pow<u32> for &'_ i128

type Output = i128

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

impl<'_> Pow<&'_ u32> for i128

type Output = i128

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

impl<'_, '_> Pow<&'_ u32> for &'_ i128

type Output = i128

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

impl Pow<u32> for isize

type Output = isize

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

impl<'_> Pow<u32> for &'_ isize

type Output = isize

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

impl<'_> Pow<&'_ u32> for isize

type Output = isize

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

impl<'_, '_> Pow<&'_ u32> for &'_ isize

type Output = isize

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

impl Pow<u32> for u8

type Output = u8

fn pow(self, rhs: u32) -> u8

impl<'_> Pow<u32> for &'_ u8

type Output = u8

fn pow(self, rhs: u32) -> u8

impl<'_> Pow<&'_ u32> for u8

type Output = u8

fn pow(self, rhs: &u32) -> u8

impl<'_, '_> Pow<&'_ u32> for &'_ u8

type Output = u8

fn pow(self, rhs: &u32) -> u8

impl Pow<u32> for u16

type Output = u16

fn pow(self, rhs: u32) -> u16

impl<'_> Pow<u32> for &'_ u16

type Output = u16

fn pow(self, rhs: u32) -> u16

impl<'_> Pow<&'_ u32> for u16

type Output = u16

fn pow(self, rhs: &u32) -> u16

impl<'_, '_> Pow<&'_ u32> for &'_ u16

type Output = u16

fn pow(self, rhs: &u32) -> u16

impl Pow<u32> for u32

type Output = u32

fn pow(self, rhs: u32) -> u32

impl<'_> Pow<u32> for &'_ u32

type Output = u32

fn pow(self, rhs: u32) -> u32

impl<'_> Pow<&'_ u32> for u32

type Output = u32

fn pow(self, rhs: &u32) -> u32

impl<'_, '_> Pow<&'_ u32> for &'_ u32

type Output = u32

fn pow(self, rhs: &u32) -> u32

impl Pow<u32> for u64

type Output = u64

fn pow(self, rhs: u32) -> u64

impl<'_> Pow<u32> for &'_ u64

type Output = u64

fn pow(self, rhs: u32) -> u64

impl<'_> Pow<&'_ u32> for u64

type Output = u64

fn pow(self, rhs: &u32) -> u64

impl<'_, '_> Pow<&'_ u32> for &'_ u64

type Output = u64

fn pow(self, rhs: &u32) -> u64

impl Pow<u32> for u128

type Output = u128

fn pow(self, rhs: u32) -> u128

impl<'_> Pow<u32> for &'_ u128

type Output = u128

fn pow(self, rhs: u32) -> u128

impl<'_> Pow<&'_ u32> for u128

type Output = u128

fn pow(self, rhs: &u32) -> u128

impl<'_, '_> Pow<&'_ u32> for &'_ u128

type Output = u128

fn pow(self, rhs: &u32) -> u128

impl Pow<u32> for usize

type Output = usize

fn pow(self, rhs: u32) -> usize

impl<'_> Pow<u32> for &'_ usize

type Output = usize

fn pow(self, rhs: u32) -> usize

impl<'_> Pow<&'_ u32> for usize

type Output = usize

fn pow(self, rhs: &u32) -> usize

impl<'_, '_> Pow<&'_ u32> for &'_ usize

type Output = usize

fn pow(self, rhs: &u32) -> usize

impl Pow<i32> for f32

type Output = f32

fn pow(self, rhs: i32) -> f32

impl<'_> Pow<i32> for &'_ f32

type Output = f32

fn pow(self, rhs: i32) -> f32

impl<'_> Pow<&'_ i32> for f32

type Output = f32

fn pow(self, rhs: &i32) -> f32

impl<'_, '_> Pow<&'_ i32> for &'_ f32

type Output = f32

fn pow(self, rhs: &i32) -> f32

impl Pow<f32> for f32

type Output = f32

fn pow(self, rhs: f32) -> f32

impl<'_> Pow<f32> for &'_ f32

type Output = f32

fn pow(self, rhs: f32) -> f32

impl<'_> Pow<&'_ f32> for f32

type Output = f32

fn pow(self, rhs: &f32) -> f32

impl<'_, '_> Pow<&'_ f32> for &'_ f32

type Output = f32

fn pow(self, rhs: &f32) -> f32

impl Pow<i32> for f64

type Output = f64

fn pow(self, rhs: i32) -> f64

impl<'_> Pow<i32> for &'_ f64

type Output = f64

fn pow(self, rhs: i32) -> f64

impl<'_> Pow<&'_ i32> for f64

type Output = f64

fn pow(self, rhs: &i32) -> f64

impl<'_, '_> Pow<&'_ i32> for &'_ f64

type Output = f64

fn pow(self, rhs: &i32) -> f64

impl Pow<f64> for f64

type Output = f64

fn pow(self, rhs: f64) -> f64

impl<'_> Pow<f64> for &'_ f64

type Output = f64

fn pow(self, rhs: f64) -> f64

impl<'_> Pow<&'_ f64> for f64

type Output = f64

fn pow(self, rhs: &f64) -> f64

impl<'_, '_> Pow<&'_ f64> for &'_ f64

type Output = f64

fn pow(self, rhs: &f64) -> f64

impl Pow<Float> for u32

type Output = Float

fn pow(self, rhs: Float) -> Float

impl<'b> Pow<&'b Float> for u32

type Output = PowFromU32Incomplete<'b>

fn pow(self, rhs: &Float) -> PowFromU32Incomplete

impl<'_> Pow<Float> for &'_ u32

type Output = Float

fn pow(self, rhs: Float) -> Float

impl<'b, '_> Pow<&'b Float> for &'_ u32

type Output = PowFromU32Incomplete<'b>

fn pow(self, rhs: &'b Float) -> PowFromU32Incomplete<'b>

impl Pow<Float> for i32

type Output = Float

fn pow(self, rhs: Float) -> Float

impl<'b> Pow<&'b Float> for i32

type Output = PowFromI32Incomplete<'b>

fn pow(self, rhs: &Float) -> PowFromI32Incomplete

impl<'_> Pow<Float> for &'_ i32

type Output = Float

fn pow(self, rhs: Float) -> Float

impl<'b, '_> Pow<&'b Float> for &'_ i32

type Output = PowFromI32Incomplete<'b>

fn pow(self, rhs: &'b Float) -> PowFromI32Incomplete<'b>

impl Pow<Float> for f64

type Output = Float

fn pow(self, rhs: Float) -> Float

impl<'b> Pow<&'b Float> for f64

type Output = PowFromF64Incomplete<'b>

fn pow(self, rhs: &Float) -> PowFromF64Incomplete

impl<'_> Pow<Float> for &'_ f64

type Output = Float

fn pow(self, rhs: Float) -> Float

impl<'b, '_> Pow<&'b Float> for &'_ f64

type Output = PowFromF64Incomplete<'b>

fn pow(self, rhs: &'b Float) -> PowFromF64Incomplete<'b>

impl Pow<Float> for f32

type Output = Float

fn pow(self, rhs: Float) -> Float

impl<'b> Pow<&'b Float> for f32

type Output = PowFromF32Incomplete<'b>

fn pow(self, rhs: &Float) -> PowFromF32Incomplete

impl<'_> Pow<Float> for &'_ f32

type Output = Float

fn pow(self, rhs: Float) -> Float

impl<'b, '_> Pow<&'b Float> for &'_ f32

type Output = PowFromF32Incomplete<'b>

fn pow(self, rhs: &'b Float) -> PowFromF32Incomplete<'b>

Loading content...

Implementors

impl Pow<f32> for Float

type Output = Float

fn pow(self, rhs: f32) -> Float

impl Pow<f32> for Complex

type Output = Complex

fn pow(self, rhs: f32) -> Complex

impl Pow<f64> for Float

type Output = Float

fn pow(self, rhs: f64) -> Float

impl Pow<f64> for Complex

type Output = Complex

fn pow(self, rhs: f64) -> Complex

impl Pow<i32> for Rational

type Output = Rational

fn pow(self, rhs: i32) -> Rational

impl Pow<i32> for Float

type Output = Float

fn pow(self, rhs: i32) -> Float

impl Pow<i32> for Complex

type Output = Complex

fn pow(self, rhs: i32) -> Complex

impl Pow<u32> for Integer

type Output = Integer

fn pow(self, rhs: u32) -> Integer

impl Pow<u32> for Rational

type Output = Rational

fn pow(self, rhs: u32) -> Rational

impl Pow<u32> for Float

type Output = Float

fn pow(self, rhs: u32) -> Float

impl Pow<u32> for Complex

type Output = Complex

fn pow(self, rhs: u32) -> Complex

impl Pow<Complex> for Complex

type Output = Complex

fn pow(self, rhs: Complex) -> Complex

impl Pow<Float> for Complex

type Output = Complex

fn pow(self, rhs: Float) -> Complex

impl Pow<Float> for Float

type Output = Float

fn pow(self, rhs: Float) -> Float

impl Pow<Integer> for Complex

type Output = Complex

fn pow(self, rhs: Integer) -> Complex

impl Pow<Integer> for Float

type Output = Float

fn pow(self, rhs: Integer) -> Float

impl<'_> Pow<&'_ f32> for Float

type Output = Float

fn pow(self, rhs: &f32) -> Float

impl<'_> Pow<&'_ f32> for Complex

type Output = Complex

fn pow(self, rhs: &f32) -> Complex

impl<'_> Pow<&'_ f64> for Float

type Output = Float

fn pow(self, rhs: &f64) -> Float

impl<'_> Pow<&'_ f64> for Complex

type Output = Complex

fn pow(self, rhs: &f64) -> Complex

impl<'_> Pow<&'_ i32> for Rational

type Output = Rational

fn pow(self, rhs: &i32) -> Rational

impl<'_> Pow<&'_ i32> for Float

type Output = Float

fn pow(self, rhs: &i32) -> Float

impl<'_> Pow<&'_ i32> for Complex

type Output = Complex

fn pow(self, rhs: &i32) -> Complex

impl<'_> Pow<&'_ u32> for Integer

type Output = Integer

fn pow(self, rhs: &u32) -> Integer

impl<'_> Pow<&'_ u32> for Rational

type Output = Rational

fn pow(self, rhs: &u32) -> Rational

impl<'_> Pow<&'_ u32> for Float

type Output = Float

fn pow(self, rhs: &u32) -> Float

impl<'_> Pow<&'_ u32> for Complex

type Output = Complex

fn pow(self, rhs: &u32) -> Complex

impl<'_> Pow<&'_ Complex> for Complex

type Output = Complex

fn pow(self, rhs: &Complex) -> Complex

impl<'_> Pow<&'_ Float> for Complex

type Output = Complex

fn pow(self, rhs: &Float) -> Complex

impl<'_> Pow<&'_ Float> for Float

type Output = Float

fn pow(self, rhs: &Float) -> Float

impl<'_> Pow<&'_ Integer> for Complex

type Output = Complex

fn pow(self, rhs: &Integer) -> Complex

impl<'_> Pow<&'_ Integer> for Float

type Output = Float

fn pow(self, rhs: &Integer) -> Float

impl<'_> Pow<Complex> for &'_ Complex

type Output = Complex

fn pow(self, rhs: Complex) -> Complex

impl<'_> Pow<Float> for &'_ Float

type Output = Float

fn pow(self, rhs: Float) -> Float

impl<'a> Pow<&'a Complex> for &'a Complex

type Output = PowIncomplete<'a>

fn pow(self, rhs: &'a Complex) -> PowIncomplete

impl<'a> Pow<&'a Float> for &'a Complex

type Output = PowFloatIncomplete<'a>

fn pow(self, rhs: &'a Float) -> PowFloatIncomplete

impl<'a> Pow<&'a Float> for &'a Float

type Output = PowIncomplete<'a>

fn pow(self, rhs: &'a Float) -> PowIncomplete

impl<'a> Pow<&'a Integer> for &'a Complex

type Output = PowIntegerIncomplete<'a>

fn pow(self, rhs: &'a Integer) -> PowIntegerIncomplete

impl<'a> Pow<&'a Integer> for &'a Float

type Output = PowIntegerIncomplete<'a>

fn pow(self, rhs: &'a Integer) -> PowIntegerIncomplete

impl<'a> Pow<Float> for &'a Complex

type Output = PowOwnedFloatIncomplete<'a>

fn pow(self, rhs: Float) -> PowOwnedFloatIncomplete<'a>

impl<'a> Pow<Integer> for &'a Complex

type Output = PowOwnedIntegerIncomplete<'a>

fn pow(self, rhs: Integer) -> PowOwnedIntegerIncomplete<'a>

impl<'a> Pow<Integer> for &'a Float

type Output = PowOwnedIntegerIncomplete<'a>

fn pow(self, rhs: Integer) -> PowOwnedIntegerIncomplete<'a>

impl<'b> Pow<f32> for &'b Float

type Output = PowF32Incomplete<'b>

fn pow(self, rhs: f32) -> PowF32Incomplete<'b>

impl<'b> Pow<f32> for &'b Complex

type Output = PowF32Incomplete<'b>

fn pow(self, rhs: f32) -> PowF32Incomplete<'b>

impl<'b> Pow<f64> for &'b Float

type Output = PowF64Incomplete<'b>

fn pow(self, rhs: f64) -> PowF64Incomplete<'b>

impl<'b> Pow<f64> for &'b Complex

type Output = PowF64Incomplete<'b>

fn pow(self, rhs: f64) -> PowF64Incomplete<'b>

impl<'b> Pow<i32> for &'b Rational

type Output = PowI32Incomplete<'b>

fn pow(self, rhs: i32) -> PowI32Incomplete<'b>

impl<'b> Pow<i32> for &'b Float

type Output = PowI32Incomplete<'b>

fn pow(self, rhs: i32) -> PowI32Incomplete<'b>

impl<'b> Pow<i32> for &'b Complex

type Output = PowI32Incomplete<'b>

fn pow(self, rhs: i32) -> PowI32Incomplete<'b>

impl<'b> Pow<u32> for &'b Integer

type Output = PowU32Incomplete<'b>

fn pow(self, rhs: u32) -> PowU32Incomplete<'b>

impl<'b> Pow<u32> for &'b Rational

type Output = PowU32Incomplete<'b>

fn pow(self, rhs: u32) -> PowU32Incomplete<'b>

impl<'b> Pow<u32> for &'b Float

type Output = PowU32Incomplete<'b>

fn pow(self, rhs: u32) -> PowU32Incomplete<'b>

impl<'b> Pow<u32> for &'b Complex

type Output = PowU32Incomplete<'b>

fn pow(self, rhs: u32) -> PowU32Incomplete<'b>

impl<'b, '_> Pow<&'_ f32> for &'b Float

type Output = PowF32Incomplete<'b>

fn pow(self, rhs: &f32) -> PowF32Incomplete<'b>

impl<'b, '_> Pow<&'_ f32> for &'b Complex

type Output = PowF32Incomplete<'b>

fn pow(self, rhs: &f32) -> PowF32Incomplete<'b>

impl<'b, '_> Pow<&'_ f64> for &'b Float

type Output = PowF64Incomplete<'b>

fn pow(self, rhs: &f64) -> PowF64Incomplete<'b>

impl<'b, '_> Pow<&'_ f64> for &'b Complex

type Output = PowF64Incomplete<'b>

fn pow(self, rhs: &f64) -> PowF64Incomplete<'b>

impl<'b, '_> Pow<&'_ i32> for &'b Rational

type Output = PowI32Incomplete<'b>

fn pow(self, rhs: &i32) -> PowI32Incomplete<'b>

impl<'b, '_> Pow<&'_ i32> for &'b Float

type Output = PowI32Incomplete<'b>

fn pow(self, rhs: &i32) -> PowI32Incomplete<'b>

impl<'b, '_> Pow<&'_ i32> for &'b Complex

type Output = PowI32Incomplete<'b>

fn pow(self, rhs: &i32) -> PowI32Incomplete<'b>

impl<'b, '_> Pow<&'_ u32> for &'b Integer

type Output = PowU32Incomplete<'b>

fn pow(self, rhs: &u32) -> PowU32Incomplete<'b>

impl<'b, '_> Pow<&'_ u32> for &'b Rational

type Output = PowU32Incomplete<'b>

fn pow(self, rhs: &u32) -> PowU32Incomplete<'b>

impl<'b, '_> Pow<&'_ u32> for &'b Float

type Output = PowU32Incomplete<'b>

fn pow(self, rhs: &u32) -> PowU32Incomplete<'b>

impl<'b, '_> Pow<&'_ u32> for &'b Complex

type Output = PowU32Incomplete<'b>

fn pow(self, rhs: &u32) -> PowU32Incomplete<'b>

Loading content...