Trait verified::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...

Implementations on Foreign Types

impl Pow<Z0> for u16

type Output = u16

fn powi(self, Z0) -> <u16 as Pow<Z0>>::Output

impl<U, B> Pow<UInt<U, B>> for i32 where
    B: Bit,
    U: Unsigned, 

type Output = i32

fn powi(self, UInt<U, B>) -> <i32 as Pow<UInt<U, B>>>::Output

impl Pow<Z0> for i32

type Output = i32

fn powi(self, Z0) -> <i32 as Pow<Z0>>::Output

impl Pow<UTerm> for u64

type Output = u64

fn powi(self, UTerm) -> <u64 as Pow<UTerm>>::Output

impl<U> Pow<PInt<U>> for u8 where
    U: NonZero + Unsigned, 

type Output = u8

fn powi(self, PInt<U>) -> <u8 as Pow<PInt<U>>>::Output

impl Pow<UTerm> for i64

type Output = i64

fn powi(self, UTerm) -> <i64 as Pow<UTerm>>::Output

impl<U> Pow<PInt<U>> for f32 where
    U: NonZero + Unsigned, 

type Output = f32

fn powi(self, PInt<U>) -> <f32 as Pow<PInt<U>>>::Output

impl Pow<UTerm> for f64

type Output = f64

fn powi(self, UTerm) -> <f64 as Pow<UTerm>>::Output

impl<U, B> Pow<UInt<U, B>> for f64 where
    B: Bit,
    U: Unsigned, 

type Output = f64

fn powi(self, UInt<U, B>) -> <f64 as Pow<UInt<U, B>>>::Output

impl<U, B> Pow<UInt<U, B>> for i16 where
    B: Bit,
    U: Unsigned, 

type Output = i16

fn powi(self, UInt<U, B>) -> <i16 as Pow<UInt<U, B>>>::Output

impl Pow<UTerm> for i32

type Output = i32

fn powi(self, UTerm) -> <i32 as Pow<UTerm>>::Output

impl<U> Pow<PInt<U>> for i8 where
    U: NonZero + Unsigned, 

type Output = i8

fn powi(self, PInt<U>) -> <i8 as Pow<PInt<U>>>::Output

impl Pow<UTerm> for i8

type Output = i8

fn powi(self, UTerm) -> <i8 as Pow<UTerm>>::Output

impl<U, B> Pow<UInt<U, B>> for u8 where
    B: Bit,
    U: Unsigned, 

type Output = u8

fn powi(self, UInt<U, B>) -> <u8 as Pow<UInt<U, B>>>::Output

impl Pow<Z0> for i64

type Output = i64

fn powi(self, Z0) -> <i64 as Pow<Z0>>::Output

impl<U> Pow<PInt<U>> for i32 where
    U: NonZero + Unsigned, 

type Output = i32

fn powi(self, PInt<U>) -> <i32 as Pow<PInt<U>>>::Output

impl<U, B> Pow<UInt<U, B>> for i64 where
    B: Bit,
    U: Unsigned, 

type Output = i64

fn powi(self, UInt<U, B>) -> <i64 as Pow<UInt<U, B>>>::Output

impl Pow<Z0> for f64

type Output = f64

fn powi(self, Z0) -> <f64 as Pow<Z0>>::Output

impl<U, B> Pow<UInt<U, B>> for isize where
    B: Bit,
    U: Unsigned, 

type Output = isize

fn powi(self, UInt<U, B>) -> <isize as Pow<UInt<U, B>>>::Output

impl<U> Pow<PInt<U>> for u64 where
    U: NonZero + Unsigned, 

type Output = u64

fn powi(self, PInt<U>) -> <u64 as Pow<PInt<U>>>::Output

impl Pow<UTerm> for u32

type Output = u32

fn powi(self, UTerm) -> <u32 as Pow<UTerm>>::Output

impl Pow<Z0> for i8

type Output = i8

fn powi(self, Z0) -> <i8 as Pow<Z0>>::Output

impl<U> Pow<PInt<U>> for u16 where
    U: NonZero + Unsigned, 

type Output = u16

fn powi(self, PInt<U>) -> <u16 as Pow<PInt<U>>>::Output

impl<U> Pow<PInt<U>> for isize where
    U: NonZero + Unsigned, 

type Output = isize

fn powi(self, PInt<U>) -> <isize as Pow<PInt<U>>>::Output

impl<U, B> Pow<UInt<U, B>> for u32 where
    B: Bit,
    U: Unsigned, 

type Output = u32

fn powi(self, UInt<U, B>) -> <u32 as Pow<UInt<U, B>>>::Output

impl<U> Pow<PInt<U>> for i16 where
    U: NonZero + Unsigned, 

type Output = i16

fn powi(self, PInt<U>) -> <i16 as Pow<PInt<U>>>::Output

impl Pow<Z0> for u32

type Output = u32

fn powi(self, Z0) -> <u32 as Pow<Z0>>::Output

impl Pow<Z0> for f32

type Output = f32

fn powi(self, Z0) -> <f32 as Pow<Z0>>::Output

impl Pow<Z0> for isize

type Output = isize

fn powi(self, Z0) -> <isize as Pow<Z0>>::Output

impl<U> Pow<PInt<U>> for usize where
    U: NonZero + Unsigned, 

type Output = usize

fn powi(self, PInt<U>) -> <usize as Pow<PInt<U>>>::Output

impl Pow<UTerm> for i16

type Output = i16

fn powi(self, UTerm) -> <i16 as Pow<UTerm>>::Output

impl<U, B> Pow<UInt<U, B>> for u16 where
    B: Bit,
    U: Unsigned, 

type Output = u16

fn powi(self, UInt<U, B>) -> <u16 as Pow<UInt<U, B>>>::Output

impl<U> Pow<PInt<U>> for f64 where
    U: NonZero + Unsigned, 

type Output = f64

fn powi(self, PInt<U>) -> <f64 as Pow<PInt<U>>>::Output

impl Pow<Z0> for usize

type Output = usize

fn powi(self, Z0) -> <usize as Pow<Z0>>::Output

impl<U, B> Pow<UInt<U, B>> for f32 where
    B: Bit,
    U: Unsigned, 

type Output = f32

fn powi(self, UInt<U, B>) -> <f32 as Pow<UInt<U, B>>>::Output

impl Pow<Z0> for u64

type Output = u64

fn powi(self, Z0) -> <u64 as Pow<Z0>>::Output

impl<U, B> Pow<UInt<U, B>> for i8 where
    B: Bit,
    U: Unsigned, 

type Output = i8

fn powi(self, UInt<U, B>) -> <i8 as Pow<UInt<U, B>>>::Output

impl Pow<UTerm> for u8

type Output = u8

fn powi(self, UTerm) -> <u8 as Pow<UTerm>>::Output

impl Pow<UTerm> for f32

type Output = f32

fn powi(self, UTerm) -> <f32 as Pow<UTerm>>::Output

impl<U> Pow<PInt<U>> for u32 where
    U: NonZero + Unsigned, 

type Output = u32

fn powi(self, PInt<U>) -> <u32 as Pow<PInt<U>>>::Output

impl Pow<UTerm> for u16

type Output = u16

fn powi(self, UTerm) -> <u16 as Pow<UTerm>>::Output

impl Pow<Z0> for u8

type Output = u8

fn powi(self, Z0) -> <u8 as Pow<Z0>>::Output

impl Pow<Z0> for i16

type Output = i16

fn powi(self, Z0) -> <i16 as Pow<Z0>>::Output

impl Pow<UTerm> for isize

type Output = isize

fn powi(self, UTerm) -> <isize as Pow<UTerm>>::Output

impl Pow<UTerm> for usize

type Output = usize

fn powi(self, UTerm) -> <usize as Pow<UTerm>>::Output

impl<U> Pow<PInt<U>> for i64 where
    U: NonZero + Unsigned, 

type Output = i64

fn powi(self, PInt<U>) -> <i64 as Pow<PInt<U>>>::Output

impl<U, B> Pow<UInt<U, B>> for u64 where
    B: Bit,
    U: Unsigned, 

type Output = u64

fn powi(self, UInt<U, B>) -> <u64 as Pow<UInt<U, B>>>::Output

impl<U, B> Pow<UInt<U, B>> for usize where
    B: Bit,
    U: Unsigned, 

type Output = usize

fn powi(self, UInt<U, B>) -> <usize as Pow<UInt<U, B>>>::Output

Loading content...

Implementors

impl Pow<Z0> for Z0

0^0 = 1

type Output = PInt<UInt<UTerm, B1>>

fn powi(self, Z0) -> <Z0 as Pow<Z0>>::Output

impl<U> Pow<NInt<UInt<U, B0>>> for NInt<UInt<UTerm, B1>> where
    U: Unsigned, 

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

type Output = PInt<UInt<UTerm, B1>>

fn powi(
    self,
    NInt<UInt<U, B0>>
) -> <NInt<UInt<UTerm, B1>> as Pow<NInt<UInt<U, B0>>>>::Output

impl<U> Pow<NInt<UInt<U, B1>>> for NInt<UInt<UTerm, B1>> where
    U: Unsigned, 

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

type Output = NInt<UInt<UTerm, B1>>

fn powi(
    self,
    NInt<UInt<U, B1>>
) -> <NInt<UInt<UTerm, B1>> as Pow<NInt<UInt<U, B1>>>>::Output

impl<U> Pow<NInt<U>> for PInt<UInt<UTerm, B1>> where
    U: NonZero + Unsigned, 

1^N = 1

type Output = PInt<UInt<UTerm, B1>>

fn powi(self, NInt<U>) -> <PInt<UInt<UTerm, B1>> as Pow<NInt<U>>>::Output

impl<U> Pow<NInt<U>> for Z0 where
    U: NonZero + Unsigned, 

0^N = 0

type Output = Z0

fn powi(self, NInt<U>) -> <Z0 as Pow<NInt<U>>>::Output

impl<U> Pow<PInt<U>> for Z0 where
    U: NonZero + Unsigned, 

0^P = 0

type Output = Z0

fn powi(self, PInt<U>) -> <Z0 as Pow<PInt<U>>>::Output

impl<U> Pow<Z0> for NInt<U> where
    U: NonZero + Unsigned, 

N^0 = 1

type Output = PInt<UInt<UTerm, B1>>

fn powi(self, Z0) -> <NInt<U> as Pow<Z0>>::Output

impl<U> Pow<Z0> for PInt<U> where
    U: NonZero + Unsigned, 

P^0 = 1

type Output = PInt<UInt<UTerm, B1>>

fn powi(self, Z0) -> <PInt<U> as Pow<Z0>>::Output

impl<Ul, Ur> Pow<PInt<UInt<Ur, B0>>> for NInt<Ul> where
    Ul: NonZero + Unsigned + Pow<UInt<Ur, B0>>,
    Ur: Unsigned,
    <Ul as Pow<UInt<Ur, B0>>>::Output: Unsigned,
    <Ul as Pow<UInt<Ur, B0>>>::Output: NonZero, 

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>>
) -> <NInt<Ul> as Pow<PInt<UInt<Ur, B0>>>>::Output

impl<Ul, Ur> Pow<PInt<UInt<Ur, B1>>> for NInt<Ul> where
    Ul: NonZero + Unsigned + Pow<UInt<Ur, B1>>,
    Ur: Unsigned,
    <Ul as Pow<UInt<Ur, B1>>>::Output: Unsigned,
    <Ul as Pow<UInt<Ur, B1>>>::Output: NonZero, 

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>>
) -> <NInt<Ul> as Pow<PInt<UInt<Ur, B1>>>>::Output

impl<Ul, Ur> Pow<PInt<Ur>> for PInt<Ul> where
    Ul: NonZero + Unsigned + Pow<Ur>,
    Ur: NonZero + Unsigned,
    <Ul as Pow<Ur>>::Output: Unsigned,
    <Ul as Pow<Ur>>::Output: NonZero, 

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

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

fn powi(self, PInt<Ur>) -> <PInt<Ul> as Pow<PInt<Ur>>>::Output

impl<X, N> Pow<N> for X where
    N: Unsigned,
    X: Unsigned + PrivatePow<UInt<UTerm, B1>, N>, 

X^N

type Output = <X as PrivatePow<UInt<UTerm, B1>, N>>::Output

fn powi(self, n: N) -> <X as Pow<N>>::Output

Loading content...