# [−][src]Trait typenum::type_operators::Pow

    pub trait Pow<Exp> {
        type Output;
        fn powi(self, exp: Exp) -> Self::Output;
    }

A type operator that provides exponentiation by repeated squaring.

# Example

    use typenum::{Pow, N3, P3, Integer};

    assert_eq!(<N3 as Pow<P3>>::Output::to_i32(), -27);

## Associated Types

### `type Output`

The result of the exponentiation.

Loading content...

## Required methods

### `fn powi(self, exp: Exp) -> Self::Output`

This function isn't used in this crate, but may be useful for others. It is implemented for primitives.

# Example

    use typenum::{Pow, U3};

    let a = 7u32.powi(U3::new());
    let b = 7u32.pow(3);
    assert_eq!(a, b);

    let x = 3.0.powi(U3::new());
    let y = 27.0;
    assert_eq!(x, y);

Loading content...

## Implementors

### `impl Pow<Z0> for usize`[src]

#### `type Output = usize`

#### `fn powi(self, _: Z0) -> Self::Output`[src]

### `impl Pow<Z0> for isize`[src]

#### `type Output = isize`

#### `fn powi(self, _: Z0) -> Self::Output`[src]

### `impl Pow<Z0> for Z0`[src]

0^0 = 1

#### `type Output = P1`

#### `fn powi(self, _: Z0) -> Self::Output`[src]

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

#### `type Output = f32`

#### `fn powi(self, _: Z0) -> Self::Output`[src]

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

#### `type Output = f64`

#### `fn powi(self, _: Z0) -> Self::Output`[src]

### `impl Pow<Z0> for i8`[src]

#### `type Output = i8`

#### `fn powi(self, _: Z0) -> Self::Output`[src]

### `impl Pow<Z0> for i16`[src]

#### `type Output = i16`

#### `fn powi(self, _: Z0) -> Self::Output`[src]

### `impl Pow<Z0> for i32`[src]

#### `type Output = i32`

#### `fn powi(self, _: Z0) -> Self::Output`[src]

### `impl Pow<Z0> for i64`[src]

#### `type Output = i64`

#### `fn powi(self, _: Z0) -> Self::Output`[src]

### `impl Pow<Z0> for u8`[src]

#### `type Output = u8`

#### `fn powi(self, _: Z0) -> Self::Output`[src]

### `impl Pow<Z0> for u16`[src]

#### `type Output = u16`

#### `fn powi(self, _: Z0) -> Self::Output`[src]

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

#### `type Output = u32`

#### `fn powi(self, _: Z0) -> Self::Output`[src]

### `impl Pow<Z0> for u64`[src]

#### `type Output = u64`

#### `fn powi(self, _: Z0) -> Self::Output`[src]

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

#### `type Output = f32`

#### `fn powi(self, _: UTerm) -> Self::Output`[src]

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

#### `type Output = f64`

#### `fn powi(self, _: UTerm) -> Self::Output`[src]

### `impl Pow<UTerm> for i8`[src]

#### `type Output = i8`

#### `fn powi(self, _: UTerm) -> Self::Output`[src]

### `impl Pow<UTerm> for i16`[src]

#### `type Output = i16`

#### `fn powi(self, _: UTerm) -> Self::Output`[src]

### `impl Pow<UTerm> for i32`[src]

#### `type Output = i32`

#### `fn powi(self, _: UTerm) -> Self::Output`[src]

### `impl Pow<UTerm> for i64`[src]

#### `type Output = i64`

#### `fn powi(self, _: UTerm) -> Self::Output`[src]

### `impl Pow<UTerm> for isize`[src]

#### `type Output = isize`

#### `fn powi(self, _: UTerm) -> Self::Output`[src]

### `impl Pow<UTerm> for u8`[src]

#### `type Output = u8`

#### `fn powi(self, _: UTerm) -> Self::Output`[src]

### `impl Pow<UTerm> for u16`[src]

#### `type Output = u16`

#### `fn powi(self, _: UTerm) -> Self::Output`[src]

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

#### `type Output = u32`

#### `fn powi(self, _: UTerm) -> Self::Output`[src]

### `impl Pow<UTerm> for u64`[src]

#### `type Output = u64`

#### `fn powi(self, _: UTerm) -> Self::Output`[src]

### `impl Pow<UTerm> for usize`[src]

#### `type Output = usize`

#### `fn powi(self, _: UTerm) -> Self::Output`[src]

### `impl<U: Unsigned + NonZero> Pow<NInt<U>> for Z0`[src]

0^N = 0

#### `type Output = Z0`

#### `fn powi(self, _: NInt<U>) -> Self::Output`[src]

### `impl<U: Unsigned + NonZero> Pow<NInt<U>> for P1`[src]

1^N = 1

#### `type Output = P1`

#### `fn powi(self, _: NInt<U>) -> Self::Output`[src]

### `impl<U: Unsigned + NonZero> Pow<PInt<U>> for Z0`[src]

0^P = 0

#### `type Output = Z0`

#### `fn powi(self, _: PInt<U>) -> Self::Output`[src]

### `impl<U: Unsigned + NonZero> Pow<PInt<U>> for f32`[src]

#### `type Output = f32`

#### `fn powi(self, _: PInt<U>) -> Self::Output`[src]

### `impl<U: Unsigned + NonZero> Pow<PInt<U>> for f64`[src]

#### `type Output = f64`

#### `fn powi(self, _: PInt<U>) -> Self::Output`[src]

### `impl<U: Unsigned + NonZero> Pow<PInt<U>> for i8`[src]

#### `type Output = i8`

#### `fn powi(self, _: PInt<U>) -> Self::Output`[src]

### `impl<U: Unsigned + NonZero> Pow<PInt<U>> for i16`[src]

#### `type Output = i16`

#### `fn powi(self, _: PInt<U>) -> Self::Output`[src]

### `impl<U: Unsigned + NonZero> Pow<PInt<U>> for i32`[src]

#### `type Output = i32`

#### `fn powi(self, _: PInt<U>) -> Self::Output`[src]

### `impl<U: Unsigned + NonZero> Pow<PInt<U>> for i64`[src]

#### `type Output = i64`

#### `fn powi(self, _: PInt<U>) -> Self::Output`[src]

### `impl<U: Unsigned + NonZero> Pow<PInt<U>> for isize`[src]

#### `type Output = isize`

#### `fn powi(self, _: PInt<U>) -> Self::Output`[src]

### `impl<U: Unsigned + NonZero> Pow<PInt<U>> for u8`[src]

#### `type Output = u8`

#### `fn powi(self, _: PInt<U>) -> Self::Output`[src]

### `impl<U: Unsigned + NonZero> Pow<PInt<U>> for u16`[src]

#### `type Output = u16`

#### `fn powi(self, _: PInt<U>) -> Self::Output`[src]

### `impl<U: Unsigned + NonZero> Pow<PInt<U>> for u32`[src]

#### `type Output = u32`

#### `fn powi(self, _: PInt<U>) -> Self::Output`[src]

### `impl<U: Unsigned + NonZero> Pow<PInt<U>> for u64`[src]

#### `type Output = u64`

#### `fn powi(self, _: PInt<U>) -> Self::Output`[src]

### `impl<U: Unsigned + NonZero> Pow<PInt<U>> for usize`[src]

#### `type Output = usize`

#### `fn powi(self, _: PInt<U>) -> Self::Output`[src]

### `impl<U: Unsigned + NonZero> Pow<Z0> for PInt<U>`[src]

P^0 = 1

#### `type Output = P1`

#### `fn powi(self, _: Z0) -> Self::Output`[src]

### `impl<U: Unsigned + NonZero> Pow<Z0> for NInt<U>`[src]

N^0 = 1

#### `type Output = P1`

#### `fn powi(self, _: Z0) -> Self::Output`[src]

### `impl<U: Unsigned> Pow<NInt<UInt<U, B0>>> for N1`[src]

(-1)^N = 1 if N is even

#### `type Output = P1`

#### `fn powi(self, _: NInt<UInt<U, B0>>) -> Self::Output`[src]

### `impl<U: Unsigned> Pow<NInt<UInt<U, B1>>> for N1`[src]

(-1)^N = -1 if N is odd

#### `type Output = N1`

#### `fn powi(self, _: NInt<UInt<U, B1>>) -> Self::Output`[src]

### `impl<U: Unsigned, B: Bit> Pow<UInt<U, B>> for f32`[src]

#### `type Output = f32`

#### `fn powi(self, _: UInt<U, B>) -> Self::Output`[src]

### `impl<U: Unsigned, B: Bit> Pow<UInt<U, B>> for f64`[src]

#### `type Output = f64`

#### `fn powi(self, _: UInt<U, B>) -> Self::Output`[src]

### `impl<U: Unsigned, B: Bit> Pow<UInt<U, B>> for i8`[src]

#### `type Output = i8`

#### `fn powi(self, _: UInt<U, B>) -> Self::Output`[src]

### `impl<U: Unsigned, B: Bit> Pow<UInt<U, B>> for i16`[src]

#### `type Output = i16`

#### `fn powi(self, _: UInt<U, B>) -> Self::Output`[src]

### `impl<U: Unsigned, B: Bit> Pow<UInt<U, B>> for i32`[src]

#### `type Output = i32`

#### `fn powi(self, _: UInt<U, B>) -> Self::Output`[src]

### `impl<U: Unsigned, B: Bit> Pow<UInt<U, B>> for i64`[src]

#### `type Output = i64`

#### `fn powi(self, _: UInt<U, B>) -> Self::Output`[src]

### `impl<U: Unsigned, B: Bit> Pow<UInt<U, B>> for isize`[src]

#### `type Output = isize`

#### `fn powi(self, _: UInt<U, B>) -> Self::Output`[src]

### `impl<U: Unsigned, B: Bit> Pow<UInt<U, B>> for u8`[src]

#### `type Output = u8`

#### `fn powi(self, _: UInt<U, B>) -> Self::Output`[src]

### `impl<U: Unsigned, B: Bit> Pow<UInt<U, B>> for u16`[src]

#### `type Output = u16`

#### `fn powi(self, _: UInt<U, B>) -> Self::Output`[src]

### `impl<U: Unsigned, B: Bit> Pow<UInt<U, B>> for u32`[src]

#### `type Output = u32`

#### `fn powi(self, _: UInt<U, B>) -> Self::Output`[src]

### `impl<U: Unsigned, B: Bit> Pow<UInt<U, B>> for u64`[src]

#### `type Output = u64`

#### `fn powi(self, _: UInt<U, B>) -> Self::Output`[src]

### `impl<U: Unsigned, B: Bit> Pow<UInt<U, B>> for usize`[src]

#### `type Output = usize`

#### `fn powi(self, _: UInt<U, B>) -> Self::Output`[src]

### `impl<Ul: Unsigned + NonZero, Ur: Unsigned + NonZero> Pow<PInt<Ur>> for PInt<Ul> where
Ul: Pow<Ur>,
<Ul as Pow<Ur>>::Output: Unsigned + NonZero,` [src]

P(Ul)^P(Ur) = P(Ul^Ur)

#### `type Output = PInt<<Ul as Pow<Ur>>::Output>`

#### `fn powi(self, _: PInt<Ur>) -> Self::Output`[src]

### `impl<Ul: Unsigned + NonZero, Ur: Unsigned> Pow<PInt<UInt<Ur, B0>>> for NInt<Ul> where
Ul: Pow<UInt<Ur, B0>>,
<Ul as Pow<UInt<Ur, B0>>>::Output: Unsigned + NonZero,` [src]

N(Ul)^P(Ur) = P(Ul^Ur) if Ur is even

#### `type Output = PInt<<Ul as Pow<UInt<Ur, B0>>>::Output>`

#### `fn powi(self, _: PInt<UInt<Ur, B0>>) -> Self::Output`[src]

### `impl<Ul: Unsigned + NonZero, Ur: Unsigned> Pow<PInt<UInt<Ur, B1>>> for NInt<Ul> where
Ul: Pow<UInt<Ur, B1>>,
<Ul as Pow<UInt<Ur, B1>>>::Output: Unsigned + NonZero,` [src]

N(Ul)^P(Ur) = N(Ul^Ur) if Ur is odd

#### `type Output = NInt<<Ul as Pow<UInt<Ur, B1>>>::Output>`

#### `fn powi(self, _: PInt<UInt<Ur, B1>>) -> Self::Output`[src]

### `impl<X: Unsigned, N: Unsigned> Pow<N> for X where
X: PrivatePow<U1, N>,` [src]

X^N

#### `type Output = PrivatePowOut<X, U1, N>`

#### `fn powi(self, _: N) -> Self::Output`[src]

Loading content...

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g., `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g., `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g., `str,u8` or `String,struct:Vec,test`)