Trait easy_ml::numeric::extra::Pow

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

A type which can compute self^rhs.

This is implemented by f32 and f64 for all combinations of by value and by reference, as well as Traces and Records of these.

The Trace and Record implementations also implement versions with the other argument being a raw f32 or f64, for convenience.

Associated Types

type Output

Loading content...

Required methods

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

Loading content...

Implementations on Foreign Types

impl Pow<f32> for f32

type Output = f32

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

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

type Output = f32

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

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

type Output = f32

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

impl<'a, 'b> Pow<&'b f32> for &'a f32

type Output = f32

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

impl Pow<f64> for f64

type Output = f64

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

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

type Output = f64

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

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

type Output = f64

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

impl<'a, 'b> Pow<&'b f64> for &'a f64

type Output = f64

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

impl<'a, T: Numeric + Real + Primitive> Pow<&'_ Record<'a, T>> for &T where
    &'t T: NumericRef<T> + RealRef<T>, 

Power of a constant to a Record of the same type with both referenced.

type Output = Record<'a, T>

fn pow(self, rhs: &Record<'a, T>) -> Self::Output

impl<'a, T: Numeric + Real + Primitive> Pow<Record<'a, T>> for &T where
    &'t T: NumericRef<T> + RealRef<T>, 

Operation for a constant and a record of the same type with the left referenced.

type Output = Record<'a, T>

fn pow(self, rhs: Record<'a, T>) -> Self::Output

impl<T: Numeric + Real + Primitive> Pow<&'_ Trace<T>> for &T where
    &'a T: NumericRef<T> + RealRef<T>, 

Power of a constant to a trace of the same type with both referenced.

type Output = Trace<T>

fn pow(self, rhs: &Trace<T>) -> Self::Output

impl<T: Numeric + Real + Primitive> Pow<Trace<T>> for &T where
    &'a T: NumericRef<T> + RealRef<T>, 

Operation for a trace and a constant of the same type with the left referenced.

type Output = Trace<T>

fn pow(self, rhs: Trace<T>) -> Self::Output

Loading content...

Implementors

impl<'a, 'l, 'r, T: Numeric + Real + Primitive> Pow<&'r Record<'a, T>> for &'l Record<'a, T> where
    &'t T: NumericRef<T> + RealRef<T>, 

Power of one Record to another, ie self^rhs for two records of the same type with both referenced and both using the same WengertList.

type Output = Record<'a, T>

fn pow(self, rhs: &Record<'a, T>) -> Self::Output

impl<'a, T: Numeric + Real + Primitive> Pow<&'_ Record<'a, T>> for Record<'a, T> where
    &'t T: NumericRef<T> + RealRef<T>, 

Operation for two records of the same type with the right referenced.

type Output = Record<'a, T>

fn pow(self, rhs: &Record<'a, T>) -> Self::Output

impl<'a, T: Numeric + Real + Primitive> Pow<&'_ Record<'a, T>> for T where
    &'t T: NumericRef<T> + RealRef<T>, 

Operation for a constant and a record of the same type with the right referenced.

type Output = Record<'a, T>

fn pow(self, rhs: &Record<'a, T>) -> Self::Output

impl<'a, T: Numeric + Real + Primitive> Pow<&'_ T> for &Record<'a, T> where
    &'t T: NumericRef<T> + RealRef<T>, 

Power of one Record to a constant of the same type with both referenced.

type Output = Record<'a, T>

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

impl<'a, T: Numeric + Real + Primitive> Pow<&'_ T> for Record<'a, T> where
    &'t T: NumericRef<T> + RealRef<T>, 

Operation for a record and a constant of the same type with the right referenced.

type Output = Record<'a, T>

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

impl<'a, T: Numeric + Real + Primitive> Pow<Record<'a, T>> for &Record<'a, T> where
    &'t T: NumericRef<T> + RealRef<T>, 

Operation for two records of the same type with the left referenced.

type Output = Record<'a, T>

fn pow(self, rhs: Record<'a, T>) -> Self::Output

impl<'a, T: Numeric + Real + Primitive> Pow<Record<'a, T>> for Record<'a, T> where
    &'t T: NumericRef<T> + RealRef<T>, 

Operation for two records of the same type.

type Output = Record<'a, T>

fn pow(self, rhs: Record<'a, T>) -> Self::Output

impl<'a, T: Numeric + Real + Primitive> Pow<Record<'a, T>> for T where
    &'t T: NumericRef<T> + RealRef<T>, 

Operation for a constant and a record of the same type.

type Output = Record<'a, T>

fn pow(self, rhs: Record<'a, T>) -> Self::Output

impl<'a, T: Numeric + Real + Primitive> Pow<T> for &Record<'a, T> where
    &'t T: NumericRef<T> + RealRef<T>, 

Operation for a record and a constant of the same type with the left referenced.

type Output = Record<'a, T>

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

impl<'a, T: Numeric + Real + Primitive> Pow<T> for Record<'a, T> where
    &'t T: NumericRef<T> + RealRef<T>, 

Operation for a record and a constant of the same type.

type Output = Record<'a, T>

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

impl<'l, 'r, T: Numeric + Real + Primitive> Pow<&'r Trace<T>> for &'l Trace<T> where
    &'a T: NumericRef<T> + RealRef<T>, 

Power of one Trace to another, ie self^rhs for two traces of the same type with both referenced.

type Output = Trace<T>

fn pow(self, rhs: &Trace<T>) -> Self::Output

impl<T: Numeric + Real + Primitive> Pow<&'_ Trace<T>> for Trace<T> where
    &'a T: NumericRef<T> + RealRef<T>, 

Operation for two traces of the same type with the right referenced.

type Output = Trace<T>

fn pow(self, rhs: &Trace<T>) -> Self::Output

impl<T: Numeric + Real + Primitive> Pow<&'_ Trace<T>> for T where
    &'a T: NumericRef<T> + RealRef<T>, 

Operation for a trace and a constant of the same type with the right referenced.

type Output = Trace<T>

fn pow(self, rhs: &Trace<T>) -> Self::Output

impl<T: Numeric + Real + Primitive> Pow<&'_ T> for &Trace<T> where
    &'a T: NumericRef<T> + RealRef<T>, 

Power of a trace to a constant of the same type with both referenced.

type Output = Trace<T>

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

impl<T: Numeric + Real + Primitive> Pow<&'_ T> for Trace<T> where
    &'a T: NumericRef<T> + RealRef<T>, 

Operation for a trace and a constant of the same type with the right referenced.

type Output = Trace<T>

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

impl<T: Numeric + Real + Primitive> Pow<Trace<T>> for &Trace<T> where
    &'a T: NumericRef<T> + RealRef<T>, 

Operation for two traces of the same type with the left referenced.

type Output = Trace<T>

fn pow(self, rhs: Trace<T>) -> Self::Output

impl<T: Numeric + Real + Primitive> Pow<Trace<T>> for Trace<T> where
    &'a T: NumericRef<T> + RealRef<T>, 

Operation for two traces of the same type.

type Output = Trace<T>

fn pow(self, rhs: Trace<T>) -> Self::Output

impl<T: Numeric + Real + Primitive> Pow<Trace<T>> for T where
    &'a T: NumericRef<T> + RealRef<T>, 

Operation for a trace and a constant of the same type.

type Output = Trace<T>

fn pow(self, rhs: Trace<T>) -> Self::Output

impl<T: Numeric + Real + Primitive> Pow<T> for &Trace<T> where
    &'a T: NumericRef<T> + RealRef<T>, 

Operation for a trace and a constant of the same type with the left referenced.

type Output = Trace<T>

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

impl<T: Numeric + Real + Primitive> Pow<T> for Trace<T> where
    &'a T: NumericRef<T> + RealRef<T>, 

Operation for a trace and a constant of the same type.

type Output = Trace<T>

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

Loading content...