Trait NormalOut

pub trait NormalOut<RHS = Self> {
    type Output;

    // Required methods
    fn _add(self, rhs: RHS) -> Self::Output;
    fn _sub(self, rhs: RHS) -> Self::Output;
    fn _mul_add(self, a: RHS, b: RHS) -> Self::Output;
    fn _mul(self, rhs: RHS) -> Self::Output;
    fn _pow(self, rhs: RHS) -> Self::Output;
    fn _rem(self, rhs: RHS) -> Self::Output;
    fn _max(self, rhs: RHS) -> Self::Output;
    fn _min(self, rhs: RHS) -> Self::Output;
    fn _clamp(self, min: RHS, max: RHS) -> Self::Output;
}

this trait is used to perform normal operations that don’t require type promotion

Required Associated Types

type Output

the output type

Required Methods

fn _add(self, rhs: RHS) -> Self::Output

perform a + b

fn _sub(self, rhs: RHS) -> Self::Output

perform a - b

fn _mul_add(self, a: RHS, b: RHS) -> Self::Output

perform self * a + b, fused multiply add if the hardware supports it, it can speed up the calculation and reduce the rounding error

fn _mul(self, rhs: RHS) -> Self::Output

perform a * b

fn _pow(self, rhs: RHS) -> Self::Output

perform a^b

fn _rem(self, rhs: RHS) -> Self::Output

perform a % b

fn _max(self, rhs: RHS) -> Self::Output

perform max(x, y)

fn _min(self, rhs: RHS) -> Self::Output

perform min(x, y)

fn _clamp(self, min: RHS, max: RHS) -> Self::Output

restrict the value of x to the range [min, max]

Implementations on Foreign Types

impl NormalOut for bool

type Output = <bool as NormalOutPromote>::Output

fn _pow(self, rhs: bool) -> <bool as NormalOut>::Output

fn _clamp(self, min: bool, max: bool) -> <bool as NormalOut>::Output

fn _mul_add(self, a: bool, b: bool) -> <bool as NormalOut>::Output

fn _add(self, rhs: bool) -> <bool as NormalOut>::Output

fn _sub(self, rhs: bool) -> <bool as NormalOut>::Output

fn _mul(self, rhs: bool) -> <bool as NormalOut>::Output

fn _rem(self, rhs: bool) -> <bool as NormalOut>::Output

fn _max(self, rhs: bool) -> <bool as NormalOut>::Output

fn _min(self, rhs: bool) -> <bool as NormalOut>::Output

impl NormalOut for f32

type Output = <f32 as NormalOutPromote>::Output

fn _pow(self, rhs: f32) -> <f32 as NormalOut>::Output

fn _clamp(self, min: f32, max: f32) -> <f32 as NormalOut>::Output

fn _mul_add(self, a: f32, b: f32) -> <f32 as NormalOut>::Output

fn _add(self, rhs: f32) -> <f32 as NormalOut>::Output

fn _sub(self, rhs: f32) -> <f32 as NormalOut>::Output

fn _mul(self, rhs: f32) -> <f32 as NormalOut>::Output

fn _rem(self, rhs: f32) -> <f32 as NormalOut>::Output

fn _max(self, rhs: f32) -> <f32 as NormalOut>::Output

fn _min(self, rhs: f32) -> <f32 as NormalOut>::Output

impl NormalOut for f64

type Output = <f64 as NormalOutPromote>::Output

fn _pow(self, rhs: f64) -> <f64 as NormalOut>::Output

fn _clamp(self, min: f64, max: f64) -> <f64 as NormalOut>::Output

fn _mul_add(self, a: f64, b: f64) -> <f64 as NormalOut>::Output

fn _add(self, rhs: f64) -> <f64 as NormalOut>::Output

fn _sub(self, rhs: f64) -> <f64 as NormalOut>::Output

fn _mul(self, rhs: f64) -> <f64 as NormalOut>::Output

fn _rem(self, rhs: f64) -> <f64 as NormalOut>::Output

fn _max(self, rhs: f64) -> <f64 as NormalOut>::Output

fn _min(self, rhs: f64) -> <f64 as NormalOut>::Output

impl NormalOut for i8

type Output = <i8 as NormalOutPromote>::Output

fn _pow(self, rhs: i8) -> <i8 as NormalOut>::Output

fn _clamp(self, min: i8, max: i8) -> <i8 as NormalOut>::Output

fn _mul_add(self, a: i8, b: i8) -> <i8 as NormalOut>::Output

fn _add(self, rhs: i8) -> <i8 as NormalOut>::Output

fn _sub(self, rhs: i8) -> <i8 as NormalOut>::Output

fn _mul(self, rhs: i8) -> <i8 as NormalOut>::Output

fn _rem(self, rhs: i8) -> <i8 as NormalOut>::Output

fn _max(self, rhs: i8) -> <i8 as NormalOut>::Output

fn _min(self, rhs: i8) -> <i8 as NormalOut>::Output

impl NormalOut for i16

type Output = <i16 as NormalOutPromote>::Output

fn _pow(self, rhs: i16) -> <i16 as NormalOut>::Output

fn _clamp(self, min: i16, max: i16) -> <i16 as NormalOut>::Output

fn _mul_add(self, a: i16, b: i16) -> <i16 as NormalOut>::Output

fn _add(self, rhs: i16) -> <i16 as NormalOut>::Output

fn _sub(self, rhs: i16) -> <i16 as NormalOut>::Output

fn _mul(self, rhs: i16) -> <i16 as NormalOut>::Output

fn _rem(self, rhs: i16) -> <i16 as NormalOut>::Output

fn _max(self, rhs: i16) -> <i16 as NormalOut>::Output

fn _min(self, rhs: i16) -> <i16 as NormalOut>::Output

impl NormalOut for i32

type Output = <i32 as NormalOutPromote>::Output

fn _pow(self, rhs: i32) -> <i32 as NormalOut>::Output

fn _clamp(self, min: i32, max: i32) -> <i32 as NormalOut>::Output

fn _mul_add(self, a: i32, b: i32) -> <i32 as NormalOut>::Output

fn _add(self, rhs: i32) -> <i32 as NormalOut>::Output

fn _sub(self, rhs: i32) -> <i32 as NormalOut>::Output

fn _mul(self, rhs: i32) -> <i32 as NormalOut>::Output

fn _rem(self, rhs: i32) -> <i32 as NormalOut>::Output

fn _max(self, rhs: i32) -> <i32 as NormalOut>::Output

fn _min(self, rhs: i32) -> <i32 as NormalOut>::Output

impl NormalOut for i64

type Output = <i64 as NormalOutPromote>::Output

fn _pow(self, rhs: i64) -> <i64 as NormalOut>::Output

fn _clamp(self, min: i64, max: i64) -> <i64 as NormalOut>::Output

fn _mul_add(self, a: i64, b: i64) -> <i64 as NormalOut>::Output

fn _add(self, rhs: i64) -> <i64 as NormalOut>::Output

fn _sub(self, rhs: i64) -> <i64 as NormalOut>::Output

fn _mul(self, rhs: i64) -> <i64 as NormalOut>::Output

fn _rem(self, rhs: i64) -> <i64 as NormalOut>::Output

fn _max(self, rhs: i64) -> <i64 as NormalOut>::Output

fn _min(self, rhs: i64) -> <i64 as NormalOut>::Output

impl NormalOut for isize

type Output = <isize as NormalOutPromote>::Output

fn _pow(self, rhs: isize) -> <isize as NormalOut>::Output

fn _clamp(self, min: isize, max: isize) -> <isize as NormalOut>::Output

fn _mul_add(self, a: isize, b: isize) -> <isize as NormalOut>::Output

fn _add(self, rhs: isize) -> <isize as NormalOut>::Output

fn _sub(self, rhs: isize) -> <isize as NormalOut>::Output

fn _mul(self, rhs: isize) -> <isize as NormalOut>::Output

fn _rem(self, rhs: isize) -> <isize as NormalOut>::Output

fn _max(self, rhs: isize) -> <isize as NormalOut>::Output

fn _min(self, rhs: isize) -> <isize as NormalOut>::Output

impl NormalOut for u8

type Output = <u8 as NormalOutPromote>::Output

fn _pow(self, rhs: u8) -> <u8 as NormalOut>::Output

fn _clamp(self, min: u8, max: u8) -> <u8 as NormalOut>::Output

fn _mul_add(self, a: u8, b: u8) -> <u8 as NormalOut>::Output

fn _add(self, rhs: u8) -> <u8 as NormalOut>::Output

fn _sub(self, rhs: u8) -> <u8 as NormalOut>::Output

fn _mul(self, rhs: u8) -> <u8 as NormalOut>::Output

fn _rem(self, rhs: u8) -> <u8 as NormalOut>::Output

fn _max(self, rhs: u8) -> <u8 as NormalOut>::Output

fn _min(self, rhs: u8) -> <u8 as NormalOut>::Output

impl NormalOut for u16

type Output = <u16 as NormalOutPromote>::Output

fn _pow(self, rhs: u16) -> <u16 as NormalOut>::Output

fn _clamp(self, min: u16, max: u16) -> <u16 as NormalOut>::Output

fn _mul_add(self, a: u16, b: u16) -> <u16 as NormalOut>::Output

fn _add(self, rhs: u16) -> <u16 as NormalOut>::Output

fn _sub(self, rhs: u16) -> <u16 as NormalOut>::Output

fn _mul(self, rhs: u16) -> <u16 as NormalOut>::Output

fn _rem(self, rhs: u16) -> <u16 as NormalOut>::Output

fn _max(self, rhs: u16) -> <u16 as NormalOut>::Output

fn _min(self, rhs: u16) -> <u16 as NormalOut>::Output

impl NormalOut for u32

type Output = <u32 as NormalOutPromote>::Output

fn _pow(self, rhs: u32) -> <u32 as NormalOut>::Output

fn _clamp(self, min: u32, max: u32) -> <u32 as NormalOut>::Output

fn _mul_add(self, a: u32, b: u32) -> <u32 as NormalOut>::Output

fn _add(self, rhs: u32) -> <u32 as NormalOut>::Output

fn _sub(self, rhs: u32) -> <u32 as NormalOut>::Output

fn _mul(self, rhs: u32) -> <u32 as NormalOut>::Output

fn _rem(self, rhs: u32) -> <u32 as NormalOut>::Output

fn _max(self, rhs: u32) -> <u32 as NormalOut>::Output

fn _min(self, rhs: u32) -> <u32 as NormalOut>::Output

impl NormalOut for u64

type Output = <u64 as NormalOutPromote>::Output

fn _pow(self, rhs: u64) -> <u64 as NormalOut>::Output

fn _clamp(self, min: u64, max: u64) -> <u64 as NormalOut>::Output

fn _mul_add(self, a: u64, b: u64) -> <u64 as NormalOut>::Output

fn _add(self, rhs: u64) -> <u64 as NormalOut>::Output

fn _sub(self, rhs: u64) -> <u64 as NormalOut>::Output

fn _mul(self, rhs: u64) -> <u64 as NormalOut>::Output

fn _rem(self, rhs: u64) -> <u64 as NormalOut>::Output

fn _max(self, rhs: u64) -> <u64 as NormalOut>::Output

fn _min(self, rhs: u64) -> <u64 as NormalOut>::Output

impl NormalOut for usize

type Output = <usize as NormalOutPromote>::Output

fn _pow(self, rhs: usize) -> <usize as NormalOut>::Output

fn _clamp(self, min: usize, max: usize) -> <usize as NormalOut>::Output

fn _mul_add(self, a: usize, b: usize) -> <usize as NormalOut>::Output

fn _add(self, rhs: usize) -> <usize as NormalOut>::Output

fn _sub(self, rhs: usize) -> <usize as NormalOut>::Output

fn _mul(self, rhs: usize) -> <usize as NormalOut>::Output

fn _rem(self, rhs: usize) -> <usize as NormalOut>::Output

fn _max(self, rhs: usize) -> <usize as NormalOut>::Output

fn _min(self, rhs: usize) -> <usize as NormalOut>::Output

impl NormalOut for bf16

type Output = <bf16 as NormalOutPromote>::Output

fn _pow(self, rhs: bf16) -> <bf16 as NormalOut>::Output

fn _clamp(self, min: bf16, max: bf16) -> <bf16 as NormalOut>::Output

fn _mul_add(self, a: bf16, b: bf16) -> <bf16 as NormalOut>::Output

fn _add(self, rhs: bf16) -> <bf16 as NormalOut>::Output

fn _sub(self, rhs: bf16) -> <bf16 as NormalOut>::Output

fn _mul(self, rhs: bf16) -> <bf16 as NormalOut>::Output

fn _rem(self, rhs: bf16) -> <bf16 as NormalOut>::Output

fn _max(self, rhs: bf16) -> <bf16 as NormalOut>::Output

fn _min(self, rhs: bf16) -> <bf16 as NormalOut>::Output

impl NormalOut for f16

type Output = <f16 as NormalOutPromote>::Output

fn _pow(self, rhs: f16) -> <f16 as NormalOut>::Output

fn _clamp(self, min: f16, max: f16) -> <f16 as NormalOut>::Output

fn _mul_add(self, a: f16, b: f16) -> <f16 as NormalOut>::Output

fn _add(self, rhs: f16) -> <f16 as NormalOut>::Output

fn _sub(self, rhs: f16) -> <f16 as NormalOut>::Output

fn _mul(self, rhs: f16) -> <f16 as NormalOut>::Output

fn _rem(self, rhs: f16) -> <f16 as NormalOut>::Output

fn _max(self, rhs: f16) -> <f16 as NormalOut>::Output

fn _min(self, rhs: f16) -> <f16 as NormalOut>::Output

impl NormalOut for Complex<f32>

type Output = <Complex<f32> as NormalOutPromote>::Output

fn _pow(self, rhs: Complex<f32>) -> <Complex<f32> as NormalOut>::Output

fn _clamp( self, min: Complex<f32>, max: Complex<f32>, ) -> <Complex<f32> as NormalOut>::Output

fn _mul_add( self, a: Complex<f32>, b: Complex<f32>, ) -> <Complex<f32> as NormalOut>::Output

fn _add(self, rhs: Complex<f32>) -> <Complex<f32> as NormalOut>::Output

fn _sub(self, rhs: Complex<f32>) -> <Complex<f32> as NormalOut>::Output

fn _mul(self, rhs: Complex<f32>) -> <Complex<f32> as NormalOut>::Output

fn _rem(self, rhs: Complex<f32>) -> <Complex<f32> as NormalOut>::Output

fn _max(self, rhs: Complex<f32>) -> <Complex<f32> as NormalOut>::Output

fn _min(self, rhs: Complex<f32>) -> <Complex<f32> as NormalOut>::Output

impl NormalOut for Complex<f64>

type Output = <Complex<f64> as NormalOutPromote>::Output

fn _pow(self, rhs: Complex<f64>) -> <Complex<f64> as NormalOut>::Output

fn _clamp( self, min: Complex<f64>, max: Complex<f64>, ) -> <Complex<f64> as NormalOut>::Output

fn _mul_add( self, a: Complex<f64>, b: Complex<f64>, ) -> <Complex<f64> as NormalOut>::Output

fn _add(self, rhs: Complex<f64>) -> <Complex<f64> as NormalOut>::Output

fn _sub(self, rhs: Complex<f64>) -> <Complex<f64> as NormalOut>::Output

fn _mul(self, rhs: Complex<f64>) -> <Complex<f64> as NormalOut>::Output

fn _rem(self, rhs: Complex<f64>) -> <Complex<f64> as NormalOut>::Output

fn _max(self, rhs: Complex<f64>) -> <Complex<f64> as NormalOut>::Output

fn _min(self, rhs: Complex<f64>) -> <Complex<f64> as NormalOut>::Output

impl NormalOut<bool> for f32

type Output = <f32 as NormalOutPromote<bool>>::Output

fn _pow(self, rhs: bool) -> <f32 as NormalOut<bool>>::Output

fn _clamp(self, min: bool, max: bool) -> <f32 as NormalOut<bool>>::Output

fn _mul_add(self, a: bool, b: bool) -> <f32 as NormalOut<bool>>::Output

fn _add(self, rhs: bool) -> <f32 as NormalOut<bool>>::Output

fn _sub(self, rhs: bool) -> <f32 as NormalOut<bool>>::Output

fn _mul(self, rhs: bool) -> <f32 as NormalOut<bool>>::Output

fn _rem(self, rhs: bool) -> <f32 as NormalOut<bool>>::Output

fn _max(self, rhs: bool) -> <f32 as NormalOut<bool>>::Output

fn _min(self, rhs: bool) -> <f32 as NormalOut<bool>>::Output

impl NormalOut<bool> for f64

type Output = <f64 as NormalOutPromote<bool>>::Output

fn _pow(self, rhs: bool) -> <f64 as NormalOut<bool>>::Output

fn _clamp(self, min: bool, max: bool) -> <f64 as NormalOut<bool>>::Output

fn _mul_add(self, a: bool, b: bool) -> <f64 as NormalOut<bool>>::Output

fn _add(self, rhs: bool) -> <f64 as NormalOut<bool>>::Output

fn _sub(self, rhs: bool) -> <f64 as NormalOut<bool>>::Output

fn _mul(self, rhs: bool) -> <f64 as NormalOut<bool>>::Output

fn _rem(self, rhs: bool) -> <f64 as NormalOut<bool>>::Output

fn _max(self, rhs: bool) -> <f64 as NormalOut<bool>>::Output

fn _min(self, rhs: bool) -> <f64 as NormalOut<bool>>::Output

impl NormalOut<bool> for i8

type Output = <i8 as NormalOutPromote<bool>>::Output

fn _pow(self, rhs: bool) -> <i8 as NormalOut<bool>>::Output

fn _clamp(self, min: bool, max: bool) -> <i8 as NormalOut<bool>>::Output

fn _mul_add(self, a: bool, b: bool) -> <i8 as NormalOut<bool>>::Output

fn _add(self, rhs: bool) -> <i8 as NormalOut<bool>>::Output

fn _sub(self, rhs: bool) -> <i8 as NormalOut<bool>>::Output

fn _mul(self, rhs: bool) -> <i8 as NormalOut<bool>>::Output

fn _rem(self, rhs: bool) -> <i8 as NormalOut<bool>>::Output

fn _max(self, rhs: bool) -> <i8 as NormalOut<bool>>::Output

fn _min(self, rhs: bool) -> <i8 as NormalOut<bool>>::Output

impl NormalOut<bool> for i16

type Output = <i16 as NormalOutPromote<bool>>::Output

fn _pow(self, rhs: bool) -> <i16 as NormalOut<bool>>::Output

fn _clamp(self, min: bool, max: bool) -> <i16 as NormalOut<bool>>::Output

fn _mul_add(self, a: bool, b: bool) -> <i16 as NormalOut<bool>>::Output

fn _add(self, rhs: bool) -> <i16 as NormalOut<bool>>::Output

fn _sub(self, rhs: bool) -> <i16 as NormalOut<bool>>::Output

fn _mul(self, rhs: bool) -> <i16 as NormalOut<bool>>::Output

fn _rem(self, rhs: bool) -> <i16 as NormalOut<bool>>::Output

fn _max(self, rhs: bool) -> <i16 as NormalOut<bool>>::Output

fn _min(self, rhs: bool) -> <i16 as NormalOut<bool>>::Output

impl NormalOut<bool> for i32

type Output = <i32 as NormalOutPromote<bool>>::Output

fn _pow(self, rhs: bool) -> <i32 as NormalOut<bool>>::Output

fn _clamp(self, min: bool, max: bool) -> <i32 as NormalOut<bool>>::Output

fn _mul_add(self, a: bool, b: bool) -> <i32 as NormalOut<bool>>::Output

fn _add(self, rhs: bool) -> <i32 as NormalOut<bool>>::Output

fn _sub(self, rhs: bool) -> <i32 as NormalOut<bool>>::Output

fn _mul(self, rhs: bool) -> <i32 as NormalOut<bool>>::Output

fn _rem(self, rhs: bool) -> <i32 as NormalOut<bool>>::Output

fn _max(self, rhs: bool) -> <i32 as NormalOut<bool>>::Output

fn _min(self, rhs: bool) -> <i32 as NormalOut<bool>>::Output

impl NormalOut<bool> for i64

type Output = <i64 as NormalOutPromote<bool>>::Output

fn _pow(self, rhs: bool) -> <i64 as NormalOut<bool>>::Output

fn _clamp(self, min: bool, max: bool) -> <i64 as NormalOut<bool>>::Output

fn _mul_add(self, a: bool, b: bool) -> <i64 as NormalOut<bool>>::Output

fn _add(self, rhs: bool) -> <i64 as NormalOut<bool>>::Output

fn _sub(self, rhs: bool) -> <i64 as NormalOut<bool>>::Output

fn _mul(self, rhs: bool) -> <i64 as NormalOut<bool>>::Output

fn _rem(self, rhs: bool) -> <i64 as NormalOut<bool>>::Output

fn _max(self, rhs: bool) -> <i64 as NormalOut<bool>>::Output

fn _min(self, rhs: bool) -> <i64 as NormalOut<bool>>::Output

impl NormalOut<bool> for isize

type Output = <isize as NormalOutPromote<bool>>::Output

fn _pow(self, rhs: bool) -> <isize as NormalOut<bool>>::Output

fn _clamp(self, min: bool, max: bool) -> <isize as NormalOut<bool>>::Output

fn _mul_add(self, a: bool, b: bool) -> <isize as NormalOut<bool>>::Output

fn _add(self, rhs: bool) -> <isize as NormalOut<bool>>::Output

fn _sub(self, rhs: bool) -> <isize as NormalOut<bool>>::Output

fn _mul(self, rhs: bool) -> <isize as NormalOut<bool>>::Output

fn _rem(self, rhs: bool) -> <isize as NormalOut<bool>>::Output

fn _max(self, rhs: bool) -> <isize as NormalOut<bool>>::Output

fn _min(self, rhs: bool) -> <isize as NormalOut<bool>>::Output

impl NormalOut<bool> for u8

type Output = <u8 as NormalOutPromote<bool>>::Output

fn _pow(self, rhs: bool) -> <u8 as NormalOut<bool>>::Output

fn _clamp(self, min: bool, max: bool) -> <u8 as NormalOut<bool>>::Output

fn _mul_add(self, a: bool, b: bool) -> <u8 as NormalOut<bool>>::Output

fn _add(self, rhs: bool) -> <u8 as NormalOut<bool>>::Output

fn _sub(self, rhs: bool) -> <u8 as NormalOut<bool>>::Output

fn _mul(self, rhs: bool) -> <u8 as NormalOut<bool>>::Output

fn _rem(self, rhs: bool) -> <u8 as NormalOut<bool>>::Output

fn _max(self, rhs: bool) -> <u8 as NormalOut<bool>>::Output

fn _min(self, rhs: bool) -> <u8 as NormalOut<bool>>::Output

impl NormalOut<bool> for u16

type Output = <u16 as NormalOutPromote<bool>>::Output

fn _pow(self, rhs: bool) -> <u16 as NormalOut<bool>>::Output

fn _clamp(self, min: bool, max: bool) -> <u16 as NormalOut<bool>>::Output

fn _mul_add(self, a: bool, b: bool) -> <u16 as NormalOut<bool>>::Output

fn _add(self, rhs: bool) -> <u16 as NormalOut<bool>>::Output

fn _sub(self, rhs: bool) -> <u16 as NormalOut<bool>>::Output

fn _mul(self, rhs: bool) -> <u16 as NormalOut<bool>>::Output

fn _rem(self, rhs: bool) -> <u16 as NormalOut<bool>>::Output

fn _max(self, rhs: bool) -> <u16 as NormalOut<bool>>::Output

fn _min(self, rhs: bool) -> <u16 as NormalOut<bool>>::Output

impl NormalOut<bool> for u32

type Output = <u32 as NormalOutPromote<bool>>::Output

fn _pow(self, rhs: bool) -> <u32 as NormalOut<bool>>::Output

fn _clamp(self, min: bool, max: bool) -> <u32 as NormalOut<bool>>::Output

fn _mul_add(self, a: bool, b: bool) -> <u32 as NormalOut<bool>>::Output

fn _add(self, rhs: bool) -> <u32 as NormalOut<bool>>::Output

fn _sub(self, rhs: bool) -> <u32 as NormalOut<bool>>::Output

fn _mul(self, rhs: bool) -> <u32 as NormalOut<bool>>::Output

fn _rem(self, rhs: bool) -> <u32 as NormalOut<bool>>::Output

fn _max(self, rhs: bool) -> <u32 as NormalOut<bool>>::Output

fn _min(self, rhs: bool) -> <u32 as NormalOut<bool>>::Output

impl NormalOut<bool> for u64

type Output = <u64 as NormalOutPromote<bool>>::Output

fn _pow(self, rhs: bool) -> <u64 as NormalOut<bool>>::Output

fn _clamp(self, min: bool, max: bool) -> <u64 as NormalOut<bool>>::Output

fn _mul_add(self, a: bool, b: bool) -> <u64 as NormalOut<bool>>::Output

fn _add(self, rhs: bool) -> <u64 as NormalOut<bool>>::Output

fn _sub(self, rhs: bool) -> <u64 as NormalOut<bool>>::Output

fn _mul(self, rhs: bool) -> <u64 as NormalOut<bool>>::Output

fn _rem(self, rhs: bool) -> <u64 as NormalOut<bool>>::Output

fn _max(self, rhs: bool) -> <u64 as NormalOut<bool>>::Output

fn _min(self, rhs: bool) -> <u64 as NormalOut<bool>>::Output

impl NormalOut<bool> for usize

type Output = <usize as NormalOutPromote<bool>>::Output

fn _pow(self, rhs: bool) -> <usize as NormalOut<bool>>::Output

fn _clamp(self, min: bool, max: bool) -> <usize as NormalOut<bool>>::Output

fn _mul_add(self, a: bool, b: bool) -> <usize as NormalOut<bool>>::Output

fn _add(self, rhs: bool) -> <usize as NormalOut<bool>>::Output

fn _sub(self, rhs: bool) -> <usize as NormalOut<bool>>::Output

fn _mul(self, rhs: bool) -> <usize as NormalOut<bool>>::Output

fn _rem(self, rhs: bool) -> <usize as NormalOut<bool>>::Output

fn _max(self, rhs: bool) -> <usize as NormalOut<bool>>::Output

fn _min(self, rhs: bool) -> <usize as NormalOut<bool>>::Output

impl NormalOut<bool> for bf16

type Output = <bf16 as NormalOutPromote<bool>>::Output

fn _pow(self, rhs: bool) -> <bf16 as NormalOut<bool>>::Output

fn _clamp(self, min: bool, max: bool) -> <bf16 as NormalOut<bool>>::Output

fn _mul_add(self, a: bool, b: bool) -> <bf16 as NormalOut<bool>>::Output

fn _add(self, rhs: bool) -> <bf16 as NormalOut<bool>>::Output

fn _sub(self, rhs: bool) -> <bf16 as NormalOut<bool>>::Output

fn _mul(self, rhs: bool) -> <bf16 as NormalOut<bool>>::Output

fn _rem(self, rhs: bool) -> <bf16 as NormalOut<bool>>::Output

fn _max(self, rhs: bool) -> <bf16 as NormalOut<bool>>::Output

fn _min(self, rhs: bool) -> <bf16 as NormalOut<bool>>::Output

impl NormalOut<bool> for f16

type Output = <f16 as NormalOutPromote<bool>>::Output

fn _pow(self, rhs: bool) -> <f16 as NormalOut<bool>>::Output

fn _clamp(self, min: bool, max: bool) -> <f16 as NormalOut<bool>>::Output

fn _mul_add(self, a: bool, b: bool) -> <f16 as NormalOut<bool>>::Output

fn _add(self, rhs: bool) -> <f16 as NormalOut<bool>>::Output

fn _sub(self, rhs: bool) -> <f16 as NormalOut<bool>>::Output

fn _mul(self, rhs: bool) -> <f16 as NormalOut<bool>>::Output

fn _rem(self, rhs: bool) -> <f16 as NormalOut<bool>>::Output

fn _max(self, rhs: bool) -> <f16 as NormalOut<bool>>::Output

fn _min(self, rhs: bool) -> <f16 as NormalOut<bool>>::Output

impl NormalOut<bool> for Complex<f32>

type Output = <Complex<f32> as NormalOutPromote<bool>>::Output

fn _pow(self, rhs: bool) -> <Complex<f32> as NormalOut<bool>>::Output

fn _clamp( self, min: bool, max: bool, ) -> <Complex<f32> as NormalOut<bool>>::Output

fn _mul_add(self, a: bool, b: bool) -> <Complex<f32> as NormalOut<bool>>::Output

fn _add(self, rhs: bool) -> <Complex<f32> as NormalOut<bool>>::Output

fn _sub(self, rhs: bool) -> <Complex<f32> as NormalOut<bool>>::Output

fn _mul(self, rhs: bool) -> <Complex<f32> as NormalOut<bool>>::Output

fn _rem(self, rhs: bool) -> <Complex<f32> as NormalOut<bool>>::Output

fn _max(self, rhs: bool) -> <Complex<f32> as NormalOut<bool>>::Output

fn _min(self, rhs: bool) -> <Complex<f32> as NormalOut<bool>>::Output

impl NormalOut<bool> for Complex<f64>

type Output = <Complex<f64> as NormalOutPromote<bool>>::Output

fn _pow(self, rhs: bool) -> <Complex<f64> as NormalOut<bool>>::Output

fn _clamp( self, min: bool, max: bool, ) -> <Complex<f64> as NormalOut<bool>>::Output

fn _mul_add(self, a: bool, b: bool) -> <Complex<f64> as NormalOut<bool>>::Output

fn _add(self, rhs: bool) -> <Complex<f64> as NormalOut<bool>>::Output

fn _sub(self, rhs: bool) -> <Complex<f64> as NormalOut<bool>>::Output

fn _mul(self, rhs: bool) -> <Complex<f64> as NormalOut<bool>>::Output

fn _rem(self, rhs: bool) -> <Complex<f64> as NormalOut<bool>>::Output

fn _max(self, rhs: bool) -> <Complex<f64> as NormalOut<bool>>::Output

fn _min(self, rhs: bool) -> <Complex<f64> as NormalOut<bool>>::Output

impl NormalOut<f32> for bool

type Output = <bool as NormalOutPromote<f32>>::Output

fn _pow(self, rhs: f32) -> <bool as NormalOut<f32>>::Output

fn _clamp(self, min: f32, max: f32) -> <bool as NormalOut<f32>>::Output

fn _mul_add(self, a: f32, b: f32) -> <bool as NormalOut<f32>>::Output

fn _add(self, rhs: f32) -> <bool as NormalOut<f32>>::Output

fn _sub(self, rhs: f32) -> <bool as NormalOut<f32>>::Output

fn _mul(self, rhs: f32) -> <bool as NormalOut<f32>>::Output

fn _rem(self, rhs: f32) -> <bool as NormalOut<f32>>::Output

fn _max(self, rhs: f32) -> <bool as NormalOut<f32>>::Output

fn _min(self, rhs: f32) -> <bool as NormalOut<f32>>::Output

impl NormalOut<f32> for f64

type Output = <f64 as NormalOutPromote<f32>>::Output

fn _pow(self, rhs: f32) -> <f64 as NormalOut<f32>>::Output

fn _clamp(self, min: f32, max: f32) -> <f64 as NormalOut<f32>>::Output

fn _mul_add(self, a: f32, b: f32) -> <f64 as NormalOut<f32>>::Output

fn _add(self, rhs: f32) -> <f64 as NormalOut<f32>>::Output

fn _sub(self, rhs: f32) -> <f64 as NormalOut<f32>>::Output

fn _mul(self, rhs: f32) -> <f64 as NormalOut<f32>>::Output

fn _rem(self, rhs: f32) -> <f64 as NormalOut<f32>>::Output

fn _max(self, rhs: f32) -> <f64 as NormalOut<f32>>::Output

fn _min(self, rhs: f32) -> <f64 as NormalOut<f32>>::Output

impl NormalOut<f32> for i8

type Output = <i8 as NormalOutPromote<f32>>::Output

fn _pow(self, rhs: f32) -> <i8 as NormalOut<f32>>::Output

fn _clamp(self, min: f32, max: f32) -> <i8 as NormalOut<f32>>::Output

fn _mul_add(self, a: f32, b: f32) -> <i8 as NormalOut<f32>>::Output

fn _add(self, rhs: f32) -> <i8 as NormalOut<f32>>::Output

fn _sub(self, rhs: f32) -> <i8 as NormalOut<f32>>::Output

fn _mul(self, rhs: f32) -> <i8 as NormalOut<f32>>::Output

fn _rem(self, rhs: f32) -> <i8 as NormalOut<f32>>::Output

fn _max(self, rhs: f32) -> <i8 as NormalOut<f32>>::Output

fn _min(self, rhs: f32) -> <i8 as NormalOut<f32>>::Output

impl NormalOut<f32> for i16

type Output = <i16 as NormalOutPromote<f32>>::Output

fn _pow(self, rhs: f32) -> <i16 as NormalOut<f32>>::Output

fn _clamp(self, min: f32, max: f32) -> <i16 as NormalOut<f32>>::Output

fn _mul_add(self, a: f32, b: f32) -> <i16 as NormalOut<f32>>::Output

fn _add(self, rhs: f32) -> <i16 as NormalOut<f32>>::Output

fn _sub(self, rhs: f32) -> <i16 as NormalOut<f32>>::Output

fn _mul(self, rhs: f32) -> <i16 as NormalOut<f32>>::Output

fn _rem(self, rhs: f32) -> <i16 as NormalOut<f32>>::Output

fn _max(self, rhs: f32) -> <i16 as NormalOut<f32>>::Output

fn _min(self, rhs: f32) -> <i16 as NormalOut<f32>>::Output

impl NormalOut<f32> for i32

type Output = <i32 as NormalOutPromote<f32>>::Output

fn _pow(self, rhs: f32) -> <i32 as NormalOut<f32>>::Output

fn _clamp(self, min: f32, max: f32) -> <i32 as NormalOut<f32>>::Output

fn _mul_add(self, a: f32, b: f32) -> <i32 as NormalOut<f32>>::Output

fn _add(self, rhs: f32) -> <i32 as NormalOut<f32>>::Output

fn _sub(self, rhs: f32) -> <i32 as NormalOut<f32>>::Output

fn _mul(self, rhs: f32) -> <i32 as NormalOut<f32>>::Output

fn _rem(self, rhs: f32) -> <i32 as NormalOut<f32>>::Output

fn _max(self, rhs: f32) -> <i32 as NormalOut<f32>>::Output

fn _min(self, rhs: f32) -> <i32 as NormalOut<f32>>::Output

impl NormalOut<f32> for i64

type Output = <i64 as NormalOutPromote<f32>>::Output

fn _pow(self, rhs: f32) -> <i64 as NormalOut<f32>>::Output

fn _clamp(self, min: f32, max: f32) -> <i64 as NormalOut<f32>>::Output

fn _mul_add(self, a: f32, b: f32) -> <i64 as NormalOut<f32>>::Output

fn _add(self, rhs: f32) -> <i64 as NormalOut<f32>>::Output

fn _sub(self, rhs: f32) -> <i64 as NormalOut<f32>>::Output

fn _mul(self, rhs: f32) -> <i64 as NormalOut<f32>>::Output

fn _rem(self, rhs: f32) -> <i64 as NormalOut<f32>>::Output

fn _max(self, rhs: f32) -> <i64 as NormalOut<f32>>::Output

fn _min(self, rhs: f32) -> <i64 as NormalOut<f32>>::Output

impl NormalOut<f32> for isize

type Output = <isize as NormalOutPromote<f32>>::Output

fn _pow(self, rhs: f32) -> <isize as NormalOut<f32>>::Output

fn _clamp(self, min: f32, max: f32) -> <isize as NormalOut<f32>>::Output

fn _mul_add(self, a: f32, b: f32) -> <isize as NormalOut<f32>>::Output

fn _add(self, rhs: f32) -> <isize as NormalOut<f32>>::Output

fn _sub(self, rhs: f32) -> <isize as NormalOut<f32>>::Output

fn _mul(self, rhs: f32) -> <isize as NormalOut<f32>>::Output

fn _rem(self, rhs: f32) -> <isize as NormalOut<f32>>::Output

fn _max(self, rhs: f32) -> <isize as NormalOut<f32>>::Output

fn _min(self, rhs: f32) -> <isize as NormalOut<f32>>::Output

impl NormalOut<f32> for u8

type Output = <u8 as NormalOutPromote<f32>>::Output

fn _pow(self, rhs: f32) -> <u8 as NormalOut<f32>>::Output

fn _clamp(self, min: f32, max: f32) -> <u8 as NormalOut<f32>>::Output

fn _mul_add(self, a: f32, b: f32) -> <u8 as NormalOut<f32>>::Output

fn _add(self, rhs: f32) -> <u8 as NormalOut<f32>>::Output

fn _sub(self, rhs: f32) -> <u8 as NormalOut<f32>>::Output

fn _mul(self, rhs: f32) -> <u8 as NormalOut<f32>>::Output

fn _rem(self, rhs: f32) -> <u8 as NormalOut<f32>>::Output

fn _max(self, rhs: f32) -> <u8 as NormalOut<f32>>::Output

fn _min(self, rhs: f32) -> <u8 as NormalOut<f32>>::Output

impl NormalOut<f32> for u16

type Output = <u16 as NormalOutPromote<f32>>::Output

fn _pow(self, rhs: f32) -> <u16 as NormalOut<f32>>::Output

fn _clamp(self, min: f32, max: f32) -> <u16 as NormalOut<f32>>::Output

fn _mul_add(self, a: f32, b: f32) -> <u16 as NormalOut<f32>>::Output

fn _add(self, rhs: f32) -> <u16 as NormalOut<f32>>::Output

fn _sub(self, rhs: f32) -> <u16 as NormalOut<f32>>::Output

fn _mul(self, rhs: f32) -> <u16 as NormalOut<f32>>::Output

fn _rem(self, rhs: f32) -> <u16 as NormalOut<f32>>::Output

fn _max(self, rhs: f32) -> <u16 as NormalOut<f32>>::Output

fn _min(self, rhs: f32) -> <u16 as NormalOut<f32>>::Output

impl NormalOut<f32> for u32

type Output = <u32 as NormalOutPromote<f32>>::Output

fn _pow(self, rhs: f32) -> <u32 as NormalOut<f32>>::Output

fn _clamp(self, min: f32, max: f32) -> <u32 as NormalOut<f32>>::Output

fn _mul_add(self, a: f32, b: f32) -> <u32 as NormalOut<f32>>::Output

fn _add(self, rhs: f32) -> <u32 as NormalOut<f32>>::Output

fn _sub(self, rhs: f32) -> <u32 as NormalOut<f32>>::Output

fn _mul(self, rhs: f32) -> <u32 as NormalOut<f32>>::Output

fn _rem(self, rhs: f32) -> <u32 as NormalOut<f32>>::Output

fn _max(self, rhs: f32) -> <u32 as NormalOut<f32>>::Output

fn _min(self, rhs: f32) -> <u32 as NormalOut<f32>>::Output

impl NormalOut<f32> for u64

type Output = <u64 as NormalOutPromote<f32>>::Output

fn _pow(self, rhs: f32) -> <u64 as NormalOut<f32>>::Output

fn _clamp(self, min: f32, max: f32) -> <u64 as NormalOut<f32>>::Output

fn _mul_add(self, a: f32, b: f32) -> <u64 as NormalOut<f32>>::Output

fn _add(self, rhs: f32) -> <u64 as NormalOut<f32>>::Output

fn _sub(self, rhs: f32) -> <u64 as NormalOut<f32>>::Output

fn _mul(self, rhs: f32) -> <u64 as NormalOut<f32>>::Output

fn _rem(self, rhs: f32) -> <u64 as NormalOut<f32>>::Output

fn _max(self, rhs: f32) -> <u64 as NormalOut<f32>>::Output

fn _min(self, rhs: f32) -> <u64 as NormalOut<f32>>::Output

impl NormalOut<f32> for usize

type Output = <usize as NormalOutPromote<f32>>::Output

fn _pow(self, rhs: f32) -> <usize as NormalOut<f32>>::Output

fn _clamp(self, min: f32, max: f32) -> <usize as NormalOut<f32>>::Output

fn _mul_add(self, a: f32, b: f32) -> <usize as NormalOut<f32>>::Output

fn _add(self, rhs: f32) -> <usize as NormalOut<f32>>::Output

fn _sub(self, rhs: f32) -> <usize as NormalOut<f32>>::Output

fn _mul(self, rhs: f32) -> <usize as NormalOut<f32>>::Output

fn _rem(self, rhs: f32) -> <usize as NormalOut<f32>>::Output

fn _max(self, rhs: f32) -> <usize as NormalOut<f32>>::Output

fn _min(self, rhs: f32) -> <usize as NormalOut<f32>>::Output

impl NormalOut<f32> for bf16

type Output = <bf16 as NormalOutPromote<f32>>::Output

fn _pow(self, rhs: f32) -> <bf16 as NormalOut<f32>>::Output

fn _clamp(self, min: f32, max: f32) -> <bf16 as NormalOut<f32>>::Output

fn _mul_add(self, a: f32, b: f32) -> <bf16 as NormalOut<f32>>::Output

fn _add(self, rhs: f32) -> <bf16 as NormalOut<f32>>::Output

fn _sub(self, rhs: f32) -> <bf16 as NormalOut<f32>>::Output

fn _mul(self, rhs: f32) -> <bf16 as NormalOut<f32>>::Output

fn _rem(self, rhs: f32) -> <bf16 as NormalOut<f32>>::Output

fn _max(self, rhs: f32) -> <bf16 as NormalOut<f32>>::Output

fn _min(self, rhs: f32) -> <bf16 as NormalOut<f32>>::Output

impl NormalOut<f32> for f16

type Output = <f16 as NormalOutPromote<f32>>::Output

fn _pow(self, rhs: f32) -> <f16 as NormalOut<f32>>::Output

fn _clamp(self, min: f32, max: f32) -> <f16 as NormalOut<f32>>::Output

fn _mul_add(self, a: f32, b: f32) -> <f16 as NormalOut<f32>>::Output

fn _add(self, rhs: f32) -> <f16 as NormalOut<f32>>::Output

fn _sub(self, rhs: f32) -> <f16 as NormalOut<f32>>::Output

fn _mul(self, rhs: f32) -> <f16 as NormalOut<f32>>::Output

fn _rem(self, rhs: f32) -> <f16 as NormalOut<f32>>::Output

fn _max(self, rhs: f32) -> <f16 as NormalOut<f32>>::Output

fn _min(self, rhs: f32) -> <f16 as NormalOut<f32>>::Output

impl NormalOut<f32> for Complex<f32>

type Output = <Complex<f32> as NormalOutPromote<f32>>::Output

fn _pow(self, rhs: f32) -> <Complex<f32> as NormalOut<f32>>::Output

fn _clamp(self, min: f32, max: f32) -> <Complex<f32> as NormalOut<f32>>::Output

fn _mul_add(self, a: f32, b: f32) -> <Complex<f32> as NormalOut<f32>>::Output

fn _add(self, rhs: f32) -> <Complex<f32> as NormalOut<f32>>::Output

fn _sub(self, rhs: f32) -> <Complex<f32> as NormalOut<f32>>::Output

fn _mul(self, rhs: f32) -> <Complex<f32> as NormalOut<f32>>::Output

fn _rem(self, rhs: f32) -> <Complex<f32> as NormalOut<f32>>::Output

fn _max(self, rhs: f32) -> <Complex<f32> as NormalOut<f32>>::Output

fn _min(self, rhs: f32) -> <Complex<f32> as NormalOut<f32>>::Output

impl NormalOut<f32> for Complex<f64>

type Output = <Complex<f64> as NormalOutPromote<f32>>::Output

fn _pow(self, rhs: f32) -> <Complex<f64> as NormalOut<f32>>::Output

fn _clamp(self, min: f32, max: f32) -> <Complex<f64> as NormalOut<f32>>::Output

fn _mul_add(self, a: f32, b: f32) -> <Complex<f64> as NormalOut<f32>>::Output

fn _add(self, rhs: f32) -> <Complex<f64> as NormalOut<f32>>::Output

fn _sub(self, rhs: f32) -> <Complex<f64> as NormalOut<f32>>::Output

fn _mul(self, rhs: f32) -> <Complex<f64> as NormalOut<f32>>::Output

fn _rem(self, rhs: f32) -> <Complex<f64> as NormalOut<f32>>::Output

fn _max(self, rhs: f32) -> <Complex<f64> as NormalOut<f32>>::Output

fn _min(self, rhs: f32) -> <Complex<f64> as NormalOut<f32>>::Output

impl NormalOut<f64> for bool

type Output = <bool as NormalOutPromote<f64>>::Output

fn _pow(self, rhs: f64) -> <bool as NormalOut<f64>>::Output

fn _clamp(self, min: f64, max: f64) -> <bool as NormalOut<f64>>::Output

fn _mul_add(self, a: f64, b: f64) -> <bool as NormalOut<f64>>::Output

fn _add(self, rhs: f64) -> <bool as NormalOut<f64>>::Output

fn _sub(self, rhs: f64) -> <bool as NormalOut<f64>>::Output

fn _mul(self, rhs: f64) -> <bool as NormalOut<f64>>::Output

fn _rem(self, rhs: f64) -> <bool as NormalOut<f64>>::Output

fn _max(self, rhs: f64) -> <bool as NormalOut<f64>>::Output

fn _min(self, rhs: f64) -> <bool as NormalOut<f64>>::Output

impl NormalOut<f64> for f32

type Output = <f32 as NormalOutPromote<f64>>::Output

fn _pow(self, rhs: f64) -> <f32 as NormalOut<f64>>::Output

fn _clamp(self, min: f64, max: f64) -> <f32 as NormalOut<f64>>::Output

fn _mul_add(self, a: f64, b: f64) -> <f32 as NormalOut<f64>>::Output

fn _add(self, rhs: f64) -> <f32 as NormalOut<f64>>::Output

fn _sub(self, rhs: f64) -> <f32 as NormalOut<f64>>::Output

fn _mul(self, rhs: f64) -> <f32 as NormalOut<f64>>::Output

fn _rem(self, rhs: f64) -> <f32 as NormalOut<f64>>::Output

fn _max(self, rhs: f64) -> <f32 as NormalOut<f64>>::Output

fn _min(self, rhs: f64) -> <f32 as NormalOut<f64>>::Output

impl NormalOut<f64> for i8

type Output = <i8 as NormalOutPromote<f64>>::Output

fn _pow(self, rhs: f64) -> <i8 as NormalOut<f64>>::Output

fn _clamp(self, min: f64, max: f64) -> <i8 as NormalOut<f64>>::Output

fn _mul_add(self, a: f64, b: f64) -> <i8 as NormalOut<f64>>::Output

fn _add(self, rhs: f64) -> <i8 as NormalOut<f64>>::Output

fn _sub(self, rhs: f64) -> <i8 as NormalOut<f64>>::Output

fn _mul(self, rhs: f64) -> <i8 as NormalOut<f64>>::Output

fn _rem(self, rhs: f64) -> <i8 as NormalOut<f64>>::Output

fn _max(self, rhs: f64) -> <i8 as NormalOut<f64>>::Output

fn _min(self, rhs: f64) -> <i8 as NormalOut<f64>>::Output

impl NormalOut<f64> for i16

type Output = <i16 as NormalOutPromote<f64>>::Output

fn _pow(self, rhs: f64) -> <i16 as NormalOut<f64>>::Output

fn _clamp(self, min: f64, max: f64) -> <i16 as NormalOut<f64>>::Output

fn _mul_add(self, a: f64, b: f64) -> <i16 as NormalOut<f64>>::Output

fn _add(self, rhs: f64) -> <i16 as NormalOut<f64>>::Output

fn _sub(self, rhs: f64) -> <i16 as NormalOut<f64>>::Output

fn _mul(self, rhs: f64) -> <i16 as NormalOut<f64>>::Output

fn _rem(self, rhs: f64) -> <i16 as NormalOut<f64>>::Output

fn _max(self, rhs: f64) -> <i16 as NormalOut<f64>>::Output

fn _min(self, rhs: f64) -> <i16 as NormalOut<f64>>::Output

impl NormalOut<f64> for i32

type Output = <i32 as NormalOutPromote<f64>>::Output

fn _pow(self, rhs: f64) -> <i32 as NormalOut<f64>>::Output

fn _clamp(self, min: f64, max: f64) -> <i32 as NormalOut<f64>>::Output

fn _mul_add(self, a: f64, b: f64) -> <i32 as NormalOut<f64>>::Output

fn _add(self, rhs: f64) -> <i32 as NormalOut<f64>>::Output

fn _sub(self, rhs: f64) -> <i32 as NormalOut<f64>>::Output

fn _mul(self, rhs: f64) -> <i32 as NormalOut<f64>>::Output

fn _rem(self, rhs: f64) -> <i32 as NormalOut<f64>>::Output

fn _max(self, rhs: f64) -> <i32 as NormalOut<f64>>::Output

fn _min(self, rhs: f64) -> <i32 as NormalOut<f64>>::Output

impl NormalOut<f64> for i64

type Output = <i64 as NormalOutPromote<f64>>::Output

fn _pow(self, rhs: f64) -> <i64 as NormalOut<f64>>::Output

fn _clamp(self, min: f64, max: f64) -> <i64 as NormalOut<f64>>::Output

fn _mul_add(self, a: f64, b: f64) -> <i64 as NormalOut<f64>>::Output

fn _add(self, rhs: f64) -> <i64 as NormalOut<f64>>::Output

fn _sub(self, rhs: f64) -> <i64 as NormalOut<f64>>::Output

fn _mul(self, rhs: f64) -> <i64 as NormalOut<f64>>::Output

fn _rem(self, rhs: f64) -> <i64 as NormalOut<f64>>::Output

fn _max(self, rhs: f64) -> <i64 as NormalOut<f64>>::Output

fn _min(self, rhs: f64) -> <i64 as NormalOut<f64>>::Output

impl NormalOut<f64> for isize

type Output = <isize as NormalOutPromote<f64>>::Output

fn _pow(self, rhs: f64) -> <isize as NormalOut<f64>>::Output

fn _clamp(self, min: f64, max: f64) -> <isize as NormalOut<f64>>::Output

fn _mul_add(self, a: f64, b: f64) -> <isize as NormalOut<f64>>::Output

fn _add(self, rhs: f64) -> <isize as NormalOut<f64>>::Output

fn _sub(self, rhs: f64) -> <isize as NormalOut<f64>>::Output

fn _mul(self, rhs: f64) -> <isize as NormalOut<f64>>::Output

fn _rem(self, rhs: f64) -> <isize as NormalOut<f64>>::Output

fn _max(self, rhs: f64) -> <isize as NormalOut<f64>>::Output

fn _min(self, rhs: f64) -> <isize as NormalOut<f64>>::Output

impl NormalOut<f64> for u8

type Output = <u8 as NormalOutPromote<f64>>::Output

fn _pow(self, rhs: f64) -> <u8 as NormalOut<f64>>::Output

fn _clamp(self, min: f64, max: f64) -> <u8 as NormalOut<f64>>::Output

fn _mul_add(self, a: f64, b: f64) -> <u8 as NormalOut<f64>>::Output

fn _add(self, rhs: f64) -> <u8 as NormalOut<f64>>::Output

fn _sub(self, rhs: f64) -> <u8 as NormalOut<f64>>::Output

fn _mul(self, rhs: f64) -> <u8 as NormalOut<f64>>::Output

fn _rem(self, rhs: f64) -> <u8 as NormalOut<f64>>::Output

fn _max(self, rhs: f64) -> <u8 as NormalOut<f64>>::Output

fn _min(self, rhs: f64) -> <u8 as NormalOut<f64>>::Output

impl NormalOut<f64> for u16

type Output = <u16 as NormalOutPromote<f64>>::Output

fn _pow(self, rhs: f64) -> <u16 as NormalOut<f64>>::Output

fn _clamp(self, min: f64, max: f64) -> <u16 as NormalOut<f64>>::Output

fn _mul_add(self, a: f64, b: f64) -> <u16 as NormalOut<f64>>::Output

fn _add(self, rhs: f64) -> <u16 as NormalOut<f64>>::Output

fn _sub(self, rhs: f64) -> <u16 as NormalOut<f64>>::Output

fn _mul(self, rhs: f64) -> <u16 as NormalOut<f64>>::Output

fn _rem(self, rhs: f64) -> <u16 as NormalOut<f64>>::Output

fn _max(self, rhs: f64) -> <u16 as NormalOut<f64>>::Output

fn _min(self, rhs: f64) -> <u16 as NormalOut<f64>>::Output

impl NormalOut<f64> for u32

type Output = <u32 as NormalOutPromote<f64>>::Output

fn _pow(self, rhs: f64) -> <u32 as NormalOut<f64>>::Output

fn _clamp(self, min: f64, max: f64) -> <u32 as NormalOut<f64>>::Output

fn _mul_add(self, a: f64, b: f64) -> <u32 as NormalOut<f64>>::Output

fn _add(self, rhs: f64) -> <u32 as NormalOut<f64>>::Output

fn _sub(self, rhs: f64) -> <u32 as NormalOut<f64>>::Output

fn _mul(self, rhs: f64) -> <u32 as NormalOut<f64>>::Output

fn _rem(self, rhs: f64) -> <u32 as NormalOut<f64>>::Output

fn _max(self, rhs: f64) -> <u32 as NormalOut<f64>>::Output

fn _min(self, rhs: f64) -> <u32 as NormalOut<f64>>::Output

impl NormalOut<f64> for u64

type Output = <u64 as NormalOutPromote<f64>>::Output

fn _pow(self, rhs: f64) -> <u64 as NormalOut<f64>>::Output

fn _clamp(self, min: f64, max: f64) -> <u64 as NormalOut<f64>>::Output

fn _mul_add(self, a: f64, b: f64) -> <u64 as NormalOut<f64>>::Output

fn _add(self, rhs: f64) -> <u64 as NormalOut<f64>>::Output

fn _sub(self, rhs: f64) -> <u64 as NormalOut<f64>>::Output

fn _mul(self, rhs: f64) -> <u64 as NormalOut<f64>>::Output

fn _rem(self, rhs: f64) -> <u64 as NormalOut<f64>>::Output

fn _max(self, rhs: f64) -> <u64 as NormalOut<f64>>::Output

fn _min(self, rhs: f64) -> <u64 as NormalOut<f64>>::Output

impl NormalOut<f64> for usize

type Output = <usize as NormalOutPromote<f64>>::Output

fn _pow(self, rhs: f64) -> <usize as NormalOut<f64>>::Output

fn _clamp(self, min: f64, max: f64) -> <usize as NormalOut<f64>>::Output

fn _mul_add(self, a: f64, b: f64) -> <usize as NormalOut<f64>>::Output

fn _add(self, rhs: f64) -> <usize as NormalOut<f64>>::Output

fn _sub(self, rhs: f64) -> <usize as NormalOut<f64>>::Output

fn _mul(self, rhs: f64) -> <usize as NormalOut<f64>>::Output

fn _rem(self, rhs: f64) -> <usize as NormalOut<f64>>::Output

fn _max(self, rhs: f64) -> <usize as NormalOut<f64>>::Output

fn _min(self, rhs: f64) -> <usize as NormalOut<f64>>::Output

impl NormalOut<f64> for bf16

type Output = <bf16 as NormalOutPromote<f64>>::Output

fn _pow(self, rhs: f64) -> <bf16 as NormalOut<f64>>::Output

fn _clamp(self, min: f64, max: f64) -> <bf16 as NormalOut<f64>>::Output

fn _mul_add(self, a: f64, b: f64) -> <bf16 as NormalOut<f64>>::Output

fn _add(self, rhs: f64) -> <bf16 as NormalOut<f64>>::Output

fn _sub(self, rhs: f64) -> <bf16 as NormalOut<f64>>::Output

fn _mul(self, rhs: f64) -> <bf16 as NormalOut<f64>>::Output

fn _rem(self, rhs: f64) -> <bf16 as NormalOut<f64>>::Output

fn _max(self, rhs: f64) -> <bf16 as NormalOut<f64>>::Output

fn _min(self, rhs: f64) -> <bf16 as NormalOut<f64>>::Output

impl NormalOut<f64> for f16

type Output = <f16 as NormalOutPromote<f64>>::Output

fn _pow(self, rhs: f64) -> <f16 as NormalOut<f64>>::Output

fn _clamp(self, min: f64, max: f64) -> <f16 as NormalOut<f64>>::Output

fn _mul_add(self, a: f64, b: f64) -> <f16 as NormalOut<f64>>::Output

fn _add(self, rhs: f64) -> <f16 as NormalOut<f64>>::Output

fn _sub(self, rhs: f64) -> <f16 as NormalOut<f64>>::Output

fn _mul(self, rhs: f64) -> <f16 as NormalOut<f64>>::Output

fn _rem(self, rhs: f64) -> <f16 as NormalOut<f64>>::Output

fn _max(self, rhs: f64) -> <f16 as NormalOut<f64>>::Output

fn _min(self, rhs: f64) -> <f16 as NormalOut<f64>>::Output

impl NormalOut<f64> for Complex<f32>

type Output = <Complex<f32> as NormalOutPromote<f64>>::Output

fn _pow(self, rhs: f64) -> <Complex<f32> as NormalOut<f64>>::Output

fn _clamp(self, min: f64, max: f64) -> <Complex<f32> as NormalOut<f64>>::Output

fn _mul_add(self, a: f64, b: f64) -> <Complex<f32> as NormalOut<f64>>::Output

fn _add(self, rhs: f64) -> <Complex<f32> as NormalOut<f64>>::Output

fn _sub(self, rhs: f64) -> <Complex<f32> as NormalOut<f64>>::Output

fn _mul(self, rhs: f64) -> <Complex<f32> as NormalOut<f64>>::Output

fn _rem(self, rhs: f64) -> <Complex<f32> as NormalOut<f64>>::Output

fn _max(self, rhs: f64) -> <Complex<f32> as NormalOut<f64>>::Output

fn _min(self, rhs: f64) -> <Complex<f32> as NormalOut<f64>>::Output

impl NormalOut<f64> for Complex<f64>

type Output = <Complex<f64> as NormalOutPromote<f64>>::Output

fn _pow(self, rhs: f64) -> <Complex<f64> as NormalOut<f64>>::Output

fn _clamp(self, min: f64, max: f64) -> <Complex<f64> as NormalOut<f64>>::Output

fn _mul_add(self, a: f64, b: f64) -> <Complex<f64> as NormalOut<f64>>::Output

fn _add(self, rhs: f64) -> <Complex<f64> as NormalOut<f64>>::Output

fn _sub(self, rhs: f64) -> <Complex<f64> as NormalOut<f64>>::Output

fn _mul(self, rhs: f64) -> <Complex<f64> as NormalOut<f64>>::Output

fn _rem(self, rhs: f64) -> <Complex<f64> as NormalOut<f64>>::Output

fn _max(self, rhs: f64) -> <Complex<f64> as NormalOut<f64>>::Output

fn _min(self, rhs: f64) -> <Complex<f64> as NormalOut<f64>>::Output

impl NormalOut<i8> for bool

type Output = <bool as NormalOutPromote<i8>>::Output

fn _pow(self, rhs: i8) -> <bool as NormalOut<i8>>::Output

fn _clamp(self, min: i8, max: i8) -> <bool as NormalOut<i8>>::Output

fn _mul_add(self, a: i8, b: i8) -> <bool as NormalOut<i8>>::Output

fn _add(self, rhs: i8) -> <bool as NormalOut<i8>>::Output

fn _sub(self, rhs: i8) -> <bool as NormalOut<i8>>::Output

fn _mul(self, rhs: i8) -> <bool as NormalOut<i8>>::Output

fn _rem(self, rhs: i8) -> <bool as NormalOut<i8>>::Output

fn _max(self, rhs: i8) -> <bool as NormalOut<i8>>::Output

fn _min(self, rhs: i8) -> <bool as NormalOut<i8>>::Output

impl NormalOut<i8> for f32

type Output = <f32 as NormalOutPromote<i8>>::Output

fn _pow(self, rhs: i8) -> <f32 as NormalOut<i8>>::Output

fn _clamp(self, min: i8, max: i8) -> <f32 as NormalOut<i8>>::Output

fn _mul_add(self, a: i8, b: i8) -> <f32 as NormalOut<i8>>::Output

fn _add(self, rhs: i8) -> <f32 as NormalOut<i8>>::Output

fn _sub(self, rhs: i8) -> <f32 as NormalOut<i8>>::Output

fn _mul(self, rhs: i8) -> <f32 as NormalOut<i8>>::Output

fn _rem(self, rhs: i8) -> <f32 as NormalOut<i8>>::Output

fn _max(self, rhs: i8) -> <f32 as NormalOut<i8>>::Output

fn _min(self, rhs: i8) -> <f32 as NormalOut<i8>>::Output

impl NormalOut<i8> for f64

type Output = <f64 as NormalOutPromote<i8>>::Output

fn _pow(self, rhs: i8) -> <f64 as NormalOut<i8>>::Output

fn _clamp(self, min: i8, max: i8) -> <f64 as NormalOut<i8>>::Output

fn _mul_add(self, a: i8, b: i8) -> <f64 as NormalOut<i8>>::Output

fn _add(self, rhs: i8) -> <f64 as NormalOut<i8>>::Output

fn _sub(self, rhs: i8) -> <f64 as NormalOut<i8>>::Output

fn _mul(self, rhs: i8) -> <f64 as NormalOut<i8>>::Output

fn _rem(self, rhs: i8) -> <f64 as NormalOut<i8>>::Output

fn _max(self, rhs: i8) -> <f64 as NormalOut<i8>>::Output

fn _min(self, rhs: i8) -> <f64 as NormalOut<i8>>::Output

impl NormalOut<i8> for i16

type Output = <i16 as NormalOutPromote<i8>>::Output

fn _pow(self, rhs: i8) -> <i16 as NormalOut<i8>>::Output

fn _clamp(self, min: i8, max: i8) -> <i16 as NormalOut<i8>>::Output

fn _mul_add(self, a: i8, b: i8) -> <i16 as NormalOut<i8>>::Output

fn _add(self, rhs: i8) -> <i16 as NormalOut<i8>>::Output

fn _sub(self, rhs: i8) -> <i16 as NormalOut<i8>>::Output

fn _mul(self, rhs: i8) -> <i16 as NormalOut<i8>>::Output

fn _rem(self, rhs: i8) -> <i16 as NormalOut<i8>>::Output

fn _max(self, rhs: i8) -> <i16 as NormalOut<i8>>::Output

fn _min(self, rhs: i8) -> <i16 as NormalOut<i8>>::Output

impl NormalOut<i8> for i32

type Output = <i32 as NormalOutPromote<i8>>::Output

fn _pow(self, rhs: i8) -> <i32 as NormalOut<i8>>::Output

fn _clamp(self, min: i8, max: i8) -> <i32 as NormalOut<i8>>::Output

fn _mul_add(self, a: i8, b: i8) -> <i32 as NormalOut<i8>>::Output

fn _add(self, rhs: i8) -> <i32 as NormalOut<i8>>::Output

fn _sub(self, rhs: i8) -> <i32 as NormalOut<i8>>::Output

fn _mul(self, rhs: i8) -> <i32 as NormalOut<i8>>::Output

fn _rem(self, rhs: i8) -> <i32 as NormalOut<i8>>::Output

fn _max(self, rhs: i8) -> <i32 as NormalOut<i8>>::Output

fn _min(self, rhs: i8) -> <i32 as NormalOut<i8>>::Output

impl NormalOut<i8> for i64

type Output = <i64 as NormalOutPromote<i8>>::Output

fn _pow(self, rhs: i8) -> <i64 as NormalOut<i8>>::Output

fn _clamp(self, min: i8, max: i8) -> <i64 as NormalOut<i8>>::Output

fn _mul_add(self, a: i8, b: i8) -> <i64 as NormalOut<i8>>::Output

fn _add(self, rhs: i8) -> <i64 as NormalOut<i8>>::Output

fn _sub(self, rhs: i8) -> <i64 as NormalOut<i8>>::Output

fn _mul(self, rhs: i8) -> <i64 as NormalOut<i8>>::Output

fn _rem(self, rhs: i8) -> <i64 as NormalOut<i8>>::Output

fn _max(self, rhs: i8) -> <i64 as NormalOut<i8>>::Output

fn _min(self, rhs: i8) -> <i64 as NormalOut<i8>>::Output

impl NormalOut<i8> for isize

type Output = <isize as NormalOutPromote<i8>>::Output

fn _pow(self, rhs: i8) -> <isize as NormalOut<i8>>::Output

fn _clamp(self, min: i8, max: i8) -> <isize as NormalOut<i8>>::Output

fn _mul_add(self, a: i8, b: i8) -> <isize as NormalOut<i8>>::Output

fn _add(self, rhs: i8) -> <isize as NormalOut<i8>>::Output

fn _sub(self, rhs: i8) -> <isize as NormalOut<i8>>::Output

fn _mul(self, rhs: i8) -> <isize as NormalOut<i8>>::Output

fn _rem(self, rhs: i8) -> <isize as NormalOut<i8>>::Output

fn _max(self, rhs: i8) -> <isize as NormalOut<i8>>::Output

fn _min(self, rhs: i8) -> <isize as NormalOut<i8>>::Output

impl NormalOut<i8> for u8

type Output = <u8 as NormalOutPromote<i8>>::Output

fn _pow(self, rhs: i8) -> <u8 as NormalOut<i8>>::Output

fn _clamp(self, min: i8, max: i8) -> <u8 as NormalOut<i8>>::Output

fn _mul_add(self, a: i8, b: i8) -> <u8 as NormalOut<i8>>::Output

fn _add(self, rhs: i8) -> <u8 as NormalOut<i8>>::Output

fn _sub(self, rhs: i8) -> <u8 as NormalOut<i8>>::Output

fn _mul(self, rhs: i8) -> <u8 as NormalOut<i8>>::Output

fn _rem(self, rhs: i8) -> <u8 as NormalOut<i8>>::Output

fn _max(self, rhs: i8) -> <u8 as NormalOut<i8>>::Output

fn _min(self, rhs: i8) -> <u8 as NormalOut<i8>>::Output

impl NormalOut<i8> for u16

type Output = <u16 as NormalOutPromote<i8>>::Output

fn _pow(self, rhs: i8) -> <u16 as NormalOut<i8>>::Output

fn _clamp(self, min: i8, max: i8) -> <u16 as NormalOut<i8>>::Output

fn _mul_add(self, a: i8, b: i8) -> <u16 as NormalOut<i8>>::Output

fn _add(self, rhs: i8) -> <u16 as NormalOut<i8>>::Output

fn _sub(self, rhs: i8) -> <u16 as NormalOut<i8>>::Output

fn _mul(self, rhs: i8) -> <u16 as NormalOut<i8>>::Output

fn _rem(self, rhs: i8) -> <u16 as NormalOut<i8>>::Output

fn _max(self, rhs: i8) -> <u16 as NormalOut<i8>>::Output

fn _min(self, rhs: i8) -> <u16 as NormalOut<i8>>::Output

impl NormalOut<i8> for u32

type Output = <u32 as NormalOutPromote<i8>>::Output

fn _pow(self, rhs: i8) -> <u32 as NormalOut<i8>>::Output

fn _clamp(self, min: i8, max: i8) -> <u32 as NormalOut<i8>>::Output

fn _mul_add(self, a: i8, b: i8) -> <u32 as NormalOut<i8>>::Output

fn _add(self, rhs: i8) -> <u32 as NormalOut<i8>>::Output

fn _sub(self, rhs: i8) -> <u32 as NormalOut<i8>>::Output

fn _mul(self, rhs: i8) -> <u32 as NormalOut<i8>>::Output

fn _rem(self, rhs: i8) -> <u32 as NormalOut<i8>>::Output

fn _max(self, rhs: i8) -> <u32 as NormalOut<i8>>::Output

fn _min(self, rhs: i8) -> <u32 as NormalOut<i8>>::Output

impl NormalOut<i8> for u64

type Output = <u64 as NormalOutPromote<i8>>::Output

fn _pow(self, rhs: i8) -> <u64 as NormalOut<i8>>::Output

fn _clamp(self, min: i8, max: i8) -> <u64 as NormalOut<i8>>::Output

fn _mul_add(self, a: i8, b: i8) -> <u64 as NormalOut<i8>>::Output

fn _add(self, rhs: i8) -> <u64 as NormalOut<i8>>::Output

fn _sub(self, rhs: i8) -> <u64 as NormalOut<i8>>::Output

fn _mul(self, rhs: i8) -> <u64 as NormalOut<i8>>::Output

fn _rem(self, rhs: i8) -> <u64 as NormalOut<i8>>::Output

fn _max(self, rhs: i8) -> <u64 as NormalOut<i8>>::Output

fn _min(self, rhs: i8) -> <u64 as NormalOut<i8>>::Output

impl NormalOut<i8> for usize

type Output = <usize as NormalOutPromote<i8>>::Output

fn _pow(self, rhs: i8) -> <usize as NormalOut<i8>>::Output

fn _clamp(self, min: i8, max: i8) -> <usize as NormalOut<i8>>::Output

fn _mul_add(self, a: i8, b: i8) -> <usize as NormalOut<i8>>::Output

fn _add(self, rhs: i8) -> <usize as NormalOut<i8>>::Output

fn _sub(self, rhs: i8) -> <usize as NormalOut<i8>>::Output

fn _mul(self, rhs: i8) -> <usize as NormalOut<i8>>::Output

fn _rem(self, rhs: i8) -> <usize as NormalOut<i8>>::Output

fn _max(self, rhs: i8) -> <usize as NormalOut<i8>>::Output

fn _min(self, rhs: i8) -> <usize as NormalOut<i8>>::Output

impl NormalOut<i8> for bf16

type Output = <bf16 as NormalOutPromote<i8>>::Output

fn _pow(self, rhs: i8) -> <bf16 as NormalOut<i8>>::Output

fn _clamp(self, min: i8, max: i8) -> <bf16 as NormalOut<i8>>::Output

fn _mul_add(self, a: i8, b: i8) -> <bf16 as NormalOut<i8>>::Output

fn _add(self, rhs: i8) -> <bf16 as NormalOut<i8>>::Output

fn _sub(self, rhs: i8) -> <bf16 as NormalOut<i8>>::Output

fn _mul(self, rhs: i8) -> <bf16 as NormalOut<i8>>::Output

fn _rem(self, rhs: i8) -> <bf16 as NormalOut<i8>>::Output

fn _max(self, rhs: i8) -> <bf16 as NormalOut<i8>>::Output

fn _min(self, rhs: i8) -> <bf16 as NormalOut<i8>>::Output

impl NormalOut<i8> for f16

type Output = <f16 as NormalOutPromote<i8>>::Output

fn _pow(self, rhs: i8) -> <f16 as NormalOut<i8>>::Output

fn _clamp(self, min: i8, max: i8) -> <f16 as NormalOut<i8>>::Output

fn _mul_add(self, a: i8, b: i8) -> <f16 as NormalOut<i8>>::Output

fn _add(self, rhs: i8) -> <f16 as NormalOut<i8>>::Output

fn _sub(self, rhs: i8) -> <f16 as NormalOut<i8>>::Output

fn _mul(self, rhs: i8) -> <f16 as NormalOut<i8>>::Output

fn _rem(self, rhs: i8) -> <f16 as NormalOut<i8>>::Output

fn _max(self, rhs: i8) -> <f16 as NormalOut<i8>>::Output

fn _min(self, rhs: i8) -> <f16 as NormalOut<i8>>::Output

impl NormalOut<i8> for Complex<f32>

type Output = <Complex<f32> as NormalOutPromote<i8>>::Output

fn _pow(self, rhs: i8) -> <Complex<f32> as NormalOut<i8>>::Output

fn _clamp(self, min: i8, max: i8) -> <Complex<f32> as NormalOut<i8>>::Output

fn _mul_add(self, a: i8, b: i8) -> <Complex<f32> as NormalOut<i8>>::Output

fn _add(self, rhs: i8) -> <Complex<f32> as NormalOut<i8>>::Output

fn _sub(self, rhs: i8) -> <Complex<f32> as NormalOut<i8>>::Output

fn _mul(self, rhs: i8) -> <Complex<f32> as NormalOut<i8>>::Output

fn _rem(self, rhs: i8) -> <Complex<f32> as NormalOut<i8>>::Output

fn _max(self, rhs: i8) -> <Complex<f32> as NormalOut<i8>>::Output

fn _min(self, rhs: i8) -> <Complex<f32> as NormalOut<i8>>::Output

impl NormalOut<i8> for Complex<f64>

type Output = <Complex<f64> as NormalOutPromote<i8>>::Output

fn _pow(self, rhs: i8) -> <Complex<f64> as NormalOut<i8>>::Output

fn _clamp(self, min: i8, max: i8) -> <Complex<f64> as NormalOut<i8>>::Output

fn _mul_add(self, a: i8, b: i8) -> <Complex<f64> as NormalOut<i8>>::Output

fn _add(self, rhs: i8) -> <Complex<f64> as NormalOut<i8>>::Output

fn _sub(self, rhs: i8) -> <Complex<f64> as NormalOut<i8>>::Output

fn _mul(self, rhs: i8) -> <Complex<f64> as NormalOut<i8>>::Output

fn _rem(self, rhs: i8) -> <Complex<f64> as NormalOut<i8>>::Output

fn _max(self, rhs: i8) -> <Complex<f64> as NormalOut<i8>>::Output

fn _min(self, rhs: i8) -> <Complex<f64> as NormalOut<i8>>::Output

impl NormalOut<i16> for bool

type Output = <bool as NormalOutPromote<i16>>::Output

fn _pow(self, rhs: i16) -> <bool as NormalOut<i16>>::Output

fn _clamp(self, min: i16, max: i16) -> <bool as NormalOut<i16>>::Output

fn _mul_add(self, a: i16, b: i16) -> <bool as NormalOut<i16>>::Output

fn _add(self, rhs: i16) -> <bool as NormalOut<i16>>::Output

fn _sub(self, rhs: i16) -> <bool as NormalOut<i16>>::Output

fn _mul(self, rhs: i16) -> <bool as NormalOut<i16>>::Output

fn _rem(self, rhs: i16) -> <bool as NormalOut<i16>>::Output

fn _max(self, rhs: i16) -> <bool as NormalOut<i16>>::Output

fn _min(self, rhs: i16) -> <bool as NormalOut<i16>>::Output

impl NormalOut<i16> for f32

type Output = <f32 as NormalOutPromote<i16>>::Output

fn _pow(self, rhs: i16) -> <f32 as NormalOut<i16>>::Output

fn _clamp(self, min: i16, max: i16) -> <f32 as NormalOut<i16>>::Output

fn _mul_add(self, a: i16, b: i16) -> <f32 as NormalOut<i16>>::Output

fn _add(self, rhs: i16) -> <f32 as NormalOut<i16>>::Output

fn _sub(self, rhs: i16) -> <f32 as NormalOut<i16>>::Output

fn _mul(self, rhs: i16) -> <f32 as NormalOut<i16>>::Output

fn _rem(self, rhs: i16) -> <f32 as NormalOut<i16>>::Output

fn _max(self, rhs: i16) -> <f32 as NormalOut<i16>>::Output

fn _min(self, rhs: i16) -> <f32 as NormalOut<i16>>::Output

impl NormalOut<i16> for f64

type Output = <f64 as NormalOutPromote<i16>>::Output

fn _pow(self, rhs: i16) -> <f64 as NormalOut<i16>>::Output

fn _clamp(self, min: i16, max: i16) -> <f64 as NormalOut<i16>>::Output

fn _mul_add(self, a: i16, b: i16) -> <f64 as NormalOut<i16>>::Output

fn _add(self, rhs: i16) -> <f64 as NormalOut<i16>>::Output

fn _sub(self, rhs: i16) -> <f64 as NormalOut<i16>>::Output

fn _mul(self, rhs: i16) -> <f64 as NormalOut<i16>>::Output

fn _rem(self, rhs: i16) -> <f64 as NormalOut<i16>>::Output

fn _max(self, rhs: i16) -> <f64 as NormalOut<i16>>::Output

fn _min(self, rhs: i16) -> <f64 as NormalOut<i16>>::Output

impl NormalOut<i16> for i8

type Output = <i8 as NormalOutPromote<i16>>::Output

fn _pow(self, rhs: i16) -> <i8 as NormalOut<i16>>::Output

fn _clamp(self, min: i16, max: i16) -> <i8 as NormalOut<i16>>::Output

fn _mul_add(self, a: i16, b: i16) -> <i8 as NormalOut<i16>>::Output

fn _add(self, rhs: i16) -> <i8 as NormalOut<i16>>::Output

fn _sub(self, rhs: i16) -> <i8 as NormalOut<i16>>::Output

fn _mul(self, rhs: i16) -> <i8 as NormalOut<i16>>::Output

fn _rem(self, rhs: i16) -> <i8 as NormalOut<i16>>::Output

fn _max(self, rhs: i16) -> <i8 as NormalOut<i16>>::Output

fn _min(self, rhs: i16) -> <i8 as NormalOut<i16>>::Output

impl NormalOut<i16> for i32

type Output = <i32 as NormalOutPromote<i16>>::Output

fn _pow(self, rhs: i16) -> <i32 as NormalOut<i16>>::Output

fn _clamp(self, min: i16, max: i16) -> <i32 as NormalOut<i16>>::Output

fn _mul_add(self, a: i16, b: i16) -> <i32 as NormalOut<i16>>::Output

fn _add(self, rhs: i16) -> <i32 as NormalOut<i16>>::Output

fn _sub(self, rhs: i16) -> <i32 as NormalOut<i16>>::Output

fn _mul(self, rhs: i16) -> <i32 as NormalOut<i16>>::Output

fn _rem(self, rhs: i16) -> <i32 as NormalOut<i16>>::Output

fn _max(self, rhs: i16) -> <i32 as NormalOut<i16>>::Output

fn _min(self, rhs: i16) -> <i32 as NormalOut<i16>>::Output

impl NormalOut<i16> for i64

type Output = <i64 as NormalOutPromote<i16>>::Output

fn _pow(self, rhs: i16) -> <i64 as NormalOut<i16>>::Output

fn _clamp(self, min: i16, max: i16) -> <i64 as NormalOut<i16>>::Output

fn _mul_add(self, a: i16, b: i16) -> <i64 as NormalOut<i16>>::Output

fn _add(self, rhs: i16) -> <i64 as NormalOut<i16>>::Output

fn _sub(self, rhs: i16) -> <i64 as NormalOut<i16>>::Output

fn _mul(self, rhs: i16) -> <i64 as NormalOut<i16>>::Output

fn _rem(self, rhs: i16) -> <i64 as NormalOut<i16>>::Output

fn _max(self, rhs: i16) -> <i64 as NormalOut<i16>>::Output

fn _min(self, rhs: i16) -> <i64 as NormalOut<i16>>::Output

impl NormalOut<i16> for isize

type Output = <isize as NormalOutPromote<i16>>::Output

fn _pow(self, rhs: i16) -> <isize as NormalOut<i16>>::Output

fn _clamp(self, min: i16, max: i16) -> <isize as NormalOut<i16>>::Output

fn _mul_add(self, a: i16, b: i16) -> <isize as NormalOut<i16>>::Output

fn _add(self, rhs: i16) -> <isize as NormalOut<i16>>::Output

fn _sub(self, rhs: i16) -> <isize as NormalOut<i16>>::Output

fn _mul(self, rhs: i16) -> <isize as NormalOut<i16>>::Output

fn _rem(self, rhs: i16) -> <isize as NormalOut<i16>>::Output

fn _max(self, rhs: i16) -> <isize as NormalOut<i16>>::Output

fn _min(self, rhs: i16) -> <isize as NormalOut<i16>>::Output

impl NormalOut<i16> for u8

type Output = <u8 as NormalOutPromote<i16>>::Output

fn _pow(self, rhs: i16) -> <u8 as NormalOut<i16>>::Output

fn _clamp(self, min: i16, max: i16) -> <u8 as NormalOut<i16>>::Output

fn _mul_add(self, a: i16, b: i16) -> <u8 as NormalOut<i16>>::Output

fn _add(self, rhs: i16) -> <u8 as NormalOut<i16>>::Output

fn _sub(self, rhs: i16) -> <u8 as NormalOut<i16>>::Output

fn _mul(self, rhs: i16) -> <u8 as NormalOut<i16>>::Output

fn _rem(self, rhs: i16) -> <u8 as NormalOut<i16>>::Output

fn _max(self, rhs: i16) -> <u8 as NormalOut<i16>>::Output

fn _min(self, rhs: i16) -> <u8 as NormalOut<i16>>::Output

impl NormalOut<i16> for u16

type Output = <u16 as NormalOutPromote<i16>>::Output

fn _pow(self, rhs: i16) -> <u16 as NormalOut<i16>>::Output

fn _clamp(self, min: i16, max: i16) -> <u16 as NormalOut<i16>>::Output

fn _mul_add(self, a: i16, b: i16) -> <u16 as NormalOut<i16>>::Output

fn _add(self, rhs: i16) -> <u16 as NormalOut<i16>>::Output

fn _sub(self, rhs: i16) -> <u16 as NormalOut<i16>>::Output

fn _mul(self, rhs: i16) -> <u16 as NormalOut<i16>>::Output

fn _rem(self, rhs: i16) -> <u16 as NormalOut<i16>>::Output

fn _max(self, rhs: i16) -> <u16 as NormalOut<i16>>::Output

fn _min(self, rhs: i16) -> <u16 as NormalOut<i16>>::Output

impl NormalOut<i16> for u32

type Output = <u32 as NormalOutPromote<i16>>::Output

fn _pow(self, rhs: i16) -> <u32 as NormalOut<i16>>::Output

fn _clamp(self, min: i16, max: i16) -> <u32 as NormalOut<i16>>::Output

fn _mul_add(self, a: i16, b: i16) -> <u32 as NormalOut<i16>>::Output

fn _add(self, rhs: i16) -> <u32 as NormalOut<i16>>::Output

fn _sub(self, rhs: i16) -> <u32 as NormalOut<i16>>::Output

fn _mul(self, rhs: i16) -> <u32 as NormalOut<i16>>::Output

fn _rem(self, rhs: i16) -> <u32 as NormalOut<i16>>::Output

fn _max(self, rhs: i16) -> <u32 as NormalOut<i16>>::Output

fn _min(self, rhs: i16) -> <u32 as NormalOut<i16>>::Output

impl NormalOut<i16> for u64

type Output = <u64 as NormalOutPromote<i16>>::Output

fn _pow(self, rhs: i16) -> <u64 as NormalOut<i16>>::Output

fn _clamp(self, min: i16, max: i16) -> <u64 as NormalOut<i16>>::Output

fn _mul_add(self, a: i16, b: i16) -> <u64 as NormalOut<i16>>::Output

fn _add(self, rhs: i16) -> <u64 as NormalOut<i16>>::Output

fn _sub(self, rhs: i16) -> <u64 as NormalOut<i16>>::Output

fn _mul(self, rhs: i16) -> <u64 as NormalOut<i16>>::Output

fn _rem(self, rhs: i16) -> <u64 as NormalOut<i16>>::Output

fn _max(self, rhs: i16) -> <u64 as NormalOut<i16>>::Output

fn _min(self, rhs: i16) -> <u64 as NormalOut<i16>>::Output

impl NormalOut<i16> for usize

type Output = <usize as NormalOutPromote<i16>>::Output

fn _pow(self, rhs: i16) -> <usize as NormalOut<i16>>::Output

fn _clamp(self, min: i16, max: i16) -> <usize as NormalOut<i16>>::Output

fn _mul_add(self, a: i16, b: i16) -> <usize as NormalOut<i16>>::Output

fn _add(self, rhs: i16) -> <usize as NormalOut<i16>>::Output

fn _sub(self, rhs: i16) -> <usize as NormalOut<i16>>::Output

fn _mul(self, rhs: i16) -> <usize as NormalOut<i16>>::Output

fn _rem(self, rhs: i16) -> <usize as NormalOut<i16>>::Output

fn _max(self, rhs: i16) -> <usize as NormalOut<i16>>::Output

fn _min(self, rhs: i16) -> <usize as NormalOut<i16>>::Output

impl NormalOut<i16> for bf16

type Output = <bf16 as NormalOutPromote<i16>>::Output

fn _pow(self, rhs: i16) -> <bf16 as NormalOut<i16>>::Output

fn _clamp(self, min: i16, max: i16) -> <bf16 as NormalOut<i16>>::Output

fn _mul_add(self, a: i16, b: i16) -> <bf16 as NormalOut<i16>>::Output

fn _add(self, rhs: i16) -> <bf16 as NormalOut<i16>>::Output

fn _sub(self, rhs: i16) -> <bf16 as NormalOut<i16>>::Output

fn _mul(self, rhs: i16) -> <bf16 as NormalOut<i16>>::Output

fn _rem(self, rhs: i16) -> <bf16 as NormalOut<i16>>::Output

fn _max(self, rhs: i16) -> <bf16 as NormalOut<i16>>::Output

fn _min(self, rhs: i16) -> <bf16 as NormalOut<i16>>::Output

impl NormalOut<i16> for f16

type Output = <f16 as NormalOutPromote<i16>>::Output

fn _pow(self, rhs: i16) -> <f16 as NormalOut<i16>>::Output

fn _clamp(self, min: i16, max: i16) -> <f16 as NormalOut<i16>>::Output

fn _mul_add(self, a: i16, b: i16) -> <f16 as NormalOut<i16>>::Output

fn _add(self, rhs: i16) -> <f16 as NormalOut<i16>>::Output

fn _sub(self, rhs: i16) -> <f16 as NormalOut<i16>>::Output

fn _mul(self, rhs: i16) -> <f16 as NormalOut<i16>>::Output

fn _rem(self, rhs: i16) -> <f16 as NormalOut<i16>>::Output

fn _max(self, rhs: i16) -> <f16 as NormalOut<i16>>::Output

fn _min(self, rhs: i16) -> <f16 as NormalOut<i16>>::Output

impl NormalOut<i16> for Complex<f32>

type Output = <Complex<f32> as NormalOutPromote<i16>>::Output

fn _pow(self, rhs: i16) -> <Complex<f32> as NormalOut<i16>>::Output

fn _clamp(self, min: i16, max: i16) -> <Complex<f32> as NormalOut<i16>>::Output

fn _mul_add(self, a: i16, b: i16) -> <Complex<f32> as NormalOut<i16>>::Output

fn _add(self, rhs: i16) -> <Complex<f32> as NormalOut<i16>>::Output

fn _sub(self, rhs: i16) -> <Complex<f32> as NormalOut<i16>>::Output

fn _mul(self, rhs: i16) -> <Complex<f32> as NormalOut<i16>>::Output

fn _rem(self, rhs: i16) -> <Complex<f32> as NormalOut<i16>>::Output

fn _max(self, rhs: i16) -> <Complex<f32> as NormalOut<i16>>::Output

fn _min(self, rhs: i16) -> <Complex<f32> as NormalOut<i16>>::Output

impl NormalOut<i16> for Complex<f64>

type Output = <Complex<f64> as NormalOutPromote<i16>>::Output

fn _pow(self, rhs: i16) -> <Complex<f64> as NormalOut<i16>>::Output

fn _clamp(self, min: i16, max: i16) -> <Complex<f64> as NormalOut<i16>>::Output

fn _mul_add(self, a: i16, b: i16) -> <Complex<f64> as NormalOut<i16>>::Output

fn _add(self, rhs: i16) -> <Complex<f64> as NormalOut<i16>>::Output

fn _sub(self, rhs: i16) -> <Complex<f64> as NormalOut<i16>>::Output

fn _mul(self, rhs: i16) -> <Complex<f64> as NormalOut<i16>>::Output

fn _rem(self, rhs: i16) -> <Complex<f64> as NormalOut<i16>>::Output

fn _max(self, rhs: i16) -> <Complex<f64> as NormalOut<i16>>::Output

fn _min(self, rhs: i16) -> <Complex<f64> as NormalOut<i16>>::Output

impl NormalOut<i32> for bool

type Output = <bool as NormalOutPromote<i32>>::Output

fn _pow(self, rhs: i32) -> <bool as NormalOut<i32>>::Output

fn _clamp(self, min: i32, max: i32) -> <bool as NormalOut<i32>>::Output

fn _mul_add(self, a: i32, b: i32) -> <bool as NormalOut<i32>>::Output

fn _add(self, rhs: i32) -> <bool as NormalOut<i32>>::Output

fn _sub(self, rhs: i32) -> <bool as NormalOut<i32>>::Output

fn _mul(self, rhs: i32) -> <bool as NormalOut<i32>>::Output

fn _rem(self, rhs: i32) -> <bool as NormalOut<i32>>::Output

fn _max(self, rhs: i32) -> <bool as NormalOut<i32>>::Output

fn _min(self, rhs: i32) -> <bool as NormalOut<i32>>::Output

impl NormalOut<i32> for f32

type Output = <f32 as NormalOutPromote<i32>>::Output

fn _pow(self, rhs: i32) -> <f32 as NormalOut<i32>>::Output

fn _clamp(self, min: i32, max: i32) -> <f32 as NormalOut<i32>>::Output

fn _mul_add(self, a: i32, b: i32) -> <f32 as NormalOut<i32>>::Output

fn _add(self, rhs: i32) -> <f32 as NormalOut<i32>>::Output

fn _sub(self, rhs: i32) -> <f32 as NormalOut<i32>>::Output

fn _mul(self, rhs: i32) -> <f32 as NormalOut<i32>>::Output

fn _rem(self, rhs: i32) -> <f32 as NormalOut<i32>>::Output

fn _max(self, rhs: i32) -> <f32 as NormalOut<i32>>::Output

fn _min(self, rhs: i32) -> <f32 as NormalOut<i32>>::Output

impl NormalOut<i32> for f64

type Output = <f64 as NormalOutPromote<i32>>::Output

fn _pow(self, rhs: i32) -> <f64 as NormalOut<i32>>::Output

fn _clamp(self, min: i32, max: i32) -> <f64 as NormalOut<i32>>::Output

fn _mul_add(self, a: i32, b: i32) -> <f64 as NormalOut<i32>>::Output

fn _add(self, rhs: i32) -> <f64 as NormalOut<i32>>::Output

fn _sub(self, rhs: i32) -> <f64 as NormalOut<i32>>::Output

fn _mul(self, rhs: i32) -> <f64 as NormalOut<i32>>::Output

fn _rem(self, rhs: i32) -> <f64 as NormalOut<i32>>::Output

fn _max(self, rhs: i32) -> <f64 as NormalOut<i32>>::Output

fn _min(self, rhs: i32) -> <f64 as NormalOut<i32>>::Output

impl NormalOut<i32> for i8

type Output = <i8 as NormalOutPromote<i32>>::Output

fn _pow(self, rhs: i32) -> <i8 as NormalOut<i32>>::Output

fn _clamp(self, min: i32, max: i32) -> <i8 as NormalOut<i32>>::Output

fn _mul_add(self, a: i32, b: i32) -> <i8 as NormalOut<i32>>::Output

fn _add(self, rhs: i32) -> <i8 as NormalOut<i32>>::Output

fn _sub(self, rhs: i32) -> <i8 as NormalOut<i32>>::Output

fn _mul(self, rhs: i32) -> <i8 as NormalOut<i32>>::Output

fn _rem(self, rhs: i32) -> <i8 as NormalOut<i32>>::Output

fn _max(self, rhs: i32) -> <i8 as NormalOut<i32>>::Output

fn _min(self, rhs: i32) -> <i8 as NormalOut<i32>>::Output

impl NormalOut<i32> for i16

type Output = <i16 as NormalOutPromote<i32>>::Output

fn _pow(self, rhs: i32) -> <i16 as NormalOut<i32>>::Output

fn _clamp(self, min: i32, max: i32) -> <i16 as NormalOut<i32>>::Output

fn _mul_add(self, a: i32, b: i32) -> <i16 as NormalOut<i32>>::Output

fn _add(self, rhs: i32) -> <i16 as NormalOut<i32>>::Output

fn _sub(self, rhs: i32) -> <i16 as NormalOut<i32>>::Output

fn _mul(self, rhs: i32) -> <i16 as NormalOut<i32>>::Output

fn _rem(self, rhs: i32) -> <i16 as NormalOut<i32>>::Output

fn _max(self, rhs: i32) -> <i16 as NormalOut<i32>>::Output

fn _min(self, rhs: i32) -> <i16 as NormalOut<i32>>::Output

impl NormalOut<i32> for i64

type Output = <i64 as NormalOutPromote<i32>>::Output

fn _pow(self, rhs: i32) -> <i64 as NormalOut<i32>>::Output

fn _clamp(self, min: i32, max: i32) -> <i64 as NormalOut<i32>>::Output

fn _mul_add(self, a: i32, b: i32) -> <i64 as NormalOut<i32>>::Output

fn _add(self, rhs: i32) -> <i64 as NormalOut<i32>>::Output

fn _sub(self, rhs: i32) -> <i64 as NormalOut<i32>>::Output

fn _mul(self, rhs: i32) -> <i64 as NormalOut<i32>>::Output

fn _rem(self, rhs: i32) -> <i64 as NormalOut<i32>>::Output

fn _max(self, rhs: i32) -> <i64 as NormalOut<i32>>::Output

fn _min(self, rhs: i32) -> <i64 as NormalOut<i32>>::Output

impl NormalOut<i32> for isize

type Output = <isize as NormalOutPromote<i32>>::Output

fn _pow(self, rhs: i32) -> <isize as NormalOut<i32>>::Output

fn _clamp(self, min: i32, max: i32) -> <isize as NormalOut<i32>>::Output

fn _mul_add(self, a: i32, b: i32) -> <isize as NormalOut<i32>>::Output

fn _add(self, rhs: i32) -> <isize as NormalOut<i32>>::Output

fn _sub(self, rhs: i32) -> <isize as NormalOut<i32>>::Output

fn _mul(self, rhs: i32) -> <isize as NormalOut<i32>>::Output

fn _rem(self, rhs: i32) -> <isize as NormalOut<i32>>::Output

fn _max(self, rhs: i32) -> <isize as NormalOut<i32>>::Output

fn _min(self, rhs: i32) -> <isize as NormalOut<i32>>::Output

impl NormalOut<i32> for u8

type Output = <u8 as NormalOutPromote<i32>>::Output

fn _pow(self, rhs: i32) -> <u8 as NormalOut<i32>>::Output

fn _clamp(self, min: i32, max: i32) -> <u8 as NormalOut<i32>>::Output

fn _mul_add(self, a: i32, b: i32) -> <u8 as NormalOut<i32>>::Output

fn _add(self, rhs: i32) -> <u8 as NormalOut<i32>>::Output

fn _sub(self, rhs: i32) -> <u8 as NormalOut<i32>>::Output

fn _mul(self, rhs: i32) -> <u8 as NormalOut<i32>>::Output

fn _rem(self, rhs: i32) -> <u8 as NormalOut<i32>>::Output

fn _max(self, rhs: i32) -> <u8 as NormalOut<i32>>::Output

fn _min(self, rhs: i32) -> <u8 as NormalOut<i32>>::Output

impl NormalOut<i32> for u16

type Output = <u16 as NormalOutPromote<i32>>::Output

fn _pow(self, rhs: i32) -> <u16 as NormalOut<i32>>::Output

fn _clamp(self, min: i32, max: i32) -> <u16 as NormalOut<i32>>::Output

fn _mul_add(self, a: i32, b: i32) -> <u16 as NormalOut<i32>>::Output

fn _add(self, rhs: i32) -> <u16 as NormalOut<i32>>::Output

fn _sub(self, rhs: i32) -> <u16 as NormalOut<i32>>::Output

fn _mul(self, rhs: i32) -> <u16 as NormalOut<i32>>::Output

fn _rem(self, rhs: i32) -> <u16 as NormalOut<i32>>::Output

fn _max(self, rhs: i32) -> <u16 as NormalOut<i32>>::Output

fn _min(self, rhs: i32) -> <u16 as NormalOut<i32>>::Output

impl NormalOut<i32> for u32

type Output = <u32 as NormalOutPromote<i32>>::Output

fn _pow(self, rhs: i32) -> <u32 as NormalOut<i32>>::Output

fn _clamp(self, min: i32, max: i32) -> <u32 as NormalOut<i32>>::Output

fn _mul_add(self, a: i32, b: i32) -> <u32 as NormalOut<i32>>::Output

fn _add(self, rhs: i32) -> <u32 as NormalOut<i32>>::Output

fn _sub(self, rhs: i32) -> <u32 as NormalOut<i32>>::Output

fn _mul(self, rhs: i32) -> <u32 as NormalOut<i32>>::Output

fn _rem(self, rhs: i32) -> <u32 as NormalOut<i32>>::Output

fn _max(self, rhs: i32) -> <u32 as NormalOut<i32>>::Output

fn _min(self, rhs: i32) -> <u32 as NormalOut<i32>>::Output

impl NormalOut<i32> for u64

type Output = <u64 as NormalOutPromote<i32>>::Output

fn _pow(self, rhs: i32) -> <u64 as NormalOut<i32>>::Output

fn _clamp(self, min: i32, max: i32) -> <u64 as NormalOut<i32>>::Output

fn _mul_add(self, a: i32, b: i32) -> <u64 as NormalOut<i32>>::Output

fn _add(self, rhs: i32) -> <u64 as NormalOut<i32>>::Output

fn _sub(self, rhs: i32) -> <u64 as NormalOut<i32>>::Output

fn _mul(self, rhs: i32) -> <u64 as NormalOut<i32>>::Output

fn _rem(self, rhs: i32) -> <u64 as NormalOut<i32>>::Output

fn _max(self, rhs: i32) -> <u64 as NormalOut<i32>>::Output

fn _min(self, rhs: i32) -> <u64 as NormalOut<i32>>::Output

impl NormalOut<i32> for usize

type Output = <usize as NormalOutPromote<i32>>::Output

fn _pow(self, rhs: i32) -> <usize as NormalOut<i32>>::Output

fn _clamp(self, min: i32, max: i32) -> <usize as NormalOut<i32>>::Output

fn _mul_add(self, a: i32, b: i32) -> <usize as NormalOut<i32>>::Output

fn _add(self, rhs: i32) -> <usize as NormalOut<i32>>::Output

fn _sub(self, rhs: i32) -> <usize as NormalOut<i32>>::Output

fn _mul(self, rhs: i32) -> <usize as NormalOut<i32>>::Output

fn _rem(self, rhs: i32) -> <usize as NormalOut<i32>>::Output

fn _max(self, rhs: i32) -> <usize as NormalOut<i32>>::Output

fn _min(self, rhs: i32) -> <usize as NormalOut<i32>>::Output

impl NormalOut<i32> for bf16

type Output = <bf16 as NormalOutPromote<i32>>::Output

fn _pow(self, rhs: i32) -> <bf16 as NormalOut<i32>>::Output

fn _clamp(self, min: i32, max: i32) -> <bf16 as NormalOut<i32>>::Output

fn _mul_add(self, a: i32, b: i32) -> <bf16 as NormalOut<i32>>::Output

fn _add(self, rhs: i32) -> <bf16 as NormalOut<i32>>::Output

fn _sub(self, rhs: i32) -> <bf16 as NormalOut<i32>>::Output

fn _mul(self, rhs: i32) -> <bf16 as NormalOut<i32>>::Output

fn _rem(self, rhs: i32) -> <bf16 as NormalOut<i32>>::Output

fn _max(self, rhs: i32) -> <bf16 as NormalOut<i32>>::Output

fn _min(self, rhs: i32) -> <bf16 as NormalOut<i32>>::Output

impl NormalOut<i32> for f16

type Output = <f16 as NormalOutPromote<i32>>::Output

fn _pow(self, rhs: i32) -> <f16 as NormalOut<i32>>::Output

fn _clamp(self, min: i32, max: i32) -> <f16 as NormalOut<i32>>::Output

fn _mul_add(self, a: i32, b: i32) -> <f16 as NormalOut<i32>>::Output

fn _add(self, rhs: i32) -> <f16 as NormalOut<i32>>::Output

fn _sub(self, rhs: i32) -> <f16 as NormalOut<i32>>::Output

fn _mul(self, rhs: i32) -> <f16 as NormalOut<i32>>::Output

fn _rem(self, rhs: i32) -> <f16 as NormalOut<i32>>::Output

fn _max(self, rhs: i32) -> <f16 as NormalOut<i32>>::Output

fn _min(self, rhs: i32) -> <f16 as NormalOut<i32>>::Output

impl NormalOut<i32> for Complex<f32>

type Output = <Complex<f32> as NormalOutPromote<i32>>::Output

fn _pow(self, rhs: i32) -> <Complex<f32> as NormalOut<i32>>::Output

fn _clamp(self, min: i32, max: i32) -> <Complex<f32> as NormalOut<i32>>::Output

fn _mul_add(self, a: i32, b: i32) -> <Complex<f32> as NormalOut<i32>>::Output

fn _add(self, rhs: i32) -> <Complex<f32> as NormalOut<i32>>::Output

fn _sub(self, rhs: i32) -> <Complex<f32> as NormalOut<i32>>::Output

fn _mul(self, rhs: i32) -> <Complex<f32> as NormalOut<i32>>::Output

fn _rem(self, rhs: i32) -> <Complex<f32> as NormalOut<i32>>::Output

fn _max(self, rhs: i32) -> <Complex<f32> as NormalOut<i32>>::Output

fn _min(self, rhs: i32) -> <Complex<f32> as NormalOut<i32>>::Output

impl NormalOut<i32> for Complex<f64>

type Output = <Complex<f64> as NormalOutPromote<i32>>::Output

fn _pow(self, rhs: i32) -> <Complex<f64> as NormalOut<i32>>::Output

fn _clamp(self, min: i32, max: i32) -> <Complex<f64> as NormalOut<i32>>::Output

fn _mul_add(self, a: i32, b: i32) -> <Complex<f64> as NormalOut<i32>>::Output

fn _add(self, rhs: i32) -> <Complex<f64> as NormalOut<i32>>::Output

fn _sub(self, rhs: i32) -> <Complex<f64> as NormalOut<i32>>::Output

fn _mul(self, rhs: i32) -> <Complex<f64> as NormalOut<i32>>::Output

fn _rem(self, rhs: i32) -> <Complex<f64> as NormalOut<i32>>::Output

fn _max(self, rhs: i32) -> <Complex<f64> as NormalOut<i32>>::Output

fn _min(self, rhs: i32) -> <Complex<f64> as NormalOut<i32>>::Output

impl NormalOut<i64> for bool

type Output = <bool as NormalOutPromote<i64>>::Output

fn _pow(self, rhs: i64) -> <bool as NormalOut<i64>>::Output

fn _clamp(self, min: i64, max: i64) -> <bool as NormalOut<i64>>::Output

fn _mul_add(self, a: i64, b: i64) -> <bool as NormalOut<i64>>::Output

fn _add(self, rhs: i64) -> <bool as NormalOut<i64>>::Output

fn _sub(self, rhs: i64) -> <bool as NormalOut<i64>>::Output

fn _mul(self, rhs: i64) -> <bool as NormalOut<i64>>::Output

fn _rem(self, rhs: i64) -> <bool as NormalOut<i64>>::Output

fn _max(self, rhs: i64) -> <bool as NormalOut<i64>>::Output

fn _min(self, rhs: i64) -> <bool as NormalOut<i64>>::Output

impl NormalOut<i64> for f32

type Output = <f32 as NormalOutPromote<i64>>::Output

fn _pow(self, rhs: i64) -> <f32 as NormalOut<i64>>::Output

fn _clamp(self, min: i64, max: i64) -> <f32 as NormalOut<i64>>::Output

fn _mul_add(self, a: i64, b: i64) -> <f32 as NormalOut<i64>>::Output

fn _add(self, rhs: i64) -> <f32 as NormalOut<i64>>::Output

fn _sub(self, rhs: i64) -> <f32 as NormalOut<i64>>::Output

fn _mul(self, rhs: i64) -> <f32 as NormalOut<i64>>::Output

fn _rem(self, rhs: i64) -> <f32 as NormalOut<i64>>::Output

fn _max(self, rhs: i64) -> <f32 as NormalOut<i64>>::Output

fn _min(self, rhs: i64) -> <f32 as NormalOut<i64>>::Output

impl NormalOut<i64> for f64

type Output = <f64 as NormalOutPromote<i64>>::Output

fn _pow(self, rhs: i64) -> <f64 as NormalOut<i64>>::Output

fn _clamp(self, min: i64, max: i64) -> <f64 as NormalOut<i64>>::Output

fn _mul_add(self, a: i64, b: i64) -> <f64 as NormalOut<i64>>::Output

fn _add(self, rhs: i64) -> <f64 as NormalOut<i64>>::Output

fn _sub(self, rhs: i64) -> <f64 as NormalOut<i64>>::Output

fn _mul(self, rhs: i64) -> <f64 as NormalOut<i64>>::Output

fn _rem(self, rhs: i64) -> <f64 as NormalOut<i64>>::Output

fn _max(self, rhs: i64) -> <f64 as NormalOut<i64>>::Output

fn _min(self, rhs: i64) -> <f64 as NormalOut<i64>>::Output

impl NormalOut<i64> for i8

type Output = <i8 as NormalOutPromote<i64>>::Output

fn _pow(self, rhs: i64) -> <i8 as NormalOut<i64>>::Output

fn _clamp(self, min: i64, max: i64) -> <i8 as NormalOut<i64>>::Output

fn _mul_add(self, a: i64, b: i64) -> <i8 as NormalOut<i64>>::Output

fn _add(self, rhs: i64) -> <i8 as NormalOut<i64>>::Output

fn _sub(self, rhs: i64) -> <i8 as NormalOut<i64>>::Output

fn _mul(self, rhs: i64) -> <i8 as NormalOut<i64>>::Output

fn _rem(self, rhs: i64) -> <i8 as NormalOut<i64>>::Output

fn _max(self, rhs: i64) -> <i8 as NormalOut<i64>>::Output

fn _min(self, rhs: i64) -> <i8 as NormalOut<i64>>::Output

impl NormalOut<i64> for i16

type Output = <i16 as NormalOutPromote<i64>>::Output

fn _pow(self, rhs: i64) -> <i16 as NormalOut<i64>>::Output

fn _clamp(self, min: i64, max: i64) -> <i16 as NormalOut<i64>>::Output

fn _mul_add(self, a: i64, b: i64) -> <i16 as NormalOut<i64>>::Output

fn _add(self, rhs: i64) -> <i16 as NormalOut<i64>>::Output

fn _sub(self, rhs: i64) -> <i16 as NormalOut<i64>>::Output

fn _mul(self, rhs: i64) -> <i16 as NormalOut<i64>>::Output

fn _rem(self, rhs: i64) -> <i16 as NormalOut<i64>>::Output

fn _max(self, rhs: i64) -> <i16 as NormalOut<i64>>::Output

fn _min(self, rhs: i64) -> <i16 as NormalOut<i64>>::Output

impl NormalOut<i64> for i32

type Output = <i32 as NormalOutPromote<i64>>::Output

fn _pow(self, rhs: i64) -> <i32 as NormalOut<i64>>::Output

fn _clamp(self, min: i64, max: i64) -> <i32 as NormalOut<i64>>::Output

fn _mul_add(self, a: i64, b: i64) -> <i32 as NormalOut<i64>>::Output

fn _add(self, rhs: i64) -> <i32 as NormalOut<i64>>::Output

fn _sub(self, rhs: i64) -> <i32 as NormalOut<i64>>::Output

fn _mul(self, rhs: i64) -> <i32 as NormalOut<i64>>::Output

fn _rem(self, rhs: i64) -> <i32 as NormalOut<i64>>::Output

fn _max(self, rhs: i64) -> <i32 as NormalOut<i64>>::Output

fn _min(self, rhs: i64) -> <i32 as NormalOut<i64>>::Output

impl NormalOut<i64> for isize

type Output = <isize as NormalOutPromote<i64>>::Output

fn _pow(self, rhs: i64) -> <isize as NormalOut<i64>>::Output

fn _clamp(self, min: i64, max: i64) -> <isize as NormalOut<i64>>::Output

fn _mul_add(self, a: i64, b: i64) -> <isize as NormalOut<i64>>::Output

fn _add(self, rhs: i64) -> <isize as NormalOut<i64>>::Output

fn _sub(self, rhs: i64) -> <isize as NormalOut<i64>>::Output

fn _mul(self, rhs: i64) -> <isize as NormalOut<i64>>::Output

fn _rem(self, rhs: i64) -> <isize as NormalOut<i64>>::Output

fn _max(self, rhs: i64) -> <isize as NormalOut<i64>>::Output

fn _min(self, rhs: i64) -> <isize as NormalOut<i64>>::Output

impl NormalOut<i64> for u8

type Output = <u8 as NormalOutPromote<i64>>::Output

fn _pow(self, rhs: i64) -> <u8 as NormalOut<i64>>::Output

fn _clamp(self, min: i64, max: i64) -> <u8 as NormalOut<i64>>::Output

fn _mul_add(self, a: i64, b: i64) -> <u8 as NormalOut<i64>>::Output

fn _add(self, rhs: i64) -> <u8 as NormalOut<i64>>::Output

fn _sub(self, rhs: i64) -> <u8 as NormalOut<i64>>::Output

fn _mul(self, rhs: i64) -> <u8 as NormalOut<i64>>::Output

fn _rem(self, rhs: i64) -> <u8 as NormalOut<i64>>::Output

fn _max(self, rhs: i64) -> <u8 as NormalOut<i64>>::Output

fn _min(self, rhs: i64) -> <u8 as NormalOut<i64>>::Output

impl NormalOut<i64> for u16

type Output = <u16 as NormalOutPromote<i64>>::Output

fn _pow(self, rhs: i64) -> <u16 as NormalOut<i64>>::Output

fn _clamp(self, min: i64, max: i64) -> <u16 as NormalOut<i64>>::Output

fn _mul_add(self, a: i64, b: i64) -> <u16 as NormalOut<i64>>::Output

fn _add(self, rhs: i64) -> <u16 as NormalOut<i64>>::Output

fn _sub(self, rhs: i64) -> <u16 as NormalOut<i64>>::Output

fn _mul(self, rhs: i64) -> <u16 as NormalOut<i64>>::Output

fn _rem(self, rhs: i64) -> <u16 as NormalOut<i64>>::Output

fn _max(self, rhs: i64) -> <u16 as NormalOut<i64>>::Output

fn _min(self, rhs: i64) -> <u16 as NormalOut<i64>>::Output

impl NormalOut<i64> for u32

type Output = <u32 as NormalOutPromote<i64>>::Output

fn _pow(self, rhs: i64) -> <u32 as NormalOut<i64>>::Output

fn _clamp(self, min: i64, max: i64) -> <u32 as NormalOut<i64>>::Output

fn _mul_add(self, a: i64, b: i64) -> <u32 as NormalOut<i64>>::Output

fn _add(self, rhs: i64) -> <u32 as NormalOut<i64>>::Output

fn _sub(self, rhs: i64) -> <u32 as NormalOut<i64>>::Output

fn _mul(self, rhs: i64) -> <u32 as NormalOut<i64>>::Output

fn _rem(self, rhs: i64) -> <u32 as NormalOut<i64>>::Output

fn _max(self, rhs: i64) -> <u32 as NormalOut<i64>>::Output

fn _min(self, rhs: i64) -> <u32 as NormalOut<i64>>::Output

impl NormalOut<i64> for u64

type Output = <u64 as NormalOutPromote<i64>>::Output

fn _pow(self, rhs: i64) -> <u64 as NormalOut<i64>>::Output

fn _clamp(self, min: i64, max: i64) -> <u64 as NormalOut<i64>>::Output

fn _mul_add(self, a: i64, b: i64) -> <u64 as NormalOut<i64>>::Output

fn _add(self, rhs: i64) -> <u64 as NormalOut<i64>>::Output

fn _sub(self, rhs: i64) -> <u64 as NormalOut<i64>>::Output

fn _mul(self, rhs: i64) -> <u64 as NormalOut<i64>>::Output

fn _rem(self, rhs: i64) -> <u64 as NormalOut<i64>>::Output

fn _max(self, rhs: i64) -> <u64 as NormalOut<i64>>::Output

fn _min(self, rhs: i64) -> <u64 as NormalOut<i64>>::Output

impl NormalOut<i64> for usize

type Output = <usize as NormalOutPromote<i64>>::Output

fn _pow(self, rhs: i64) -> <usize as NormalOut<i64>>::Output

fn _clamp(self, min: i64, max: i64) -> <usize as NormalOut<i64>>::Output

fn _mul_add(self, a: i64, b: i64) -> <usize as NormalOut<i64>>::Output

fn _add(self, rhs: i64) -> <usize as NormalOut<i64>>::Output

fn _sub(self, rhs: i64) -> <usize as NormalOut<i64>>::Output

fn _mul(self, rhs: i64) -> <usize as NormalOut<i64>>::Output

fn _rem(self, rhs: i64) -> <usize as NormalOut<i64>>::Output

fn _max(self, rhs: i64) -> <usize as NormalOut<i64>>::Output

fn _min(self, rhs: i64) -> <usize as NormalOut<i64>>::Output

impl NormalOut<i64> for bf16

type Output = <bf16 as NormalOutPromote<i64>>::Output

fn _pow(self, rhs: i64) -> <bf16 as NormalOut<i64>>::Output

fn _clamp(self, min: i64, max: i64) -> <bf16 as NormalOut<i64>>::Output

fn _mul_add(self, a: i64, b: i64) -> <bf16 as NormalOut<i64>>::Output

fn _add(self, rhs: i64) -> <bf16 as NormalOut<i64>>::Output

fn _sub(self, rhs: i64) -> <bf16 as NormalOut<i64>>::Output

fn _mul(self, rhs: i64) -> <bf16 as NormalOut<i64>>::Output

fn _rem(self, rhs: i64) -> <bf16 as NormalOut<i64>>::Output

fn _max(self, rhs: i64) -> <bf16 as NormalOut<i64>>::Output

fn _min(self, rhs: i64) -> <bf16 as NormalOut<i64>>::Output

impl NormalOut<i64> for f16

type Output = <f16 as NormalOutPromote<i64>>::Output

fn _pow(self, rhs: i64) -> <f16 as NormalOut<i64>>::Output

fn _clamp(self, min: i64, max: i64) -> <f16 as NormalOut<i64>>::Output

fn _mul_add(self, a: i64, b: i64) -> <f16 as NormalOut<i64>>::Output

fn _add(self, rhs: i64) -> <f16 as NormalOut<i64>>::Output

fn _sub(self, rhs: i64) -> <f16 as NormalOut<i64>>::Output

fn _mul(self, rhs: i64) -> <f16 as NormalOut<i64>>::Output

fn _rem(self, rhs: i64) -> <f16 as NormalOut<i64>>::Output

fn _max(self, rhs: i64) -> <f16 as NormalOut<i64>>::Output

fn _min(self, rhs: i64) -> <f16 as NormalOut<i64>>::Output

impl NormalOut<i64> for Complex<f32>

type Output = <Complex<f32> as NormalOutPromote<i64>>::Output

fn _pow(self, rhs: i64) -> <Complex<f32> as NormalOut<i64>>::Output

fn _clamp(self, min: i64, max: i64) -> <Complex<f32> as NormalOut<i64>>::Output

fn _mul_add(self, a: i64, b: i64) -> <Complex<f32> as NormalOut<i64>>::Output

fn _add(self, rhs: i64) -> <Complex<f32> as NormalOut<i64>>::Output

fn _sub(self, rhs: i64) -> <Complex<f32> as NormalOut<i64>>::Output

fn _mul(self, rhs: i64) -> <Complex<f32> as NormalOut<i64>>::Output

fn _rem(self, rhs: i64) -> <Complex<f32> as NormalOut<i64>>::Output

fn _max(self, rhs: i64) -> <Complex<f32> as NormalOut<i64>>::Output

fn _min(self, rhs: i64) -> <Complex<f32> as NormalOut<i64>>::Output

impl NormalOut<i64> for Complex<f64>

type Output = <Complex<f64> as NormalOutPromote<i64>>::Output

fn _pow(self, rhs: i64) -> <Complex<f64> as NormalOut<i64>>::Output

fn _clamp(self, min: i64, max: i64) -> <Complex<f64> as NormalOut<i64>>::Output

fn _mul_add(self, a: i64, b: i64) -> <Complex<f64> as NormalOut<i64>>::Output

fn _add(self, rhs: i64) -> <Complex<f64> as NormalOut<i64>>::Output

fn _sub(self, rhs: i64) -> <Complex<f64> as NormalOut<i64>>::Output

fn _mul(self, rhs: i64) -> <Complex<f64> as NormalOut<i64>>::Output

fn _rem(self, rhs: i64) -> <Complex<f64> as NormalOut<i64>>::Output

fn _max(self, rhs: i64) -> <Complex<f64> as NormalOut<i64>>::Output

fn _min(self, rhs: i64) -> <Complex<f64> as NormalOut<i64>>::Output

impl NormalOut<isize> for bool

type Output = <bool as NormalOutPromote<isize>>::Output

fn _pow(self, rhs: isize) -> <bool as NormalOut<isize>>::Output

fn _clamp(self, min: isize, max: isize) -> <bool as NormalOut<isize>>::Output

fn _mul_add(self, a: isize, b: isize) -> <bool as NormalOut<isize>>::Output

fn _add(self, rhs: isize) -> <bool as NormalOut<isize>>::Output

fn _sub(self, rhs: isize) -> <bool as NormalOut<isize>>::Output

fn _mul(self, rhs: isize) -> <bool as NormalOut<isize>>::Output

fn _rem(self, rhs: isize) -> <bool as NormalOut<isize>>::Output

fn _max(self, rhs: isize) -> <bool as NormalOut<isize>>::Output

fn _min(self, rhs: isize) -> <bool as NormalOut<isize>>::Output

impl NormalOut<isize> for f32

type Output = <f32 as NormalOutPromote<isize>>::Output

fn _pow(self, rhs: isize) -> <f32 as NormalOut<isize>>::Output

fn _clamp(self, min: isize, max: isize) -> <f32 as NormalOut<isize>>::Output

fn _mul_add(self, a: isize, b: isize) -> <f32 as NormalOut<isize>>::Output

fn _add(self, rhs: isize) -> <f32 as NormalOut<isize>>::Output

fn _sub(self, rhs: isize) -> <f32 as NormalOut<isize>>::Output

fn _mul(self, rhs: isize) -> <f32 as NormalOut<isize>>::Output

fn _rem(self, rhs: isize) -> <f32 as NormalOut<isize>>::Output

fn _max(self, rhs: isize) -> <f32 as NormalOut<isize>>::Output

fn _min(self, rhs: isize) -> <f32 as NormalOut<isize>>::Output

impl NormalOut<isize> for f64

type Output = <f64 as NormalOutPromote<isize>>::Output

fn _pow(self, rhs: isize) -> <f64 as NormalOut<isize>>::Output

fn _clamp(self, min: isize, max: isize) -> <f64 as NormalOut<isize>>::Output

fn _mul_add(self, a: isize, b: isize) -> <f64 as NormalOut<isize>>::Output

fn _add(self, rhs: isize) -> <f64 as NormalOut<isize>>::Output

fn _sub(self, rhs: isize) -> <f64 as NormalOut<isize>>::Output

fn _mul(self, rhs: isize) -> <f64 as NormalOut<isize>>::Output

fn _rem(self, rhs: isize) -> <f64 as NormalOut<isize>>::Output

fn _max(self, rhs: isize) -> <f64 as NormalOut<isize>>::Output

fn _min(self, rhs: isize) -> <f64 as NormalOut<isize>>::Output

impl NormalOut<isize> for i8

type Output = <i8 as NormalOutPromote<isize>>::Output

fn _pow(self, rhs: isize) -> <i8 as NormalOut<isize>>::Output

fn _clamp(self, min: isize, max: isize) -> <i8 as NormalOut<isize>>::Output

fn _mul_add(self, a: isize, b: isize) -> <i8 as NormalOut<isize>>::Output

fn _add(self, rhs: isize) -> <i8 as NormalOut<isize>>::Output

fn _sub(self, rhs: isize) -> <i8 as NormalOut<isize>>::Output

fn _mul(self, rhs: isize) -> <i8 as NormalOut<isize>>::Output

fn _rem(self, rhs: isize) -> <i8 as NormalOut<isize>>::Output

fn _max(self, rhs: isize) -> <i8 as NormalOut<isize>>::Output

fn _min(self, rhs: isize) -> <i8 as NormalOut<isize>>::Output

impl NormalOut<isize> for i16

type Output = <i16 as NormalOutPromote<isize>>::Output

fn _pow(self, rhs: isize) -> <i16 as NormalOut<isize>>::Output

fn _clamp(self, min: isize, max: isize) -> <i16 as NormalOut<isize>>::Output

fn _mul_add(self, a: isize, b: isize) -> <i16 as NormalOut<isize>>::Output

fn _add(self, rhs: isize) -> <i16 as NormalOut<isize>>::Output

fn _sub(self, rhs: isize) -> <i16 as NormalOut<isize>>::Output

fn _mul(self, rhs: isize) -> <i16 as NormalOut<isize>>::Output

fn _rem(self, rhs: isize) -> <i16 as NormalOut<isize>>::Output

fn _max(self, rhs: isize) -> <i16 as NormalOut<isize>>::Output

fn _min(self, rhs: isize) -> <i16 as NormalOut<isize>>::Output

impl NormalOut<isize> for i32

type Output = <i32 as NormalOutPromote<isize>>::Output

fn _pow(self, rhs: isize) -> <i32 as NormalOut<isize>>::Output

fn _clamp(self, min: isize, max: isize) -> <i32 as NormalOut<isize>>::Output

fn _mul_add(self, a: isize, b: isize) -> <i32 as NormalOut<isize>>::Output

fn _add(self, rhs: isize) -> <i32 as NormalOut<isize>>::Output

fn _sub(self, rhs: isize) -> <i32 as NormalOut<isize>>::Output

fn _mul(self, rhs: isize) -> <i32 as NormalOut<isize>>::Output

fn _rem(self, rhs: isize) -> <i32 as NormalOut<isize>>::Output

fn _max(self, rhs: isize) -> <i32 as NormalOut<isize>>::Output

fn _min(self, rhs: isize) -> <i32 as NormalOut<isize>>::Output

impl NormalOut<isize> for i64

type Output = <i64 as NormalOutPromote<isize>>::Output

fn _pow(self, rhs: isize) -> <i64 as NormalOut<isize>>::Output

fn _clamp(self, min: isize, max: isize) -> <i64 as NormalOut<isize>>::Output

fn _mul_add(self, a: isize, b: isize) -> <i64 as NormalOut<isize>>::Output

fn _add(self, rhs: isize) -> <i64 as NormalOut<isize>>::Output

fn _sub(self, rhs: isize) -> <i64 as NormalOut<isize>>::Output

fn _mul(self, rhs: isize) -> <i64 as NormalOut<isize>>::Output

fn _rem(self, rhs: isize) -> <i64 as NormalOut<isize>>::Output

fn _max(self, rhs: isize) -> <i64 as NormalOut<isize>>::Output

fn _min(self, rhs: isize) -> <i64 as NormalOut<isize>>::Output

impl NormalOut<isize> for u8

type Output = <u8 as NormalOutPromote<isize>>::Output

fn _pow(self, rhs: isize) -> <u8 as NormalOut<isize>>::Output

fn _clamp(self, min: isize, max: isize) -> <u8 as NormalOut<isize>>::Output

fn _mul_add(self, a: isize, b: isize) -> <u8 as NormalOut<isize>>::Output

fn _add(self, rhs: isize) -> <u8 as NormalOut<isize>>::Output

fn _sub(self, rhs: isize) -> <u8 as NormalOut<isize>>::Output

fn _mul(self, rhs: isize) -> <u8 as NormalOut<isize>>::Output

fn _rem(self, rhs: isize) -> <u8 as NormalOut<isize>>::Output

fn _max(self, rhs: isize) -> <u8 as NormalOut<isize>>::Output

fn _min(self, rhs: isize) -> <u8 as NormalOut<isize>>::Output

impl NormalOut<isize> for u16

type Output = <u16 as NormalOutPromote<isize>>::Output

fn _pow(self, rhs: isize) -> <u16 as NormalOut<isize>>::Output

fn _clamp(self, min: isize, max: isize) -> <u16 as NormalOut<isize>>::Output

fn _mul_add(self, a: isize, b: isize) -> <u16 as NormalOut<isize>>::Output

fn _add(self, rhs: isize) -> <u16 as NormalOut<isize>>::Output

fn _sub(self, rhs: isize) -> <u16 as NormalOut<isize>>::Output

fn _mul(self, rhs: isize) -> <u16 as NormalOut<isize>>::Output

fn _rem(self, rhs: isize) -> <u16 as NormalOut<isize>>::Output

fn _max(self, rhs: isize) -> <u16 as NormalOut<isize>>::Output

fn _min(self, rhs: isize) -> <u16 as NormalOut<isize>>::Output

impl NormalOut<isize> for u32

type Output = <u32 as NormalOutPromote<isize>>::Output

fn _pow(self, rhs: isize) -> <u32 as NormalOut<isize>>::Output

fn _clamp(self, min: isize, max: isize) -> <u32 as NormalOut<isize>>::Output

fn _mul_add(self, a: isize, b: isize) -> <u32 as NormalOut<isize>>::Output

fn _add(self, rhs: isize) -> <u32 as NormalOut<isize>>::Output

fn _sub(self, rhs: isize) -> <u32 as NormalOut<isize>>::Output

fn _mul(self, rhs: isize) -> <u32 as NormalOut<isize>>::Output

fn _rem(self, rhs: isize) -> <u32 as NormalOut<isize>>::Output

fn _max(self, rhs: isize) -> <u32 as NormalOut<isize>>::Output

fn _min(self, rhs: isize) -> <u32 as NormalOut<isize>>::Output

impl NormalOut<isize> for u64

type Output = <u64 as NormalOutPromote<isize>>::Output

fn _pow(self, rhs: isize) -> <u64 as NormalOut<isize>>::Output

fn _clamp(self, min: isize, max: isize) -> <u64 as NormalOut<isize>>::Output

fn _mul_add(self, a: isize, b: isize) -> <u64 as NormalOut<isize>>::Output

fn _add(self, rhs: isize) -> <u64 as NormalOut<isize>>::Output

fn _sub(self, rhs: isize) -> <u64 as NormalOut<isize>>::Output

fn _mul(self, rhs: isize) -> <u64 as NormalOut<isize>>::Output

fn _rem(self, rhs: isize) -> <u64 as NormalOut<isize>>::Output

fn _max(self, rhs: isize) -> <u64 as NormalOut<isize>>::Output

fn _min(self, rhs: isize) -> <u64 as NormalOut<isize>>::Output

impl NormalOut<isize> for usize

type Output = <usize as NormalOutPromote<isize>>::Output

fn _pow(self, rhs: isize) -> <usize as NormalOut<isize>>::Output

fn _clamp(self, min: isize, max: isize) -> <usize as NormalOut<isize>>::Output

fn _mul_add(self, a: isize, b: isize) -> <usize as NormalOut<isize>>::Output

fn _add(self, rhs: isize) -> <usize as NormalOut<isize>>::Output

fn _sub(self, rhs: isize) -> <usize as NormalOut<isize>>::Output

fn _mul(self, rhs: isize) -> <usize as NormalOut<isize>>::Output

fn _rem(self, rhs: isize) -> <usize as NormalOut<isize>>::Output

fn _max(self, rhs: isize) -> <usize as NormalOut<isize>>::Output

fn _min(self, rhs: isize) -> <usize as NormalOut<isize>>::Output

impl NormalOut<isize> for bf16

type Output = <bf16 as NormalOutPromote<isize>>::Output

fn _pow(self, rhs: isize) -> <bf16 as NormalOut<isize>>::Output

fn _clamp(self, min: isize, max: isize) -> <bf16 as NormalOut<isize>>::Output

fn _mul_add(self, a: isize, b: isize) -> <bf16 as NormalOut<isize>>::Output

fn _add(self, rhs: isize) -> <bf16 as NormalOut<isize>>::Output

fn _sub(self, rhs: isize) -> <bf16 as NormalOut<isize>>::Output

fn _mul(self, rhs: isize) -> <bf16 as NormalOut<isize>>::Output

fn _rem(self, rhs: isize) -> <bf16 as NormalOut<isize>>::Output

fn _max(self, rhs: isize) -> <bf16 as NormalOut<isize>>::Output

fn _min(self, rhs: isize) -> <bf16 as NormalOut<isize>>::Output

impl NormalOut<isize> for f16

type Output = <f16 as NormalOutPromote<isize>>::Output

fn _pow(self, rhs: isize) -> <f16 as NormalOut<isize>>::Output

fn _clamp(self, min: isize, max: isize) -> <f16 as NormalOut<isize>>::Output

fn _mul_add(self, a: isize, b: isize) -> <f16 as NormalOut<isize>>::Output

fn _add(self, rhs: isize) -> <f16 as NormalOut<isize>>::Output

fn _sub(self, rhs: isize) -> <f16 as NormalOut<isize>>::Output

fn _mul(self, rhs: isize) -> <f16 as NormalOut<isize>>::Output

fn _rem(self, rhs: isize) -> <f16 as NormalOut<isize>>::Output

fn _max(self, rhs: isize) -> <f16 as NormalOut<isize>>::Output

fn _min(self, rhs: isize) -> <f16 as NormalOut<isize>>::Output

impl NormalOut<isize> for Complex<f32>

type Output = <Complex<f32> as NormalOutPromote<isize>>::Output

fn _pow(self, rhs: isize) -> <Complex<f32> as NormalOut<isize>>::Output

fn _clamp( self, min: isize, max: isize, ) -> <Complex<f32> as NormalOut<isize>>::Output

fn _mul_add( self, a: isize, b: isize, ) -> <Complex<f32> as NormalOut<isize>>::Output

fn _add(self, rhs: isize) -> <Complex<f32> as NormalOut<isize>>::Output

fn _sub(self, rhs: isize) -> <Complex<f32> as NormalOut<isize>>::Output

fn _mul(self, rhs: isize) -> <Complex<f32> as NormalOut<isize>>::Output

fn _rem(self, rhs: isize) -> <Complex<f32> as NormalOut<isize>>::Output

fn _max(self, rhs: isize) -> <Complex<f32> as NormalOut<isize>>::Output

fn _min(self, rhs: isize) -> <Complex<f32> as NormalOut<isize>>::Output

impl NormalOut<isize> for Complex<f64>

type Output = <Complex<f64> as NormalOutPromote<isize>>::Output

fn _pow(self, rhs: isize) -> <Complex<f64> as NormalOut<isize>>::Output

fn _clamp( self, min: isize, max: isize, ) -> <Complex<f64> as NormalOut<isize>>::Output

fn _mul_add( self, a: isize, b: isize, ) -> <Complex<f64> as NormalOut<isize>>::Output

fn _add(self, rhs: isize) -> <Complex<f64> as NormalOut<isize>>::Output

fn _sub(self, rhs: isize) -> <Complex<f64> as NormalOut<isize>>::Output

fn _mul(self, rhs: isize) -> <Complex<f64> as NormalOut<isize>>::Output

fn _rem(self, rhs: isize) -> <Complex<f64> as NormalOut<isize>>::Output

fn _max(self, rhs: isize) -> <Complex<f64> as NormalOut<isize>>::Output

fn _min(self, rhs: isize) -> <Complex<f64> as NormalOut<isize>>::Output

impl NormalOut<u8> for bool

type Output = <bool as NormalOutPromote<u8>>::Output

fn _pow(self, rhs: u8) -> <bool as NormalOut<u8>>::Output

fn _clamp(self, min: u8, max: u8) -> <bool as NormalOut<u8>>::Output

fn _mul_add(self, a: u8, b: u8) -> <bool as NormalOut<u8>>::Output

fn _add(self, rhs: u8) -> <bool as NormalOut<u8>>::Output

fn _sub(self, rhs: u8) -> <bool as NormalOut<u8>>::Output

fn _mul(self, rhs: u8) -> <bool as NormalOut<u8>>::Output

fn _rem(self, rhs: u8) -> <bool as NormalOut<u8>>::Output

fn _max(self, rhs: u8) -> <bool as NormalOut<u8>>::Output

fn _min(self, rhs: u8) -> <bool as NormalOut<u8>>::Output

impl NormalOut<u8> for f32

type Output = <f32 as NormalOutPromote<u8>>::Output

fn _pow(self, rhs: u8) -> <f32 as NormalOut<u8>>::Output

fn _clamp(self, min: u8, max: u8) -> <f32 as NormalOut<u8>>::Output

fn _mul_add(self, a: u8, b: u8) -> <f32 as NormalOut<u8>>::Output

fn _add(self, rhs: u8) -> <f32 as NormalOut<u8>>::Output

fn _sub(self, rhs: u8) -> <f32 as NormalOut<u8>>::Output

fn _mul(self, rhs: u8) -> <f32 as NormalOut<u8>>::Output

fn _rem(self, rhs: u8) -> <f32 as NormalOut<u8>>::Output

fn _max(self, rhs: u8) -> <f32 as NormalOut<u8>>::Output

fn _min(self, rhs: u8) -> <f32 as NormalOut<u8>>::Output

impl NormalOut<u8> for f64

type Output = <f64 as NormalOutPromote<u8>>::Output

fn _pow(self, rhs: u8) -> <f64 as NormalOut<u8>>::Output

fn _clamp(self, min: u8, max: u8) -> <f64 as NormalOut<u8>>::Output

fn _mul_add(self, a: u8, b: u8) -> <f64 as NormalOut<u8>>::Output

fn _add(self, rhs: u8) -> <f64 as NormalOut<u8>>::Output

fn _sub(self, rhs: u8) -> <f64 as NormalOut<u8>>::Output

fn _mul(self, rhs: u8) -> <f64 as NormalOut<u8>>::Output

fn _rem(self, rhs: u8) -> <f64 as NormalOut<u8>>::Output

fn _max(self, rhs: u8) -> <f64 as NormalOut<u8>>::Output

fn _min(self, rhs: u8) -> <f64 as NormalOut<u8>>::Output

impl NormalOut<u8> for i8

type Output = <i8 as NormalOutPromote<u8>>::Output

fn _pow(self, rhs: u8) -> <i8 as NormalOut<u8>>::Output

fn _clamp(self, min: u8, max: u8) -> <i8 as NormalOut<u8>>::Output

fn _mul_add(self, a: u8, b: u8) -> <i8 as NormalOut<u8>>::Output

fn _add(self, rhs: u8) -> <i8 as NormalOut<u8>>::Output

fn _sub(self, rhs: u8) -> <i8 as NormalOut<u8>>::Output

fn _mul(self, rhs: u8) -> <i8 as NormalOut<u8>>::Output

fn _rem(self, rhs: u8) -> <i8 as NormalOut<u8>>::Output

fn _max(self, rhs: u8) -> <i8 as NormalOut<u8>>::Output

fn _min(self, rhs: u8) -> <i8 as NormalOut<u8>>::Output

impl NormalOut<u8> for i16

type Output = <i16 as NormalOutPromote<u8>>::Output

fn _pow(self, rhs: u8) -> <i16 as NormalOut<u8>>::Output

fn _clamp(self, min: u8, max: u8) -> <i16 as NormalOut<u8>>::Output

fn _mul_add(self, a: u8, b: u8) -> <i16 as NormalOut<u8>>::Output

fn _add(self, rhs: u8) -> <i16 as NormalOut<u8>>::Output

fn _sub(self, rhs: u8) -> <i16 as NormalOut<u8>>::Output

fn _mul(self, rhs: u8) -> <i16 as NormalOut<u8>>::Output

fn _rem(self, rhs: u8) -> <i16 as NormalOut<u8>>::Output

fn _max(self, rhs: u8) -> <i16 as NormalOut<u8>>::Output

fn _min(self, rhs: u8) -> <i16 as NormalOut<u8>>::Output

impl NormalOut<u8> for i32

type Output = <i32 as NormalOutPromote<u8>>::Output

fn _pow(self, rhs: u8) -> <i32 as NormalOut<u8>>::Output

fn _clamp(self, min: u8, max: u8) -> <i32 as NormalOut<u8>>::Output

fn _mul_add(self, a: u8, b: u8) -> <i32 as NormalOut<u8>>::Output

fn _add(self, rhs: u8) -> <i32 as NormalOut<u8>>::Output

fn _sub(self, rhs: u8) -> <i32 as NormalOut<u8>>::Output

fn _mul(self, rhs: u8) -> <i32 as NormalOut<u8>>::Output

fn _rem(self, rhs: u8) -> <i32 as NormalOut<u8>>::Output

fn _max(self, rhs: u8) -> <i32 as NormalOut<u8>>::Output

fn _min(self, rhs: u8) -> <i32 as NormalOut<u8>>::Output

impl NormalOut<u8> for i64

type Output = <i64 as NormalOutPromote<u8>>::Output

fn _pow(self, rhs: u8) -> <i64 as NormalOut<u8>>::Output

fn _clamp(self, min: u8, max: u8) -> <i64 as NormalOut<u8>>::Output

fn _mul_add(self, a: u8, b: u8) -> <i64 as NormalOut<u8>>::Output

fn _add(self, rhs: u8) -> <i64 as NormalOut<u8>>::Output

fn _sub(self, rhs: u8) -> <i64 as NormalOut<u8>>::Output

fn _mul(self, rhs: u8) -> <i64 as NormalOut<u8>>::Output

fn _rem(self, rhs: u8) -> <i64 as NormalOut<u8>>::Output

fn _max(self, rhs: u8) -> <i64 as NormalOut<u8>>::Output

fn _min(self, rhs: u8) -> <i64 as NormalOut<u8>>::Output

impl NormalOut<u8> for isize

type Output = <isize as NormalOutPromote<u8>>::Output

fn _pow(self, rhs: u8) -> <isize as NormalOut<u8>>::Output

fn _clamp(self, min: u8, max: u8) -> <isize as NormalOut<u8>>::Output

fn _mul_add(self, a: u8, b: u8) -> <isize as NormalOut<u8>>::Output

fn _add(self, rhs: u8) -> <isize as NormalOut<u8>>::Output

fn _sub(self, rhs: u8) -> <isize as NormalOut<u8>>::Output

fn _mul(self, rhs: u8) -> <isize as NormalOut<u8>>::Output

fn _rem(self, rhs: u8) -> <isize as NormalOut<u8>>::Output

fn _max(self, rhs: u8) -> <isize as NormalOut<u8>>::Output

fn _min(self, rhs: u8) -> <isize as NormalOut<u8>>::Output

impl NormalOut<u8> for u16

type Output = <u16 as NormalOutPromote<u8>>::Output

fn _pow(self, rhs: u8) -> <u16 as NormalOut<u8>>::Output

fn _clamp(self, min: u8, max: u8) -> <u16 as NormalOut<u8>>::Output

fn _mul_add(self, a: u8, b: u8) -> <u16 as NormalOut<u8>>::Output

fn _add(self, rhs: u8) -> <u16 as NormalOut<u8>>::Output

fn _sub(self, rhs: u8) -> <u16 as NormalOut<u8>>::Output

fn _mul(self, rhs: u8) -> <u16 as NormalOut<u8>>::Output

fn _rem(self, rhs: u8) -> <u16 as NormalOut<u8>>::Output

fn _max(self, rhs: u8) -> <u16 as NormalOut<u8>>::Output

fn _min(self, rhs: u8) -> <u16 as NormalOut<u8>>::Output

impl NormalOut<u8> for u32

type Output = <u32 as NormalOutPromote<u8>>::Output

fn _pow(self, rhs: u8) -> <u32 as NormalOut<u8>>::Output

fn _clamp(self, min: u8, max: u8) -> <u32 as NormalOut<u8>>::Output

fn _mul_add(self, a: u8, b: u8) -> <u32 as NormalOut<u8>>::Output

fn _add(self, rhs: u8) -> <u32 as NormalOut<u8>>::Output

fn _sub(self, rhs: u8) -> <u32 as NormalOut<u8>>::Output

fn _mul(self, rhs: u8) -> <u32 as NormalOut<u8>>::Output

fn _rem(self, rhs: u8) -> <u32 as NormalOut<u8>>::Output

fn _max(self, rhs: u8) -> <u32 as NormalOut<u8>>::Output

fn _min(self, rhs: u8) -> <u32 as NormalOut<u8>>::Output

impl NormalOut<u8> for u64

type Output = <u64 as NormalOutPromote<u8>>::Output

fn _pow(self, rhs: u8) -> <u64 as NormalOut<u8>>::Output

fn _clamp(self, min: u8, max: u8) -> <u64 as NormalOut<u8>>::Output

fn _mul_add(self, a: u8, b: u8) -> <u64 as NormalOut<u8>>::Output

fn _add(self, rhs: u8) -> <u64 as NormalOut<u8>>::Output

fn _sub(self, rhs: u8) -> <u64 as NormalOut<u8>>::Output

fn _mul(self, rhs: u8) -> <u64 as NormalOut<u8>>::Output

fn _rem(self, rhs: u8) -> <u64 as NormalOut<u8>>::Output

fn _max(self, rhs: u8) -> <u64 as NormalOut<u8>>::Output

fn _min(self, rhs: u8) -> <u64 as NormalOut<u8>>::Output

impl NormalOut<u8> for usize

type Output = <usize as NormalOutPromote<u8>>::Output

fn _pow(self, rhs: u8) -> <usize as NormalOut<u8>>::Output

fn _clamp(self, min: u8, max: u8) -> <usize as NormalOut<u8>>::Output

fn _mul_add(self, a: u8, b: u8) -> <usize as NormalOut<u8>>::Output

fn _add(self, rhs: u8) -> <usize as NormalOut<u8>>::Output

fn _sub(self, rhs: u8) -> <usize as NormalOut<u8>>::Output

fn _mul(self, rhs: u8) -> <usize as NormalOut<u8>>::Output

fn _rem(self, rhs: u8) -> <usize as NormalOut<u8>>::Output

fn _max(self, rhs: u8) -> <usize as NormalOut<u8>>::Output

fn _min(self, rhs: u8) -> <usize as NormalOut<u8>>::Output

impl NormalOut<u8> for bf16

type Output = <bf16 as NormalOutPromote<u8>>::Output

fn _pow(self, rhs: u8) -> <bf16 as NormalOut<u8>>::Output

fn _clamp(self, min: u8, max: u8) -> <bf16 as NormalOut<u8>>::Output

fn _mul_add(self, a: u8, b: u8) -> <bf16 as NormalOut<u8>>::Output

fn _add(self, rhs: u8) -> <bf16 as NormalOut<u8>>::Output

fn _sub(self, rhs: u8) -> <bf16 as NormalOut<u8>>::Output

fn _mul(self, rhs: u8) -> <bf16 as NormalOut<u8>>::Output

fn _rem(self, rhs: u8) -> <bf16 as NormalOut<u8>>::Output

fn _max(self, rhs: u8) -> <bf16 as NormalOut<u8>>::Output

fn _min(self, rhs: u8) -> <bf16 as NormalOut<u8>>::Output

impl NormalOut<u8> for f16

type Output = <f16 as NormalOutPromote<u8>>::Output

fn _pow(self, rhs: u8) -> <f16 as NormalOut<u8>>::Output

fn _clamp(self, min: u8, max: u8) -> <f16 as NormalOut<u8>>::Output

fn _mul_add(self, a: u8, b: u8) -> <f16 as NormalOut<u8>>::Output

fn _add(self, rhs: u8) -> <f16 as NormalOut<u8>>::Output

fn _sub(self, rhs: u8) -> <f16 as NormalOut<u8>>::Output

fn _mul(self, rhs: u8) -> <f16 as NormalOut<u8>>::Output

fn _rem(self, rhs: u8) -> <f16 as NormalOut<u8>>::Output

fn _max(self, rhs: u8) -> <f16 as NormalOut<u8>>::Output

fn _min(self, rhs: u8) -> <f16 as NormalOut<u8>>::Output

impl NormalOut<u8> for Complex<f32>

type Output = <Complex<f32> as NormalOutPromote<u8>>::Output

fn _pow(self, rhs: u8) -> <Complex<f32> as NormalOut<u8>>::Output

fn _clamp(self, min: u8, max: u8) -> <Complex<f32> as NormalOut<u8>>::Output

fn _mul_add(self, a: u8, b: u8) -> <Complex<f32> as NormalOut<u8>>::Output

fn _add(self, rhs: u8) -> <Complex<f32> as NormalOut<u8>>::Output

fn _sub(self, rhs: u8) -> <Complex<f32> as NormalOut<u8>>::Output

fn _mul(self, rhs: u8) -> <Complex<f32> as NormalOut<u8>>::Output

fn _rem(self, rhs: u8) -> <Complex<f32> as NormalOut<u8>>::Output

fn _max(self, rhs: u8) -> <Complex<f32> as NormalOut<u8>>::Output

fn _min(self, rhs: u8) -> <Complex<f32> as NormalOut<u8>>::Output

impl NormalOut<u8> for Complex<f64>

type Output = <Complex<f64> as NormalOutPromote<u8>>::Output

fn _pow(self, rhs: u8) -> <Complex<f64> as NormalOut<u8>>::Output

fn _clamp(self, min: u8, max: u8) -> <Complex<f64> as NormalOut<u8>>::Output

fn _mul_add(self, a: u8, b: u8) -> <Complex<f64> as NormalOut<u8>>::Output

fn _add(self, rhs: u8) -> <Complex<f64> as NormalOut<u8>>::Output

fn _sub(self, rhs: u8) -> <Complex<f64> as NormalOut<u8>>::Output

fn _mul(self, rhs: u8) -> <Complex<f64> as NormalOut<u8>>::Output

fn _rem(self, rhs: u8) -> <Complex<f64> as NormalOut<u8>>::Output

fn _max(self, rhs: u8) -> <Complex<f64> as NormalOut<u8>>::Output

fn _min(self, rhs: u8) -> <Complex<f64> as NormalOut<u8>>::Output

impl NormalOut<u16> for bool

type Output = <bool as NormalOutPromote<u16>>::Output

fn _pow(self, rhs: u16) -> <bool as NormalOut<u16>>::Output

fn _clamp(self, min: u16, max: u16) -> <bool as NormalOut<u16>>::Output

fn _mul_add(self, a: u16, b: u16) -> <bool as NormalOut<u16>>::Output

fn _add(self, rhs: u16) -> <bool as NormalOut<u16>>::Output

fn _sub(self, rhs: u16) -> <bool as NormalOut<u16>>::Output

fn _mul(self, rhs: u16) -> <bool as NormalOut<u16>>::Output

fn _rem(self, rhs: u16) -> <bool as NormalOut<u16>>::Output

fn _max(self, rhs: u16) -> <bool as NormalOut<u16>>::Output

fn _min(self, rhs: u16) -> <bool as NormalOut<u16>>::Output

impl NormalOut<u16> for f32

type Output = <f32 as NormalOutPromote<u16>>::Output

fn _pow(self, rhs: u16) -> <f32 as NormalOut<u16>>::Output

fn _clamp(self, min: u16, max: u16) -> <f32 as NormalOut<u16>>::Output

fn _mul_add(self, a: u16, b: u16) -> <f32 as NormalOut<u16>>::Output

fn _add(self, rhs: u16) -> <f32 as NormalOut<u16>>::Output

fn _sub(self, rhs: u16) -> <f32 as NormalOut<u16>>::Output

fn _mul(self, rhs: u16) -> <f32 as NormalOut<u16>>::Output

fn _rem(self, rhs: u16) -> <f32 as NormalOut<u16>>::Output

fn _max(self, rhs: u16) -> <f32 as NormalOut<u16>>::Output

fn _min(self, rhs: u16) -> <f32 as NormalOut<u16>>::Output

impl NormalOut<u16> for f64

type Output = <f64 as NormalOutPromote<u16>>::Output

fn _pow(self, rhs: u16) -> <f64 as NormalOut<u16>>::Output

fn _clamp(self, min: u16, max: u16) -> <f64 as NormalOut<u16>>::Output

fn _mul_add(self, a: u16, b: u16) -> <f64 as NormalOut<u16>>::Output

fn _add(self, rhs: u16) -> <f64 as NormalOut<u16>>::Output

fn _sub(self, rhs: u16) -> <f64 as NormalOut<u16>>::Output

fn _mul(self, rhs: u16) -> <f64 as NormalOut<u16>>::Output

fn _rem(self, rhs: u16) -> <f64 as NormalOut<u16>>::Output

fn _max(self, rhs: u16) -> <f64 as NormalOut<u16>>::Output

fn _min(self, rhs: u16) -> <f64 as NormalOut<u16>>::Output

impl NormalOut<u16> for i8

type Output = <i8 as NormalOutPromote<u16>>::Output

fn _pow(self, rhs: u16) -> <i8 as NormalOut<u16>>::Output

fn _clamp(self, min: u16, max: u16) -> <i8 as NormalOut<u16>>::Output

fn _mul_add(self, a: u16, b: u16) -> <i8 as NormalOut<u16>>::Output

fn _add(self, rhs: u16) -> <i8 as NormalOut<u16>>::Output

fn _sub(self, rhs: u16) -> <i8 as NormalOut<u16>>::Output

fn _mul(self, rhs: u16) -> <i8 as NormalOut<u16>>::Output

fn _rem(self, rhs: u16) -> <i8 as NormalOut<u16>>::Output

fn _max(self, rhs: u16) -> <i8 as NormalOut<u16>>::Output

fn _min(self, rhs: u16) -> <i8 as NormalOut<u16>>::Output

impl NormalOut<u16> for i16

type Output = <i16 as NormalOutPromote<u16>>::Output

fn _pow(self, rhs: u16) -> <i16 as NormalOut<u16>>::Output

fn _clamp(self, min: u16, max: u16) -> <i16 as NormalOut<u16>>::Output

fn _mul_add(self, a: u16, b: u16) -> <i16 as NormalOut<u16>>::Output

fn _add(self, rhs: u16) -> <i16 as NormalOut<u16>>::Output

fn _sub(self, rhs: u16) -> <i16 as NormalOut<u16>>::Output

fn _mul(self, rhs: u16) -> <i16 as NormalOut<u16>>::Output

fn _rem(self, rhs: u16) -> <i16 as NormalOut<u16>>::Output

fn _max(self, rhs: u16) -> <i16 as NormalOut<u16>>::Output

fn _min(self, rhs: u16) -> <i16 as NormalOut<u16>>::Output

impl NormalOut<u16> for i32

type Output = <i32 as NormalOutPromote<u16>>::Output

fn _pow(self, rhs: u16) -> <i32 as NormalOut<u16>>::Output

fn _clamp(self, min: u16, max: u16) -> <i32 as NormalOut<u16>>::Output

fn _mul_add(self, a: u16, b: u16) -> <i32 as NormalOut<u16>>::Output

fn _add(self, rhs: u16) -> <i32 as NormalOut<u16>>::Output

fn _sub(self, rhs: u16) -> <i32 as NormalOut<u16>>::Output

fn _mul(self, rhs: u16) -> <i32 as NormalOut<u16>>::Output

fn _rem(self, rhs: u16) -> <i32 as NormalOut<u16>>::Output

fn _max(self, rhs: u16) -> <i32 as NormalOut<u16>>::Output

fn _min(self, rhs: u16) -> <i32 as NormalOut<u16>>::Output

impl NormalOut<u16> for i64

type Output = <i64 as NormalOutPromote<u16>>::Output

fn _pow(self, rhs: u16) -> <i64 as NormalOut<u16>>::Output

fn _clamp(self, min: u16, max: u16) -> <i64 as NormalOut<u16>>::Output

fn _mul_add(self, a: u16, b: u16) -> <i64 as NormalOut<u16>>::Output

fn _add(self, rhs: u16) -> <i64 as NormalOut<u16>>::Output

fn _sub(self, rhs: u16) -> <i64 as NormalOut<u16>>::Output

fn _mul(self, rhs: u16) -> <i64 as NormalOut<u16>>::Output

fn _rem(self, rhs: u16) -> <i64 as NormalOut<u16>>::Output

fn _max(self, rhs: u16) -> <i64 as NormalOut<u16>>::Output

fn _min(self, rhs: u16) -> <i64 as NormalOut<u16>>::Output

impl NormalOut<u16> for isize

type Output = <isize as NormalOutPromote<u16>>::Output

fn _pow(self, rhs: u16) -> <isize as NormalOut<u16>>::Output

fn _clamp(self, min: u16, max: u16) -> <isize as NormalOut<u16>>::Output

fn _mul_add(self, a: u16, b: u16) -> <isize as NormalOut<u16>>::Output

fn _add(self, rhs: u16) -> <isize as NormalOut<u16>>::Output

fn _sub(self, rhs: u16) -> <isize as NormalOut<u16>>::Output

fn _mul(self, rhs: u16) -> <isize as NormalOut<u16>>::Output

fn _rem(self, rhs: u16) -> <isize as NormalOut<u16>>::Output

fn _max(self, rhs: u16) -> <isize as NormalOut<u16>>::Output

fn _min(self, rhs: u16) -> <isize as NormalOut<u16>>::Output

impl NormalOut<u16> for u8

type Output = <u8 as NormalOutPromote<u16>>::Output

fn _pow(self, rhs: u16) -> <u8 as NormalOut<u16>>::Output

fn _clamp(self, min: u16, max: u16) -> <u8 as NormalOut<u16>>::Output

fn _mul_add(self, a: u16, b: u16) -> <u8 as NormalOut<u16>>::Output

fn _add(self, rhs: u16) -> <u8 as NormalOut<u16>>::Output

fn _sub(self, rhs: u16) -> <u8 as NormalOut<u16>>::Output

fn _mul(self, rhs: u16) -> <u8 as NormalOut<u16>>::Output

fn _rem(self, rhs: u16) -> <u8 as NormalOut<u16>>::Output

fn _max(self, rhs: u16) -> <u8 as NormalOut<u16>>::Output

fn _min(self, rhs: u16) -> <u8 as NormalOut<u16>>::Output

impl NormalOut<u16> for u32

type Output = <u32 as NormalOutPromote<u16>>::Output

fn _pow(self, rhs: u16) -> <u32 as NormalOut<u16>>::Output

fn _clamp(self, min: u16, max: u16) -> <u32 as NormalOut<u16>>::Output

fn _mul_add(self, a: u16, b: u16) -> <u32 as NormalOut<u16>>::Output

fn _add(self, rhs: u16) -> <u32 as NormalOut<u16>>::Output

fn _sub(self, rhs: u16) -> <u32 as NormalOut<u16>>::Output

fn _mul(self, rhs: u16) -> <u32 as NormalOut<u16>>::Output

fn _rem(self, rhs: u16) -> <u32 as NormalOut<u16>>::Output

fn _max(self, rhs: u16) -> <u32 as NormalOut<u16>>::Output

fn _min(self, rhs: u16) -> <u32 as NormalOut<u16>>::Output

impl NormalOut<u16> for u64

type Output = <u64 as NormalOutPromote<u16>>::Output

fn _pow(self, rhs: u16) -> <u64 as NormalOut<u16>>::Output

fn _clamp(self, min: u16, max: u16) -> <u64 as NormalOut<u16>>::Output

fn _mul_add(self, a: u16, b: u16) -> <u64 as NormalOut<u16>>::Output

fn _add(self, rhs: u16) -> <u64 as NormalOut<u16>>::Output

fn _sub(self, rhs: u16) -> <u64 as NormalOut<u16>>::Output

fn _mul(self, rhs: u16) -> <u64 as NormalOut<u16>>::Output

fn _rem(self, rhs: u16) -> <u64 as NormalOut<u16>>::Output

fn _max(self, rhs: u16) -> <u64 as NormalOut<u16>>::Output

fn _min(self, rhs: u16) -> <u64 as NormalOut<u16>>::Output

impl NormalOut<u16> for usize

type Output = <usize as NormalOutPromote<u16>>::Output

fn _pow(self, rhs: u16) -> <usize as NormalOut<u16>>::Output

fn _clamp(self, min: u16, max: u16) -> <usize as NormalOut<u16>>::Output

fn _mul_add(self, a: u16, b: u16) -> <usize as NormalOut<u16>>::Output

fn _add(self, rhs: u16) -> <usize as NormalOut<u16>>::Output

fn _sub(self, rhs: u16) -> <usize as NormalOut<u16>>::Output

fn _mul(self, rhs: u16) -> <usize as NormalOut<u16>>::Output

fn _rem(self, rhs: u16) -> <usize as NormalOut<u16>>::Output

fn _max(self, rhs: u16) -> <usize as NormalOut<u16>>::Output

fn _min(self, rhs: u16) -> <usize as NormalOut<u16>>::Output

impl NormalOut<u16> for bf16

type Output = <bf16 as NormalOutPromote<u16>>::Output

fn _pow(self, rhs: u16) -> <bf16 as NormalOut<u16>>::Output

fn _clamp(self, min: u16, max: u16) -> <bf16 as NormalOut<u16>>::Output

fn _mul_add(self, a: u16, b: u16) -> <bf16 as NormalOut<u16>>::Output

fn _add(self, rhs: u16) -> <bf16 as NormalOut<u16>>::Output

fn _sub(self, rhs: u16) -> <bf16 as NormalOut<u16>>::Output

fn _mul(self, rhs: u16) -> <bf16 as NormalOut<u16>>::Output

fn _rem(self, rhs: u16) -> <bf16 as NormalOut<u16>>::Output

fn _max(self, rhs: u16) -> <bf16 as NormalOut<u16>>::Output

fn _min(self, rhs: u16) -> <bf16 as NormalOut<u16>>::Output

impl NormalOut<u16> for f16

type Output = <f16 as NormalOutPromote<u16>>::Output

fn _pow(self, rhs: u16) -> <f16 as NormalOut<u16>>::Output

fn _clamp(self, min: u16, max: u16) -> <f16 as NormalOut<u16>>::Output

fn _mul_add(self, a: u16, b: u16) -> <f16 as NormalOut<u16>>::Output

fn _add(self, rhs: u16) -> <f16 as NormalOut<u16>>::Output

fn _sub(self, rhs: u16) -> <f16 as NormalOut<u16>>::Output

fn _mul(self, rhs: u16) -> <f16 as NormalOut<u16>>::Output

fn _rem(self, rhs: u16) -> <f16 as NormalOut<u16>>::Output

fn _max(self, rhs: u16) -> <f16 as NormalOut<u16>>::Output

fn _min(self, rhs: u16) -> <f16 as NormalOut<u16>>::Output

impl NormalOut<u16> for Complex<f32>

type Output = <Complex<f32> as NormalOutPromote<u16>>::Output

fn _pow(self, rhs: u16) -> <Complex<f32> as NormalOut<u16>>::Output

fn _clamp(self, min: u16, max: u16) -> <Complex<f32> as NormalOut<u16>>::Output

fn _mul_add(self, a: u16, b: u16) -> <Complex<f32> as NormalOut<u16>>::Output

fn _add(self, rhs: u16) -> <Complex<f32> as NormalOut<u16>>::Output

fn _sub(self, rhs: u16) -> <Complex<f32> as NormalOut<u16>>::Output

fn _mul(self, rhs: u16) -> <Complex<f32> as NormalOut<u16>>::Output

fn _rem(self, rhs: u16) -> <Complex<f32> as NormalOut<u16>>::Output

fn _max(self, rhs: u16) -> <Complex<f32> as NormalOut<u16>>::Output

fn _min(self, rhs: u16) -> <Complex<f32> as NormalOut<u16>>::Output

impl NormalOut<u16> for Complex<f64>

type Output = <Complex<f64> as NormalOutPromote<u16>>::Output

fn _pow(self, rhs: u16) -> <Complex<f64> as NormalOut<u16>>::Output

fn _clamp(self, min: u16, max: u16) -> <Complex<f64> as NormalOut<u16>>::Output

fn _mul_add(self, a: u16, b: u16) -> <Complex<f64> as NormalOut<u16>>::Output

fn _add(self, rhs: u16) -> <Complex<f64> as NormalOut<u16>>::Output

fn _sub(self, rhs: u16) -> <Complex<f64> as NormalOut<u16>>::Output

fn _mul(self, rhs: u16) -> <Complex<f64> as NormalOut<u16>>::Output

fn _rem(self, rhs: u16) -> <Complex<f64> as NormalOut<u16>>::Output

fn _max(self, rhs: u16) -> <Complex<f64> as NormalOut<u16>>::Output

fn _min(self, rhs: u16) -> <Complex<f64> as NormalOut<u16>>::Output

impl NormalOut<u32> for bool

type Output = <bool as NormalOutPromote<u32>>::Output

fn _pow(self, rhs: u32) -> <bool as NormalOut<u32>>::Output

fn _clamp(self, min: u32, max: u32) -> <bool as NormalOut<u32>>::Output

fn _mul_add(self, a: u32, b: u32) -> <bool as NormalOut<u32>>::Output

fn _add(self, rhs: u32) -> <bool as NormalOut<u32>>::Output

fn _sub(self, rhs: u32) -> <bool as NormalOut<u32>>::Output

fn _mul(self, rhs: u32) -> <bool as NormalOut<u32>>::Output

fn _rem(self, rhs: u32) -> <bool as NormalOut<u32>>::Output

fn _max(self, rhs: u32) -> <bool as NormalOut<u32>>::Output

fn _min(self, rhs: u32) -> <bool as NormalOut<u32>>::Output

impl NormalOut<u32> for f32

type Output = <f32 as NormalOutPromote<u32>>::Output

fn _pow(self, rhs: u32) -> <f32 as NormalOut<u32>>::Output

fn _clamp(self, min: u32, max: u32) -> <f32 as NormalOut<u32>>::Output

fn _mul_add(self, a: u32, b: u32) -> <f32 as NormalOut<u32>>::Output

fn _add(self, rhs: u32) -> <f32 as NormalOut<u32>>::Output

fn _sub(self, rhs: u32) -> <f32 as NormalOut<u32>>::Output

fn _mul(self, rhs: u32) -> <f32 as NormalOut<u32>>::Output

fn _rem(self, rhs: u32) -> <f32 as NormalOut<u32>>::Output

fn _max(self, rhs: u32) -> <f32 as NormalOut<u32>>::Output

fn _min(self, rhs: u32) -> <f32 as NormalOut<u32>>::Output

impl NormalOut<u32> for f64

type Output = <f64 as NormalOutPromote<u32>>::Output

fn _pow(self, rhs: u32) -> <f64 as NormalOut<u32>>::Output

fn _clamp(self, min: u32, max: u32) -> <f64 as NormalOut<u32>>::Output

fn _mul_add(self, a: u32, b: u32) -> <f64 as NormalOut<u32>>::Output

fn _add(self, rhs: u32) -> <f64 as NormalOut<u32>>::Output

fn _sub(self, rhs: u32) -> <f64 as NormalOut<u32>>::Output

fn _mul(self, rhs: u32) -> <f64 as NormalOut<u32>>::Output

fn _rem(self, rhs: u32) -> <f64 as NormalOut<u32>>::Output

fn _max(self, rhs: u32) -> <f64 as NormalOut<u32>>::Output

fn _min(self, rhs: u32) -> <f64 as NormalOut<u32>>::Output

impl NormalOut<u32> for i8

type Output = <i8 as NormalOutPromote<u32>>::Output

fn _pow(self, rhs: u32) -> <i8 as NormalOut<u32>>::Output

fn _clamp(self, min: u32, max: u32) -> <i8 as NormalOut<u32>>::Output

fn _mul_add(self, a: u32, b: u32) -> <i8 as NormalOut<u32>>::Output

fn _add(self, rhs: u32) -> <i8 as NormalOut<u32>>::Output

fn _sub(self, rhs: u32) -> <i8 as NormalOut<u32>>::Output

fn _mul(self, rhs: u32) -> <i8 as NormalOut<u32>>::Output

fn _rem(self, rhs: u32) -> <i8 as NormalOut<u32>>::Output

fn _max(self, rhs: u32) -> <i8 as NormalOut<u32>>::Output

fn _min(self, rhs: u32) -> <i8 as NormalOut<u32>>::Output

impl NormalOut<u32> for i16

type Output = <i16 as NormalOutPromote<u32>>::Output

fn _pow(self, rhs: u32) -> <i16 as NormalOut<u32>>::Output

fn _clamp(self, min: u32, max: u32) -> <i16 as NormalOut<u32>>::Output

fn _mul_add(self, a: u32, b: u32) -> <i16 as NormalOut<u32>>::Output

fn _add(self, rhs: u32) -> <i16 as NormalOut<u32>>::Output

fn _sub(self, rhs: u32) -> <i16 as NormalOut<u32>>::Output

fn _mul(self, rhs: u32) -> <i16 as NormalOut<u32>>::Output

fn _rem(self, rhs: u32) -> <i16 as NormalOut<u32>>::Output

fn _max(self, rhs: u32) -> <i16 as NormalOut<u32>>::Output

fn _min(self, rhs: u32) -> <i16 as NormalOut<u32>>::Output

impl NormalOut<u32> for i32

type Output = <i32 as NormalOutPromote<u32>>::Output

fn _pow(self, rhs: u32) -> <i32 as NormalOut<u32>>::Output

fn _clamp(self, min: u32, max: u32) -> <i32 as NormalOut<u32>>::Output

fn _mul_add(self, a: u32, b: u32) -> <i32 as NormalOut<u32>>::Output

fn _add(self, rhs: u32) -> <i32 as NormalOut<u32>>::Output

fn _sub(self, rhs: u32) -> <i32 as NormalOut<u32>>::Output

fn _mul(self, rhs: u32) -> <i32 as NormalOut<u32>>::Output

fn _rem(self, rhs: u32) -> <i32 as NormalOut<u32>>::Output

fn _max(self, rhs: u32) -> <i32 as NormalOut<u32>>::Output

fn _min(self, rhs: u32) -> <i32 as NormalOut<u32>>::Output

impl NormalOut<u32> for i64

type Output = <i64 as NormalOutPromote<u32>>::Output

fn _pow(self, rhs: u32) -> <i64 as NormalOut<u32>>::Output

fn _clamp(self, min: u32, max: u32) -> <i64 as NormalOut<u32>>::Output

fn _mul_add(self, a: u32, b: u32) -> <i64 as NormalOut<u32>>::Output

fn _add(self, rhs: u32) -> <i64 as NormalOut<u32>>::Output

fn _sub(self, rhs: u32) -> <i64 as NormalOut<u32>>::Output

fn _mul(self, rhs: u32) -> <i64 as NormalOut<u32>>::Output

fn _rem(self, rhs: u32) -> <i64 as NormalOut<u32>>::Output

fn _max(self, rhs: u32) -> <i64 as NormalOut<u32>>::Output

fn _min(self, rhs: u32) -> <i64 as NormalOut<u32>>::Output

impl NormalOut<u32> for isize

type Output = <isize as NormalOutPromote<u32>>::Output

fn _pow(self, rhs: u32) -> <isize as NormalOut<u32>>::Output

fn _clamp(self, min: u32, max: u32) -> <isize as NormalOut<u32>>::Output

fn _mul_add(self, a: u32, b: u32) -> <isize as NormalOut<u32>>::Output

fn _add(self, rhs: u32) -> <isize as NormalOut<u32>>::Output

fn _sub(self, rhs: u32) -> <isize as NormalOut<u32>>::Output

fn _mul(self, rhs: u32) -> <isize as NormalOut<u32>>::Output

fn _rem(self, rhs: u32) -> <isize as NormalOut<u32>>::Output

fn _max(self, rhs: u32) -> <isize as NormalOut<u32>>::Output

fn _min(self, rhs: u32) -> <isize as NormalOut<u32>>::Output

impl NormalOut<u32> for u8

type Output = <u8 as NormalOutPromote<u32>>::Output

fn _pow(self, rhs: u32) -> <u8 as NormalOut<u32>>::Output

fn _clamp(self, min: u32, max: u32) -> <u8 as NormalOut<u32>>::Output

fn _mul_add(self, a: u32, b: u32) -> <u8 as NormalOut<u32>>::Output

fn _add(self, rhs: u32) -> <u8 as NormalOut<u32>>::Output

fn _sub(self, rhs: u32) -> <u8 as NormalOut<u32>>::Output

fn _mul(self, rhs: u32) -> <u8 as NormalOut<u32>>::Output

fn _rem(self, rhs: u32) -> <u8 as NormalOut<u32>>::Output

fn _max(self, rhs: u32) -> <u8 as NormalOut<u32>>::Output

fn _min(self, rhs: u32) -> <u8 as NormalOut<u32>>::Output

impl NormalOut<u32> for u16

type Output = <u16 as NormalOutPromote<u32>>::Output

fn _pow(self, rhs: u32) -> <u16 as NormalOut<u32>>::Output

fn _clamp(self, min: u32, max: u32) -> <u16 as NormalOut<u32>>::Output

fn _mul_add(self, a: u32, b: u32) -> <u16 as NormalOut<u32>>::Output

fn _add(self, rhs: u32) -> <u16 as NormalOut<u32>>::Output

fn _sub(self, rhs: u32) -> <u16 as NormalOut<u32>>::Output

fn _mul(self, rhs: u32) -> <u16 as NormalOut<u32>>::Output

fn _rem(self, rhs: u32) -> <u16 as NormalOut<u32>>::Output

fn _max(self, rhs: u32) -> <u16 as NormalOut<u32>>::Output

fn _min(self, rhs: u32) -> <u16 as NormalOut<u32>>::Output

impl NormalOut<u32> for u64

type Output = <u64 as NormalOutPromote<u32>>::Output

fn _pow(self, rhs: u32) -> <u64 as NormalOut<u32>>::Output

fn _clamp(self, min: u32, max: u32) -> <u64 as NormalOut<u32>>::Output

fn _mul_add(self, a: u32, b: u32) -> <u64 as NormalOut<u32>>::Output

fn _add(self, rhs: u32) -> <u64 as NormalOut<u32>>::Output

fn _sub(self, rhs: u32) -> <u64 as NormalOut<u32>>::Output

fn _mul(self, rhs: u32) -> <u64 as NormalOut<u32>>::Output

fn _rem(self, rhs: u32) -> <u64 as NormalOut<u32>>::Output

fn _max(self, rhs: u32) -> <u64 as NormalOut<u32>>::Output

fn _min(self, rhs: u32) -> <u64 as NormalOut<u32>>::Output

impl NormalOut<u32> for usize

type Output = <usize as NormalOutPromote<u32>>::Output

fn _pow(self, rhs: u32) -> <usize as NormalOut<u32>>::Output

fn _clamp(self, min: u32, max: u32) -> <usize as NormalOut<u32>>::Output

fn _mul_add(self, a: u32, b: u32) -> <usize as NormalOut<u32>>::Output

fn _add(self, rhs: u32) -> <usize as NormalOut<u32>>::Output

fn _sub(self, rhs: u32) -> <usize as NormalOut<u32>>::Output

fn _mul(self, rhs: u32) -> <usize as NormalOut<u32>>::Output

fn _rem(self, rhs: u32) -> <usize as NormalOut<u32>>::Output

fn _max(self, rhs: u32) -> <usize as NormalOut<u32>>::Output

fn _min(self, rhs: u32) -> <usize as NormalOut<u32>>::Output

impl NormalOut<u32> for bf16

type Output = <bf16 as NormalOutPromote<u32>>::Output

fn _pow(self, rhs: u32) -> <bf16 as NormalOut<u32>>::Output

fn _clamp(self, min: u32, max: u32) -> <bf16 as NormalOut<u32>>::Output

fn _mul_add(self, a: u32, b: u32) -> <bf16 as NormalOut<u32>>::Output

fn _add(self, rhs: u32) -> <bf16 as NormalOut<u32>>::Output

fn _sub(self, rhs: u32) -> <bf16 as NormalOut<u32>>::Output

fn _mul(self, rhs: u32) -> <bf16 as NormalOut<u32>>::Output

fn _rem(self, rhs: u32) -> <bf16 as NormalOut<u32>>::Output

fn _max(self, rhs: u32) -> <bf16 as NormalOut<u32>>::Output

fn _min(self, rhs: u32) -> <bf16 as NormalOut<u32>>::Output

impl NormalOut<u32> for f16

type Output = <f16 as NormalOutPromote<u32>>::Output

fn _pow(self, rhs: u32) -> <f16 as NormalOut<u32>>::Output

fn _clamp(self, min: u32, max: u32) -> <f16 as NormalOut<u32>>::Output

fn _mul_add(self, a: u32, b: u32) -> <f16 as NormalOut<u32>>::Output

fn _add(self, rhs: u32) -> <f16 as NormalOut<u32>>::Output

fn _sub(self, rhs: u32) -> <f16 as NormalOut<u32>>::Output

fn _mul(self, rhs: u32) -> <f16 as NormalOut<u32>>::Output

fn _rem(self, rhs: u32) -> <f16 as NormalOut<u32>>::Output

fn _max(self, rhs: u32) -> <f16 as NormalOut<u32>>::Output

fn _min(self, rhs: u32) -> <f16 as NormalOut<u32>>::Output

impl NormalOut<u32> for Complex<f32>

type Output = <Complex<f32> as NormalOutPromote<u32>>::Output

fn _pow(self, rhs: u32) -> <Complex<f32> as NormalOut<u32>>::Output

fn _clamp(self, min: u32, max: u32) -> <Complex<f32> as NormalOut<u32>>::Output

fn _mul_add(self, a: u32, b: u32) -> <Complex<f32> as NormalOut<u32>>::Output

fn _add(self, rhs: u32) -> <Complex<f32> as NormalOut<u32>>::Output

fn _sub(self, rhs: u32) -> <Complex<f32> as NormalOut<u32>>::Output

fn _mul(self, rhs: u32) -> <Complex<f32> as NormalOut<u32>>::Output

fn _rem(self, rhs: u32) -> <Complex<f32> as NormalOut<u32>>::Output

fn _max(self, rhs: u32) -> <Complex<f32> as NormalOut<u32>>::Output

fn _min(self, rhs: u32) -> <Complex<f32> as NormalOut<u32>>::Output

impl NormalOut<u32> for Complex<f64>

type Output = <Complex<f64> as NormalOutPromote<u32>>::Output

fn _pow(self, rhs: u32) -> <Complex<f64> as NormalOut<u32>>::Output

fn _clamp(self, min: u32, max: u32) -> <Complex<f64> as NormalOut<u32>>::Output

fn _mul_add(self, a: u32, b: u32) -> <Complex<f64> as NormalOut<u32>>::Output

fn _add(self, rhs: u32) -> <Complex<f64> as NormalOut<u32>>::Output

fn _sub(self, rhs: u32) -> <Complex<f64> as NormalOut<u32>>::Output

fn _mul(self, rhs: u32) -> <Complex<f64> as NormalOut<u32>>::Output

fn _rem(self, rhs: u32) -> <Complex<f64> as NormalOut<u32>>::Output

fn _max(self, rhs: u32) -> <Complex<f64> as NormalOut<u32>>::Output

fn _min(self, rhs: u32) -> <Complex<f64> as NormalOut<u32>>::Output

impl NormalOut<u64> for bool

type Output = <bool as NormalOutPromote<u64>>::Output

fn _pow(self, rhs: u64) -> <bool as NormalOut<u64>>::Output

fn _clamp(self, min: u64, max: u64) -> <bool as NormalOut<u64>>::Output

fn _mul_add(self, a: u64, b: u64) -> <bool as NormalOut<u64>>::Output

fn _add(self, rhs: u64) -> <bool as NormalOut<u64>>::Output

fn _sub(self, rhs: u64) -> <bool as NormalOut<u64>>::Output

fn _mul(self, rhs: u64) -> <bool as NormalOut<u64>>::Output

fn _rem(self, rhs: u64) -> <bool as NormalOut<u64>>::Output

fn _max(self, rhs: u64) -> <bool as NormalOut<u64>>::Output

fn _min(self, rhs: u64) -> <bool as NormalOut<u64>>::Output

impl NormalOut<u64> for f32

type Output = <f32 as NormalOutPromote<u64>>::Output

fn _pow(self, rhs: u64) -> <f32 as NormalOut<u64>>::Output

fn _clamp(self, min: u64, max: u64) -> <f32 as NormalOut<u64>>::Output

fn _mul_add(self, a: u64, b: u64) -> <f32 as NormalOut<u64>>::Output

fn _add(self, rhs: u64) -> <f32 as NormalOut<u64>>::Output

fn _sub(self, rhs: u64) -> <f32 as NormalOut<u64>>::Output

fn _mul(self, rhs: u64) -> <f32 as NormalOut<u64>>::Output

fn _rem(self, rhs: u64) -> <f32 as NormalOut<u64>>::Output

fn _max(self, rhs: u64) -> <f32 as NormalOut<u64>>::Output

fn _min(self, rhs: u64) -> <f32 as NormalOut<u64>>::Output

impl NormalOut<u64> for f64

type Output = <f64 as NormalOutPromote<u64>>::Output

fn _pow(self, rhs: u64) -> <f64 as NormalOut<u64>>::Output

fn _clamp(self, min: u64, max: u64) -> <f64 as NormalOut<u64>>::Output

fn _mul_add(self, a: u64, b: u64) -> <f64 as NormalOut<u64>>::Output

fn _add(self, rhs: u64) -> <f64 as NormalOut<u64>>::Output

fn _sub(self, rhs: u64) -> <f64 as NormalOut<u64>>::Output

fn _mul(self, rhs: u64) -> <f64 as NormalOut<u64>>::Output

fn _rem(self, rhs: u64) -> <f64 as NormalOut<u64>>::Output

fn _max(self, rhs: u64) -> <f64 as NormalOut<u64>>::Output

fn _min(self, rhs: u64) -> <f64 as NormalOut<u64>>::Output

impl NormalOut<u64> for i8

type Output = <i8 as NormalOutPromote<u64>>::Output

fn _pow(self, rhs: u64) -> <i8 as NormalOut<u64>>::Output

fn _clamp(self, min: u64, max: u64) -> <i8 as NormalOut<u64>>::Output

fn _mul_add(self, a: u64, b: u64) -> <i8 as NormalOut<u64>>::Output

fn _add(self, rhs: u64) -> <i8 as NormalOut<u64>>::Output

fn _sub(self, rhs: u64) -> <i8 as NormalOut<u64>>::Output

fn _mul(self, rhs: u64) -> <i8 as NormalOut<u64>>::Output

fn _rem(self, rhs: u64) -> <i8 as NormalOut<u64>>::Output

fn _max(self, rhs: u64) -> <i8 as NormalOut<u64>>::Output

fn _min(self, rhs: u64) -> <i8 as NormalOut<u64>>::Output

impl NormalOut<u64> for i16

type Output = <i16 as NormalOutPromote<u64>>::Output

fn _pow(self, rhs: u64) -> <i16 as NormalOut<u64>>::Output

fn _clamp(self, min: u64, max: u64) -> <i16 as NormalOut<u64>>::Output

fn _mul_add(self, a: u64, b: u64) -> <i16 as NormalOut<u64>>::Output

fn _add(self, rhs: u64) -> <i16 as NormalOut<u64>>::Output

fn _sub(self, rhs: u64) -> <i16 as NormalOut<u64>>::Output

fn _mul(self, rhs: u64) -> <i16 as NormalOut<u64>>::Output

fn _rem(self, rhs: u64) -> <i16 as NormalOut<u64>>::Output

fn _max(self, rhs: u64) -> <i16 as NormalOut<u64>>::Output

fn _min(self, rhs: u64) -> <i16 as NormalOut<u64>>::Output

impl NormalOut<u64> for i32

type Output = <i32 as NormalOutPromote<u64>>::Output

fn _pow(self, rhs: u64) -> <i32 as NormalOut<u64>>::Output

fn _clamp(self, min: u64, max: u64) -> <i32 as NormalOut<u64>>::Output

fn _mul_add(self, a: u64, b: u64) -> <i32 as NormalOut<u64>>::Output

fn _add(self, rhs: u64) -> <i32 as NormalOut<u64>>::Output

fn _sub(self, rhs: u64) -> <i32 as NormalOut<u64>>::Output

fn _mul(self, rhs: u64) -> <i32 as NormalOut<u64>>::Output

fn _rem(self, rhs: u64) -> <i32 as NormalOut<u64>>::Output

fn _max(self, rhs: u64) -> <i32 as NormalOut<u64>>::Output

fn _min(self, rhs: u64) -> <i32 as NormalOut<u64>>::Output

impl NormalOut<u64> for i64

type Output = <i64 as NormalOutPromote<u64>>::Output

fn _pow(self, rhs: u64) -> <i64 as NormalOut<u64>>::Output

fn _clamp(self, min: u64, max: u64) -> <i64 as NormalOut<u64>>::Output

fn _mul_add(self, a: u64, b: u64) -> <i64 as NormalOut<u64>>::Output

fn _add(self, rhs: u64) -> <i64 as NormalOut<u64>>::Output

fn _sub(self, rhs: u64) -> <i64 as NormalOut<u64>>::Output

fn _mul(self, rhs: u64) -> <i64 as NormalOut<u64>>::Output

fn _rem(self, rhs: u64) -> <i64 as NormalOut<u64>>::Output

fn _max(self, rhs: u64) -> <i64 as NormalOut<u64>>::Output

fn _min(self, rhs: u64) -> <i64 as NormalOut<u64>>::Output

impl NormalOut<u64> for isize

type Output = <isize as NormalOutPromote<u64>>::Output

fn _pow(self, rhs: u64) -> <isize as NormalOut<u64>>::Output

fn _clamp(self, min: u64, max: u64) -> <isize as NormalOut<u64>>::Output

fn _mul_add(self, a: u64, b: u64) -> <isize as NormalOut<u64>>::Output

fn _add(self, rhs: u64) -> <isize as NormalOut<u64>>::Output

fn _sub(self, rhs: u64) -> <isize as NormalOut<u64>>::Output

fn _mul(self, rhs: u64) -> <isize as NormalOut<u64>>::Output

fn _rem(self, rhs: u64) -> <isize as NormalOut<u64>>::Output

fn _max(self, rhs: u64) -> <isize as NormalOut<u64>>::Output

fn _min(self, rhs: u64) -> <isize as NormalOut<u64>>::Output

impl NormalOut<u64> for u8

type Output = <u8 as NormalOutPromote<u64>>::Output

fn _pow(self, rhs: u64) -> <u8 as NormalOut<u64>>::Output

fn _clamp(self, min: u64, max: u64) -> <u8 as NormalOut<u64>>::Output

fn _mul_add(self, a: u64, b: u64) -> <u8 as NormalOut<u64>>::Output

fn _add(self, rhs: u64) -> <u8 as NormalOut<u64>>::Output

fn _sub(self, rhs: u64) -> <u8 as NormalOut<u64>>::Output

fn _mul(self, rhs: u64) -> <u8 as NormalOut<u64>>::Output

fn _rem(self, rhs: u64) -> <u8 as NormalOut<u64>>::Output

fn _max(self, rhs: u64) -> <u8 as NormalOut<u64>>::Output

fn _min(self, rhs: u64) -> <u8 as NormalOut<u64>>::Output

impl NormalOut<u64> for u16

type Output = <u16 as NormalOutPromote<u64>>::Output

fn _pow(self, rhs: u64) -> <u16 as NormalOut<u64>>::Output

fn _clamp(self, min: u64, max: u64) -> <u16 as NormalOut<u64>>::Output

fn _mul_add(self, a: u64, b: u64) -> <u16 as NormalOut<u64>>::Output

fn _add(self, rhs: u64) -> <u16 as NormalOut<u64>>::Output

fn _sub(self, rhs: u64) -> <u16 as NormalOut<u64>>::Output

fn _mul(self, rhs: u64) -> <u16 as NormalOut<u64>>::Output

fn _rem(self, rhs: u64) -> <u16 as NormalOut<u64>>::Output

fn _max(self, rhs: u64) -> <u16 as NormalOut<u64>>::Output

fn _min(self, rhs: u64) -> <u16 as NormalOut<u64>>::Output

impl NormalOut<u64> for u32

type Output = <u32 as NormalOutPromote<u64>>::Output

fn _pow(self, rhs: u64) -> <u32 as NormalOut<u64>>::Output

fn _clamp(self, min: u64, max: u64) -> <u32 as NormalOut<u64>>::Output

fn _mul_add(self, a: u64, b: u64) -> <u32 as NormalOut<u64>>::Output

fn _add(self, rhs: u64) -> <u32 as NormalOut<u64>>::Output

fn _sub(self, rhs: u64) -> <u32 as NormalOut<u64>>::Output

fn _mul(self, rhs: u64) -> <u32 as NormalOut<u64>>::Output

fn _rem(self, rhs: u64) -> <u32 as NormalOut<u64>>::Output

fn _max(self, rhs: u64) -> <u32 as NormalOut<u64>>::Output

fn _min(self, rhs: u64) -> <u32 as NormalOut<u64>>::Output

impl NormalOut<u64> for usize

type Output = <usize as NormalOutPromote<u64>>::Output

fn _pow(self, rhs: u64) -> <usize as NormalOut<u64>>::Output

fn _clamp(self, min: u64, max: u64) -> <usize as NormalOut<u64>>::Output

fn _mul_add(self, a: u64, b: u64) -> <usize as NormalOut<u64>>::Output

fn _add(self, rhs: u64) -> <usize as NormalOut<u64>>::Output

fn _sub(self, rhs: u64) -> <usize as NormalOut<u64>>::Output

fn _mul(self, rhs: u64) -> <usize as NormalOut<u64>>::Output

fn _rem(self, rhs: u64) -> <usize as NormalOut<u64>>::Output

fn _max(self, rhs: u64) -> <usize as NormalOut<u64>>::Output

fn _min(self, rhs: u64) -> <usize as NormalOut<u64>>::Output

impl NormalOut<u64> for bf16

type Output = <bf16 as NormalOutPromote<u64>>::Output

fn _pow(self, rhs: u64) -> <bf16 as NormalOut<u64>>::Output

fn _clamp(self, min: u64, max: u64) -> <bf16 as NormalOut<u64>>::Output

fn _mul_add(self, a: u64, b: u64) -> <bf16 as NormalOut<u64>>::Output

fn _add(self, rhs: u64) -> <bf16 as NormalOut<u64>>::Output

fn _sub(self, rhs: u64) -> <bf16 as NormalOut<u64>>::Output

fn _mul(self, rhs: u64) -> <bf16 as NormalOut<u64>>::Output

fn _rem(self, rhs: u64) -> <bf16 as NormalOut<u64>>::Output

fn _max(self, rhs: u64) -> <bf16 as NormalOut<u64>>::Output

fn _min(self, rhs: u64) -> <bf16 as NormalOut<u64>>::Output

impl NormalOut<u64> for f16

type Output = <f16 as NormalOutPromote<u64>>::Output

fn _pow(self, rhs: u64) -> <f16 as NormalOut<u64>>::Output

fn _clamp(self, min: u64, max: u64) -> <f16 as NormalOut<u64>>::Output

fn _mul_add(self, a: u64, b: u64) -> <f16 as NormalOut<u64>>::Output

fn _add(self, rhs: u64) -> <f16 as NormalOut<u64>>::Output

fn _sub(self, rhs: u64) -> <f16 as NormalOut<u64>>::Output

fn _mul(self, rhs: u64) -> <f16 as NormalOut<u64>>::Output

fn _rem(self, rhs: u64) -> <f16 as NormalOut<u64>>::Output

fn _max(self, rhs: u64) -> <f16 as NormalOut<u64>>::Output

fn _min(self, rhs: u64) -> <f16 as NormalOut<u64>>::Output

impl NormalOut<u64> for Complex<f32>

type Output = <Complex<f32> as NormalOutPromote<u64>>::Output

fn _pow(self, rhs: u64) -> <Complex<f32> as NormalOut<u64>>::Output

fn _clamp(self, min: u64, max: u64) -> <Complex<f32> as NormalOut<u64>>::Output

fn _mul_add(self, a: u64, b: u64) -> <Complex<f32> as NormalOut<u64>>::Output

fn _add(self, rhs: u64) -> <Complex<f32> as NormalOut<u64>>::Output

fn _sub(self, rhs: u64) -> <Complex<f32> as NormalOut<u64>>::Output

fn _mul(self, rhs: u64) -> <Complex<f32> as NormalOut<u64>>::Output

fn _rem(self, rhs: u64) -> <Complex<f32> as NormalOut<u64>>::Output

fn _max(self, rhs: u64) -> <Complex<f32> as NormalOut<u64>>::Output

fn _min(self, rhs: u64) -> <Complex<f32> as NormalOut<u64>>::Output

impl NormalOut<u64> for Complex<f64>

type Output = <Complex<f64> as NormalOutPromote<u64>>::Output

fn _pow(self, rhs: u64) -> <Complex<f64> as NormalOut<u64>>::Output

fn _clamp(self, min: u64, max: u64) -> <Complex<f64> as NormalOut<u64>>::Output

fn _mul_add(self, a: u64, b: u64) -> <Complex<f64> as NormalOut<u64>>::Output

fn _add(self, rhs: u64) -> <Complex<f64> as NormalOut<u64>>::Output

fn _sub(self, rhs: u64) -> <Complex<f64> as NormalOut<u64>>::Output

fn _mul(self, rhs: u64) -> <Complex<f64> as NormalOut<u64>>::Output

fn _rem(self, rhs: u64) -> <Complex<f64> as NormalOut<u64>>::Output

fn _max(self, rhs: u64) -> <Complex<f64> as NormalOut<u64>>::Output

fn _min(self, rhs: u64) -> <Complex<f64> as NormalOut<u64>>::Output

impl NormalOut<usize> for bool

type Output = <bool as NormalOutPromote<usize>>::Output

fn _pow(self, rhs: usize) -> <bool as NormalOut<usize>>::Output

fn _clamp(self, min: usize, max: usize) -> <bool as NormalOut<usize>>::Output

fn _mul_add(self, a: usize, b: usize) -> <bool as NormalOut<usize>>::Output

fn _add(self, rhs: usize) -> <bool as NormalOut<usize>>::Output

fn _sub(self, rhs: usize) -> <bool as NormalOut<usize>>::Output

fn _mul(self, rhs: usize) -> <bool as NormalOut<usize>>::Output

fn _rem(self, rhs: usize) -> <bool as NormalOut<usize>>::Output

fn _max(self, rhs: usize) -> <bool as NormalOut<usize>>::Output

fn _min(self, rhs: usize) -> <bool as NormalOut<usize>>::Output

impl NormalOut<usize> for f32

type Output = <f32 as NormalOutPromote<usize>>::Output

fn _pow(self, rhs: usize) -> <f32 as NormalOut<usize>>::Output

fn _clamp(self, min: usize, max: usize) -> <f32 as NormalOut<usize>>::Output

fn _mul_add(self, a: usize, b: usize) -> <f32 as NormalOut<usize>>::Output

fn _add(self, rhs: usize) -> <f32 as NormalOut<usize>>::Output

fn _sub(self, rhs: usize) -> <f32 as NormalOut<usize>>::Output

fn _mul(self, rhs: usize) -> <f32 as NormalOut<usize>>::Output

fn _rem(self, rhs: usize) -> <f32 as NormalOut<usize>>::Output

fn _max(self, rhs: usize) -> <f32 as NormalOut<usize>>::Output

fn _min(self, rhs: usize) -> <f32 as NormalOut<usize>>::Output

impl NormalOut<usize> for f64

type Output = <f64 as NormalOutPromote<usize>>::Output

fn _pow(self, rhs: usize) -> <f64 as NormalOut<usize>>::Output

fn _clamp(self, min: usize, max: usize) -> <f64 as NormalOut<usize>>::Output

fn _mul_add(self, a: usize, b: usize) -> <f64 as NormalOut<usize>>::Output

fn _add(self, rhs: usize) -> <f64 as NormalOut<usize>>::Output

fn _sub(self, rhs: usize) -> <f64 as NormalOut<usize>>::Output

fn _mul(self, rhs: usize) -> <f64 as NormalOut<usize>>::Output

fn _rem(self, rhs: usize) -> <f64 as NormalOut<usize>>::Output

fn _max(self, rhs: usize) -> <f64 as NormalOut<usize>>::Output

fn _min(self, rhs: usize) -> <f64 as NormalOut<usize>>::Output

impl NormalOut<usize> for i8

type Output = <i8 as NormalOutPromote<usize>>::Output

fn _pow(self, rhs: usize) -> <i8 as NormalOut<usize>>::Output

fn _clamp(self, min: usize, max: usize) -> <i8 as NormalOut<usize>>::Output

fn _mul_add(self, a: usize, b: usize) -> <i8 as NormalOut<usize>>::Output

fn _add(self, rhs: usize) -> <i8 as NormalOut<usize>>::Output

fn _sub(self, rhs: usize) -> <i8 as NormalOut<usize>>::Output

fn _mul(self, rhs: usize) -> <i8 as NormalOut<usize>>::Output

fn _rem(self, rhs: usize) -> <i8 as NormalOut<usize>>::Output

fn _max(self, rhs: usize) -> <i8 as NormalOut<usize>>::Output

fn _min(self, rhs: usize) -> <i8 as NormalOut<usize>>::Output

impl NormalOut<usize> for i16

type Output = <i16 as NormalOutPromote<usize>>::Output

fn _pow(self, rhs: usize) -> <i16 as NormalOut<usize>>::Output

fn _clamp(self, min: usize, max: usize) -> <i16 as NormalOut<usize>>::Output

fn _mul_add(self, a: usize, b: usize) -> <i16 as NormalOut<usize>>::Output

fn _add(self, rhs: usize) -> <i16 as NormalOut<usize>>::Output

fn _sub(self, rhs: usize) -> <i16 as NormalOut<usize>>::Output

fn _mul(self, rhs: usize) -> <i16 as NormalOut<usize>>::Output

fn _rem(self, rhs: usize) -> <i16 as NormalOut<usize>>::Output

fn _max(self, rhs: usize) -> <i16 as NormalOut<usize>>::Output

fn _min(self, rhs: usize) -> <i16 as NormalOut<usize>>::Output

impl NormalOut<usize> for i32

type Output = <i32 as NormalOutPromote<usize>>::Output

fn _pow(self, rhs: usize) -> <i32 as NormalOut<usize>>::Output

fn _clamp(self, min: usize, max: usize) -> <i32 as NormalOut<usize>>::Output

fn _mul_add(self, a: usize, b: usize) -> <i32 as NormalOut<usize>>::Output

fn _add(self, rhs: usize) -> <i32 as NormalOut<usize>>::Output

fn _sub(self, rhs: usize) -> <i32 as NormalOut<usize>>::Output

fn _mul(self, rhs: usize) -> <i32 as NormalOut<usize>>::Output

fn _rem(self, rhs: usize) -> <i32 as NormalOut<usize>>::Output

fn _max(self, rhs: usize) -> <i32 as NormalOut<usize>>::Output

fn _min(self, rhs: usize) -> <i32 as NormalOut<usize>>::Output

impl NormalOut<usize> for i64

type Output = <i64 as NormalOutPromote<usize>>::Output

fn _pow(self, rhs: usize) -> <i64 as NormalOut<usize>>::Output

fn _clamp(self, min: usize, max: usize) -> <i64 as NormalOut<usize>>::Output

fn _mul_add(self, a: usize, b: usize) -> <i64 as NormalOut<usize>>::Output

fn _add(self, rhs: usize) -> <i64 as NormalOut<usize>>::Output

fn _sub(self, rhs: usize) -> <i64 as NormalOut<usize>>::Output

fn _mul(self, rhs: usize) -> <i64 as NormalOut<usize>>::Output

fn _rem(self, rhs: usize) -> <i64 as NormalOut<usize>>::Output

fn _max(self, rhs: usize) -> <i64 as NormalOut<usize>>::Output

fn _min(self, rhs: usize) -> <i64 as NormalOut<usize>>::Output

impl NormalOut<usize> for isize

type Output = <isize as NormalOutPromote<usize>>::Output

fn _pow(self, rhs: usize) -> <isize as NormalOut<usize>>::Output

fn _clamp(self, min: usize, max: usize) -> <isize as NormalOut<usize>>::Output

fn _mul_add(self, a: usize, b: usize) -> <isize as NormalOut<usize>>::Output

fn _add(self, rhs: usize) -> <isize as NormalOut<usize>>::Output

fn _sub(self, rhs: usize) -> <isize as NormalOut<usize>>::Output

fn _mul(self, rhs: usize) -> <isize as NormalOut<usize>>::Output

fn _rem(self, rhs: usize) -> <isize as NormalOut<usize>>::Output

fn _max(self, rhs: usize) -> <isize as NormalOut<usize>>::Output

fn _min(self, rhs: usize) -> <isize as NormalOut<usize>>::Output

impl NormalOut<usize> for u8

type Output = <u8 as NormalOutPromote<usize>>::Output

fn _pow(self, rhs: usize) -> <u8 as NormalOut<usize>>::Output

fn _clamp(self, min: usize, max: usize) -> <u8 as NormalOut<usize>>::Output

fn _mul_add(self, a: usize, b: usize) -> <u8 as NormalOut<usize>>::Output

fn _add(self, rhs: usize) -> <u8 as NormalOut<usize>>::Output

fn _sub(self, rhs: usize) -> <u8 as NormalOut<usize>>::Output

fn _mul(self, rhs: usize) -> <u8 as NormalOut<usize>>::Output

fn _rem(self, rhs: usize) -> <u8 as NormalOut<usize>>::Output

fn _max(self, rhs: usize) -> <u8 as NormalOut<usize>>::Output

fn _min(self, rhs: usize) -> <u8 as NormalOut<usize>>::Output

impl NormalOut<usize> for u16

type Output = <u16 as NormalOutPromote<usize>>::Output

fn _pow(self, rhs: usize) -> <u16 as NormalOut<usize>>::Output

fn _clamp(self, min: usize, max: usize) -> <u16 as NormalOut<usize>>::Output

fn _mul_add(self, a: usize, b: usize) -> <u16 as NormalOut<usize>>::Output

fn _add(self, rhs: usize) -> <u16 as NormalOut<usize>>::Output

fn _sub(self, rhs: usize) -> <u16 as NormalOut<usize>>::Output

fn _mul(self, rhs: usize) -> <u16 as NormalOut<usize>>::Output

fn _rem(self, rhs: usize) -> <u16 as NormalOut<usize>>::Output

fn _max(self, rhs: usize) -> <u16 as NormalOut<usize>>::Output

fn _min(self, rhs: usize) -> <u16 as NormalOut<usize>>::Output

impl NormalOut<usize> for u32

type Output = <u32 as NormalOutPromote<usize>>::Output

fn _pow(self, rhs: usize) -> <u32 as NormalOut<usize>>::Output

fn _clamp(self, min: usize, max: usize) -> <u32 as NormalOut<usize>>::Output

fn _mul_add(self, a: usize, b: usize) -> <u32 as NormalOut<usize>>::Output

fn _add(self, rhs: usize) -> <u32 as NormalOut<usize>>::Output

fn _sub(self, rhs: usize) -> <u32 as NormalOut<usize>>::Output

fn _mul(self, rhs: usize) -> <u32 as NormalOut<usize>>::Output

fn _rem(self, rhs: usize) -> <u32 as NormalOut<usize>>::Output

fn _max(self, rhs: usize) -> <u32 as NormalOut<usize>>::Output

fn _min(self, rhs: usize) -> <u32 as NormalOut<usize>>::Output

impl NormalOut<usize> for u64

type Output = <u64 as NormalOutPromote<usize>>::Output

fn _pow(self, rhs: usize) -> <u64 as NormalOut<usize>>::Output

fn _clamp(self, min: usize, max: usize) -> <u64 as NormalOut<usize>>::Output

fn _mul_add(self, a: usize, b: usize) -> <u64 as NormalOut<usize>>::Output

fn _add(self, rhs: usize) -> <u64 as NormalOut<usize>>::Output

fn _sub(self, rhs: usize) -> <u64 as NormalOut<usize>>::Output

fn _mul(self, rhs: usize) -> <u64 as NormalOut<usize>>::Output

fn _rem(self, rhs: usize) -> <u64 as NormalOut<usize>>::Output

fn _max(self, rhs: usize) -> <u64 as NormalOut<usize>>::Output

fn _min(self, rhs: usize) -> <u64 as NormalOut<usize>>::Output

impl NormalOut<usize> for bf16

type Output = <bf16 as NormalOutPromote<usize>>::Output

fn _pow(self, rhs: usize) -> <bf16 as NormalOut<usize>>::Output

fn _clamp(self, min: usize, max: usize) -> <bf16 as NormalOut<usize>>::Output

fn _mul_add(self, a: usize, b: usize) -> <bf16 as NormalOut<usize>>::Output

fn _add(self, rhs: usize) -> <bf16 as NormalOut<usize>>::Output

fn _sub(self, rhs: usize) -> <bf16 as NormalOut<usize>>::Output

fn _mul(self, rhs: usize) -> <bf16 as NormalOut<usize>>::Output

fn _rem(self, rhs: usize) -> <bf16 as NormalOut<usize>>::Output

fn _max(self, rhs: usize) -> <bf16 as NormalOut<usize>>::Output

fn _min(self, rhs: usize) -> <bf16 as NormalOut<usize>>::Output

impl NormalOut<usize> for f16

type Output = <f16 as NormalOutPromote<usize>>::Output

fn _pow(self, rhs: usize) -> <f16 as NormalOut<usize>>::Output

fn _clamp(self, min: usize, max: usize) -> <f16 as NormalOut<usize>>::Output

fn _mul_add(self, a: usize, b: usize) -> <f16 as NormalOut<usize>>::Output

fn _add(self, rhs: usize) -> <f16 as NormalOut<usize>>::Output

fn _sub(self, rhs: usize) -> <f16 as NormalOut<usize>>::Output

fn _mul(self, rhs: usize) -> <f16 as NormalOut<usize>>::Output

fn _rem(self, rhs: usize) -> <f16 as NormalOut<usize>>::Output

fn _max(self, rhs: usize) -> <f16 as NormalOut<usize>>::Output

fn _min(self, rhs: usize) -> <f16 as NormalOut<usize>>::Output

impl NormalOut<usize> for Complex<f32>

type Output = <Complex<f32> as NormalOutPromote<usize>>::Output

fn _pow(self, rhs: usize) -> <Complex<f32> as NormalOut<usize>>::Output

fn _clamp( self, min: usize, max: usize, ) -> <Complex<f32> as NormalOut<usize>>::Output

fn _mul_add( self, a: usize, b: usize, ) -> <Complex<f32> as NormalOut<usize>>::Output

fn _add(self, rhs: usize) -> <Complex<f32> as NormalOut<usize>>::Output

fn _sub(self, rhs: usize) -> <Complex<f32> as NormalOut<usize>>::Output

fn _mul(self, rhs: usize) -> <Complex<f32> as NormalOut<usize>>::Output

fn _rem(self, rhs: usize) -> <Complex<f32> as NormalOut<usize>>::Output

fn _max(self, rhs: usize) -> <Complex<f32> as NormalOut<usize>>::Output

fn _min(self, rhs: usize) -> <Complex<f32> as NormalOut<usize>>::Output

impl NormalOut<usize> for Complex<f64>

type Output = <Complex<f64> as NormalOutPromote<usize>>::Output

fn _pow(self, rhs: usize) -> <Complex<f64> as NormalOut<usize>>::Output

fn _clamp( self, min: usize, max: usize, ) -> <Complex<f64> as NormalOut<usize>>::Output

fn _mul_add( self, a: usize, b: usize, ) -> <Complex<f64> as NormalOut<usize>>::Output

fn _add(self, rhs: usize) -> <Complex<f64> as NormalOut<usize>>::Output

fn _sub(self, rhs: usize) -> <Complex<f64> as NormalOut<usize>>::Output

fn _mul(self, rhs: usize) -> <Complex<f64> as NormalOut<usize>>::Output

fn _rem(self, rhs: usize) -> <Complex<f64> as NormalOut<usize>>::Output

fn _max(self, rhs: usize) -> <Complex<f64> as NormalOut<usize>>::Output

fn _min(self, rhs: usize) -> <Complex<f64> as NormalOut<usize>>::Output

impl NormalOut<bf16x8> for bool

type Output = <boolx16 as NormalOutPromote<bf16x8>>::Output

fn _mul_add(self, a: bf16x8, b: bf16x8) -> <bool as NormalOut<bf16x8>>::Output

fn _add(self, rhs: bf16x8) -> <bool as NormalOut<bf16x8>>::Output

fn _sub(self, rhs: bf16x8) -> <bool as NormalOut<bf16x8>>::Output

fn _mul(self, rhs: bf16x8) -> <bool as NormalOut<bf16x8>>::Output

fn _pow(self, rhs: bf16x8) -> <bool as NormalOut<bf16x8>>::Output

fn _rem(self, rhs: bf16x8) -> <bool as NormalOut<bf16x8>>::Output

fn _clamp(self, min: bf16x8, max: bf16x8) -> <bool as NormalOut<bf16x8>>::Output

fn _max(self, rhs: bf16x8) -> <bool as NormalOut<bf16x8>>::Output

fn _min(self, rhs: bf16x8) -> <bool as NormalOut<bf16x8>>::Output

impl NormalOut<bf16x8> for f32

type Output = <f32x4 as NormalOutPromote<bf16x8>>::Output

fn _mul_add(self, a: bf16x8, b: bf16x8) -> <f32 as NormalOut<bf16x8>>::Output

fn _add(self, rhs: bf16x8) -> <f32 as NormalOut<bf16x8>>::Output

fn _sub(self, rhs: bf16x8) -> <f32 as NormalOut<bf16x8>>::Output

fn _mul(self, rhs: bf16x8) -> <f32 as NormalOut<bf16x8>>::Output

fn _pow(self, rhs: bf16x8) -> <f32 as NormalOut<bf16x8>>::Output

fn _rem(self, rhs: bf16x8) -> <f32 as NormalOut<bf16x8>>::Output

fn _clamp(self, min: bf16x8, max: bf16x8) -> <f32 as NormalOut<bf16x8>>::Output

fn _max(self, rhs: bf16x8) -> <f32 as NormalOut<bf16x8>>::Output

fn _min(self, rhs: bf16x8) -> <f32 as NormalOut<bf16x8>>::Output

impl NormalOut<bf16x8> for f64

type Output = <f64x2 as NormalOutPromote<bf16x8>>::Output

fn _mul_add(self, a: bf16x8, b: bf16x8) -> <f64 as NormalOut<bf16x8>>::Output

fn _add(self, rhs: bf16x8) -> <f64 as NormalOut<bf16x8>>::Output

fn _sub(self, rhs: bf16x8) -> <f64 as NormalOut<bf16x8>>::Output

fn _mul(self, rhs: bf16x8) -> <f64 as NormalOut<bf16x8>>::Output

fn _pow(self, rhs: bf16x8) -> <f64 as NormalOut<bf16x8>>::Output

fn _rem(self, rhs: bf16x8) -> <f64 as NormalOut<bf16x8>>::Output

fn _clamp(self, min: bf16x8, max: bf16x8) -> <f64 as NormalOut<bf16x8>>::Output

fn _max(self, rhs: bf16x8) -> <f64 as NormalOut<bf16x8>>::Output

fn _min(self, rhs: bf16x8) -> <f64 as NormalOut<bf16x8>>::Output

impl NormalOut<bf16x8> for i8

type Output = <i8x16 as NormalOutPromote<bf16x8>>::Output

fn _mul_add(self, a: bf16x8, b: bf16x8) -> <i8 as NormalOut<bf16x8>>::Output

fn _add(self, rhs: bf16x8) -> <i8 as NormalOut<bf16x8>>::Output

fn _sub(self, rhs: bf16x8) -> <i8 as NormalOut<bf16x8>>::Output

fn _mul(self, rhs: bf16x8) -> <i8 as NormalOut<bf16x8>>::Output

fn _pow(self, rhs: bf16x8) -> <i8 as NormalOut<bf16x8>>::Output

fn _rem(self, rhs: bf16x8) -> <i8 as NormalOut<bf16x8>>::Output

fn _clamp(self, min: bf16x8, max: bf16x8) -> <i8 as NormalOut<bf16x8>>::Output

fn _max(self, rhs: bf16x8) -> <i8 as NormalOut<bf16x8>>::Output

fn _min(self, rhs: bf16x8) -> <i8 as NormalOut<bf16x8>>::Output

impl NormalOut<bf16x8> for i16

type Output = <i16x8 as NormalOutPromote<bf16x8>>::Output

fn _add(self, rhs: bf16x8) -> <i16 as NormalOut<bf16x8>>::Output

fn _sub(self, rhs: bf16x8) -> <i16 as NormalOut<bf16x8>>::Output

fn _mul(self, rhs: bf16x8) -> <i16 as NormalOut<bf16x8>>::Output

fn _pow(self, rhs: bf16x8) -> <i16 as NormalOut<bf16x8>>::Output

fn _max(self, rhs: bf16x8) -> <i16 as NormalOut<bf16x8>>::Output

fn _min(self, rhs: bf16x8) -> <i16 as NormalOut<bf16x8>>::Output

fn _rem(self, rhs: bf16x8) -> <i16 as NormalOut<bf16x8>>::Output

fn _clamp(self, min: bf16x8, max: bf16x8) -> <i16 as NormalOut<bf16x8>>::Output

fn _mul_add(self, a: bf16x8, b: bf16x8) -> <i16 as NormalOut<bf16x8>>::Output

impl NormalOut<bf16x8> for i32

type Output = <i32x4 as NormalOutPromote<bf16x8>>::Output

fn _mul_add(self, a: bf16x8, b: bf16x8) -> <i32 as NormalOut<bf16x8>>::Output

fn _add(self, rhs: bf16x8) -> <i32 as NormalOut<bf16x8>>::Output

fn _sub(self, rhs: bf16x8) -> <i32 as NormalOut<bf16x8>>::Output

fn _mul(self, rhs: bf16x8) -> <i32 as NormalOut<bf16x8>>::Output

fn _pow(self, rhs: bf16x8) -> <i32 as NormalOut<bf16x8>>::Output

fn _rem(self, rhs: bf16x8) -> <i32 as NormalOut<bf16x8>>::Output

fn _clamp(self, min: bf16x8, max: bf16x8) -> <i32 as NormalOut<bf16x8>>::Output

fn _max(self, rhs: bf16x8) -> <i32 as NormalOut<bf16x8>>::Output

fn _min(self, rhs: bf16x8) -> <i32 as NormalOut<bf16x8>>::Output

impl NormalOut<bf16x8> for i64

type Output = <i64x2 as NormalOutPromote<bf16x8>>::Output

fn _mul_add(self, a: bf16x8, b: bf16x8) -> <i64 as NormalOut<bf16x8>>::Output

fn _add(self, rhs: bf16x8) -> <i64 as NormalOut<bf16x8>>::Output

fn _sub(self, rhs: bf16x8) -> <i64 as NormalOut<bf16x8>>::Output

fn _mul(self, rhs: bf16x8) -> <i64 as NormalOut<bf16x8>>::Output

fn _pow(self, rhs: bf16x8) -> <i64 as NormalOut<bf16x8>>::Output

fn _rem(self, rhs: bf16x8) -> <i64 as NormalOut<bf16x8>>::Output

fn _clamp(self, min: bf16x8, max: bf16x8) -> <i64 as NormalOut<bf16x8>>::Output

fn _max(self, rhs: bf16x8) -> <i64 as NormalOut<bf16x8>>::Output

fn _min(self, rhs: bf16x8) -> <i64 as NormalOut<bf16x8>>::Output

impl NormalOut<bf16x8> for isize

type Output = <isizex2 as NormalOutPromote<bf16x8>>::Output

fn _mul_add(self, a: bf16x8, b: bf16x8) -> <isize as NormalOut<bf16x8>>::Output

fn _add(self, rhs: bf16x8) -> <isize as NormalOut<bf16x8>>::Output

fn _sub(self, rhs: bf16x8) -> <isize as NormalOut<bf16x8>>::Output

fn _mul(self, rhs: bf16x8) -> <isize as NormalOut<bf16x8>>::Output

fn _pow(self, rhs: bf16x8) -> <isize as NormalOut<bf16x8>>::Output

fn _rem(self, rhs: bf16x8) -> <isize as NormalOut<bf16x8>>::Output

fn _clamp( self, min: bf16x8, max: bf16x8, ) -> <isize as NormalOut<bf16x8>>::Output

fn _max(self, rhs: bf16x8) -> <isize as NormalOut<bf16x8>>::Output

fn _min(self, rhs: bf16x8) -> <isize as NormalOut<bf16x8>>::Output

impl NormalOut<bf16x8> for u8

type Output = <u8x16 as NormalOutPromote<bf16x8>>::Output

fn _mul_add(self, a: bf16x8, b: bf16x8) -> <u8 as NormalOut<bf16x8>>::Output

fn _add(self, rhs: bf16x8) -> <u8 as NormalOut<bf16x8>>::Output

fn _sub(self, rhs: bf16x8) -> <u8 as NormalOut<bf16x8>>::Output

fn _mul(self, rhs: bf16x8) -> <u8 as NormalOut<bf16x8>>::Output

fn _pow(self, rhs: bf16x8) -> <u8 as NormalOut<bf16x8>>::Output

fn _rem(self, rhs: bf16x8) -> <u8 as NormalOut<bf16x8>>::Output

fn _clamp(self, min: bf16x8, max: bf16x8) -> <u8 as NormalOut<bf16x8>>::Output

fn _max(self, rhs: bf16x8) -> <u8 as NormalOut<bf16x8>>::Output

fn _min(self, rhs: bf16x8) -> <u8 as NormalOut<bf16x8>>::Output

impl NormalOut<bf16x8> for u16

type Output = <u16x8 as NormalOutPromote<bf16x8>>::Output

fn _add(self, rhs: bf16x8) -> <u16 as NormalOut<bf16x8>>::Output

fn _sub(self, rhs: bf16x8) -> <u16 as NormalOut<bf16x8>>::Output

fn _mul(self, rhs: bf16x8) -> <u16 as NormalOut<bf16x8>>::Output

fn _pow(self, rhs: bf16x8) -> <u16 as NormalOut<bf16x8>>::Output

fn _max(self, rhs: bf16x8) -> <u16 as NormalOut<bf16x8>>::Output

fn _min(self, rhs: bf16x8) -> <u16 as NormalOut<bf16x8>>::Output

fn _rem(self, rhs: bf16x8) -> <u16 as NormalOut<bf16x8>>::Output

fn _clamp(self, min: bf16x8, max: bf16x8) -> <u16 as NormalOut<bf16x8>>::Output

fn _mul_add(self, a: bf16x8, b: bf16x8) -> <u16 as NormalOut<bf16x8>>::Output

impl NormalOut<bf16x8> for u32

type Output = <u32x4 as NormalOutPromote<bf16x8>>::Output

fn _mul_add(self, a: bf16x8, b: bf16x8) -> <u32 as NormalOut<bf16x8>>::Output

fn _add(self, rhs: bf16x8) -> <u32 as NormalOut<bf16x8>>::Output

fn _sub(self, rhs: bf16x8) -> <u32 as NormalOut<bf16x8>>::Output

fn _mul(self, rhs: bf16x8) -> <u32 as NormalOut<bf16x8>>::Output

fn _pow(self, rhs: bf16x8) -> <u32 as NormalOut<bf16x8>>::Output

fn _rem(self, rhs: bf16x8) -> <u32 as NormalOut<bf16x8>>::Output

fn _clamp(self, min: bf16x8, max: bf16x8) -> <u32 as NormalOut<bf16x8>>::Output

fn _max(self, rhs: bf16x8) -> <u32 as NormalOut<bf16x8>>::Output

fn _min(self, rhs: bf16x8) -> <u32 as NormalOut<bf16x8>>::Output

impl NormalOut<bf16x8> for u64

type Output = <u64x2 as NormalOutPromote<bf16x8>>::Output

fn _mul_add(self, a: bf16x8, b: bf16x8) -> <u64 as NormalOut<bf16x8>>::Output

fn _add(self, rhs: bf16x8) -> <u64 as NormalOut<bf16x8>>::Output

fn _sub(self, rhs: bf16x8) -> <u64 as NormalOut<bf16x8>>::Output

fn _mul(self, rhs: bf16x8) -> <u64 as NormalOut<bf16x8>>::Output

fn _pow(self, rhs: bf16x8) -> <u64 as NormalOut<bf16x8>>::Output

fn _rem(self, rhs: bf16x8) -> <u64 as NormalOut<bf16x8>>::Output

fn _clamp(self, min: bf16x8, max: bf16x8) -> <u64 as NormalOut<bf16x8>>::Output

fn _max(self, rhs: bf16x8) -> <u64 as NormalOut<bf16x8>>::Output

fn _min(self, rhs: bf16x8) -> <u64 as NormalOut<bf16x8>>::Output

impl NormalOut<bf16x8> for usize

type Output = <usizex2 as NormalOutPromote<bf16x8>>::Output

fn _mul_add(self, a: bf16x8, b: bf16x8) -> <usize as NormalOut<bf16x8>>::Output

fn _add(self, rhs: bf16x8) -> <usize as NormalOut<bf16x8>>::Output

fn _sub(self, rhs: bf16x8) -> <usize as NormalOut<bf16x8>>::Output

fn _mul(self, rhs: bf16x8) -> <usize as NormalOut<bf16x8>>::Output

fn _pow(self, rhs: bf16x8) -> <usize as NormalOut<bf16x8>>::Output

fn _rem(self, rhs: bf16x8) -> <usize as NormalOut<bf16x8>>::Output

fn _clamp( self, min: bf16x8, max: bf16x8, ) -> <usize as NormalOut<bf16x8>>::Output

fn _max(self, rhs: bf16x8) -> <usize as NormalOut<bf16x8>>::Output

fn _min(self, rhs: bf16x8) -> <usize as NormalOut<bf16x8>>::Output

impl NormalOut<bf16x8> for bf16

type Output = <bf16x8 as NormalOutPromote>::Output

fn _add(self, rhs: bf16x8) -> <bf16 as NormalOut<bf16x8>>::Output

fn _sub(self, rhs: bf16x8) -> <bf16 as NormalOut<bf16x8>>::Output

fn _mul(self, rhs: bf16x8) -> <bf16 as NormalOut<bf16x8>>::Output

fn _pow(self, rhs: bf16x8) -> <bf16 as NormalOut<bf16x8>>::Output

fn _max(self, rhs: bf16x8) -> <bf16 as NormalOut<bf16x8>>::Output

fn _min(self, rhs: bf16x8) -> <bf16 as NormalOut<bf16x8>>::Output

fn _rem(self, rhs: bf16x8) -> <bf16 as NormalOut<bf16x8>>::Output

fn _clamp(self, min: bf16x8, max: bf16x8) -> <bf16 as NormalOut<bf16x8>>::Output

fn _mul_add(self, a: bf16x8, b: bf16x8) -> <bf16 as NormalOut<bf16x8>>::Output

impl NormalOut<bf16x8> for f16

type Output = <f16x8 as NormalOutPromote<bf16x8>>::Output

fn _add(self, rhs: bf16x8) -> <f16 as NormalOut<bf16x8>>::Output

fn _sub(self, rhs: bf16x8) -> <f16 as NormalOut<bf16x8>>::Output

fn _mul(self, rhs: bf16x8) -> <f16 as NormalOut<bf16x8>>::Output

fn _pow(self, rhs: bf16x8) -> <f16 as NormalOut<bf16x8>>::Output

fn _max(self, rhs: bf16x8) -> <f16 as NormalOut<bf16x8>>::Output

fn _min(self, rhs: bf16x8) -> <f16 as NormalOut<bf16x8>>::Output

fn _rem(self, rhs: bf16x8) -> <f16 as NormalOut<bf16x8>>::Output

fn _clamp(self, min: bf16x8, max: bf16x8) -> <f16 as NormalOut<bf16x8>>::Output

fn _mul_add(self, a: bf16x8, b: bf16x8) -> <f16 as NormalOut<bf16x8>>::Output

impl NormalOut<bf16x8> for Complex<f32>

type Output = <cplx32x2 as NormalOutPromote<bf16x8>>::Output

fn _mul_add( self, a: bf16x8, b: bf16x8, ) -> <Complex<f32> as NormalOut<bf16x8>>::Output

fn _add(self, rhs: bf16x8) -> <Complex<f32> as NormalOut<bf16x8>>::Output

fn _sub(self, rhs: bf16x8) -> <Complex<f32> as NormalOut<bf16x8>>::Output

fn _mul(self, rhs: bf16x8) -> <Complex<f32> as NormalOut<bf16x8>>::Output

fn _pow(self, rhs: bf16x8) -> <Complex<f32> as NormalOut<bf16x8>>::Output

fn _rem(self, rhs: bf16x8) -> <Complex<f32> as NormalOut<bf16x8>>::Output

fn _clamp( self, min: bf16x8, max: bf16x8, ) -> <Complex<f32> as NormalOut<bf16x8>>::Output

fn _max(self, rhs: bf16x8) -> <Complex<f32> as NormalOut<bf16x8>>::Output

fn _min(self, rhs: bf16x8) -> <Complex<f32> as NormalOut<bf16x8>>::Output

impl NormalOut<bf16x8> for Complex<f64>

type Output = <cplx64x1 as NormalOutPromote<bf16x8>>::Output

fn _mul_add( self, a: bf16x8, b: bf16x8, ) -> <Complex<f64> as NormalOut<bf16x8>>::Output

fn _add(self, rhs: bf16x8) -> <Complex<f64> as NormalOut<bf16x8>>::Output

fn _sub(self, rhs: bf16x8) -> <Complex<f64> as NormalOut<bf16x8>>::Output

fn _mul(self, rhs: bf16x8) -> <Complex<f64> as NormalOut<bf16x8>>::Output

fn _pow(self, rhs: bf16x8) -> <Complex<f64> as NormalOut<bf16x8>>::Output

fn _rem(self, rhs: bf16x8) -> <Complex<f64> as NormalOut<bf16x8>>::Output

fn _clamp( self, min: bf16x8, max: bf16x8, ) -> <Complex<f64> as NormalOut<bf16x8>>::Output

fn _max(self, rhs: bf16x8) -> <Complex<f64> as NormalOut<bf16x8>>::Output

fn _min(self, rhs: bf16x8) -> <Complex<f64> as NormalOut<bf16x8>>::Output

impl NormalOut<boolx16> for bool

type Output = <boolx16 as NormalOutPromote>::Output

fn _add(self, rhs: boolx16) -> <bool as NormalOut<boolx16>>::Output

fn _sub(self, rhs: boolx16) -> <bool as NormalOut<boolx16>>::Output

fn _mul(self, rhs: boolx16) -> <bool as NormalOut<boolx16>>::Output

fn _pow(self, rhs: boolx16) -> <bool as NormalOut<boolx16>>::Output

fn _max(self, rhs: boolx16) -> <bool as NormalOut<boolx16>>::Output

fn _min(self, rhs: boolx16) -> <bool as NormalOut<boolx16>>::Output

fn _rem(self, rhs: boolx16) -> <bool as NormalOut<boolx16>>::Output

fn _clamp( self, min: boolx16, max: boolx16, ) -> <bool as NormalOut<boolx16>>::Output

fn _mul_add( self, a: boolx16, b: boolx16, ) -> <bool as NormalOut<boolx16>>::Output

impl NormalOut<boolx16> for f32

type Output = <f32x4 as NormalOutPromote<boolx16>>::Output

fn _mul_add(self, a: boolx16, b: boolx16) -> <f32 as NormalOut<boolx16>>::Output

fn _add(self, rhs: boolx16) -> <f32 as NormalOut<boolx16>>::Output

fn _sub(self, rhs: boolx16) -> <f32 as NormalOut<boolx16>>::Output

fn _mul(self, rhs: boolx16) -> <f32 as NormalOut<boolx16>>::Output

fn _pow(self, rhs: boolx16) -> <f32 as NormalOut<boolx16>>::Output

fn _rem(self, rhs: boolx16) -> <f32 as NormalOut<boolx16>>::Output

fn _clamp( self, min: boolx16, max: boolx16, ) -> <f32 as NormalOut<boolx16>>::Output

fn _max(self, rhs: boolx16) -> <f32 as NormalOut<boolx16>>::Output

fn _min(self, rhs: boolx16) -> <f32 as NormalOut<boolx16>>::Output

impl NormalOut<boolx16> for f64

type Output = <f64x2 as NormalOutPromote<boolx16>>::Output

fn _mul_add(self, a: boolx16, b: boolx16) -> <f64 as NormalOut<boolx16>>::Output

fn _add(self, rhs: boolx16) -> <f64 as NormalOut<boolx16>>::Output

fn _sub(self, rhs: boolx16) -> <f64 as NormalOut<boolx16>>::Output

fn _mul(self, rhs: boolx16) -> <f64 as NormalOut<boolx16>>::Output

fn _pow(self, rhs: boolx16) -> <f64 as NormalOut<boolx16>>::Output

fn _rem(self, rhs: boolx16) -> <f64 as NormalOut<boolx16>>::Output

fn _clamp( self, min: boolx16, max: boolx16, ) -> <f64 as NormalOut<boolx16>>::Output

fn _max(self, rhs: boolx16) -> <f64 as NormalOut<boolx16>>::Output

fn _min(self, rhs: boolx16) -> <f64 as NormalOut<boolx16>>::Output

impl NormalOut<boolx16> for i8

type Output = <i8x16 as NormalOutPromote<boolx16>>::Output

fn _add(self, rhs: boolx16) -> <i8 as NormalOut<boolx16>>::Output

fn _sub(self, rhs: boolx16) -> <i8 as NormalOut<boolx16>>::Output

fn _mul(self, rhs: boolx16) -> <i8 as NormalOut<boolx16>>::Output

fn _pow(self, rhs: boolx16) -> <i8 as NormalOut<boolx16>>::Output

fn _max(self, rhs: boolx16) -> <i8 as NormalOut<boolx16>>::Output

fn _min(self, rhs: boolx16) -> <i8 as NormalOut<boolx16>>::Output

fn _rem(self, rhs: boolx16) -> <i8 as NormalOut<boolx16>>::Output

fn _clamp( self, min: boolx16, max: boolx16, ) -> <i8 as NormalOut<boolx16>>::Output

fn _mul_add(self, a: boolx16, b: boolx16) -> <i8 as NormalOut<boolx16>>::Output

impl NormalOut<boolx16> for i16

type Output = <i16x8 as NormalOutPromote<boolx16>>::Output

fn _mul_add(self, a: boolx16, b: boolx16) -> <i16 as NormalOut<boolx16>>::Output

fn _add(self, rhs: boolx16) -> <i16 as NormalOut<boolx16>>::Output

fn _sub(self, rhs: boolx16) -> <i16 as NormalOut<boolx16>>::Output

fn _mul(self, rhs: boolx16) -> <i16 as NormalOut<boolx16>>::Output

fn _pow(self, rhs: boolx16) -> <i16 as NormalOut<boolx16>>::Output

fn _rem(self, rhs: boolx16) -> <i16 as NormalOut<boolx16>>::Output

fn _clamp( self, min: boolx16, max: boolx16, ) -> <i16 as NormalOut<boolx16>>::Output

fn _max(self, rhs: boolx16) -> <i16 as NormalOut<boolx16>>::Output

fn _min(self, rhs: boolx16) -> <i16 as NormalOut<boolx16>>::Output

impl NormalOut<boolx16> for i32

type Output = <i32x4 as NormalOutPromote<boolx16>>::Output

fn _mul_add(self, a: boolx16, b: boolx16) -> <i32 as NormalOut<boolx16>>::Output

fn _add(self, rhs: boolx16) -> <i32 as NormalOut<boolx16>>::Output

fn _sub(self, rhs: boolx16) -> <i32 as NormalOut<boolx16>>::Output

fn _mul(self, rhs: boolx16) -> <i32 as NormalOut<boolx16>>::Output

fn _pow(self, rhs: boolx16) -> <i32 as NormalOut<boolx16>>::Output

fn _rem(self, rhs: boolx16) -> <i32 as NormalOut<boolx16>>::Output

fn _clamp( self, min: boolx16, max: boolx16, ) -> <i32 as NormalOut<boolx16>>::Output

fn _max(self, rhs: boolx16) -> <i32 as NormalOut<boolx16>>::Output

fn _min(self, rhs: boolx16) -> <i32 as NormalOut<boolx16>>::Output

impl NormalOut<boolx16> for i64

type Output = <i64x2 as NormalOutPromote<boolx16>>::Output

fn _mul_add(self, a: boolx16, b: boolx16) -> <i64 as NormalOut<boolx16>>::Output

fn _add(self, rhs: boolx16) -> <i64 as NormalOut<boolx16>>::Output

fn _sub(self, rhs: boolx16) -> <i64 as NormalOut<boolx16>>::Output

fn _mul(self, rhs: boolx16) -> <i64 as NormalOut<boolx16>>::Output

fn _pow(self, rhs: boolx16) -> <i64 as NormalOut<boolx16>>::Output

fn _rem(self, rhs: boolx16) -> <i64 as NormalOut<boolx16>>::Output

fn _clamp( self, min: boolx16, max: boolx16, ) -> <i64 as NormalOut<boolx16>>::Output

fn _max(self, rhs: boolx16) -> <i64 as NormalOut<boolx16>>::Output

fn _min(self, rhs: boolx16) -> <i64 as NormalOut<boolx16>>::Output

impl NormalOut<boolx16> for isize

type Output = <isizex2 as NormalOutPromote<boolx16>>::Output

fn _mul_add( self, a: boolx16, b: boolx16, ) -> <isize as NormalOut<boolx16>>::Output

fn _add(self, rhs: boolx16) -> <isize as NormalOut<boolx16>>::Output

fn _sub(self, rhs: boolx16) -> <isize as NormalOut<boolx16>>::Output

fn _mul(self, rhs: boolx16) -> <isize as NormalOut<boolx16>>::Output

fn _pow(self, rhs: boolx16) -> <isize as NormalOut<boolx16>>::Output

fn _rem(self, rhs: boolx16) -> <isize as NormalOut<boolx16>>::Output

fn _clamp( self, min: boolx16, max: boolx16, ) -> <isize as NormalOut<boolx16>>::Output

fn _max(self, rhs: boolx16) -> <isize as NormalOut<boolx16>>::Output

fn _min(self, rhs: boolx16) -> <isize as NormalOut<boolx16>>::Output

impl NormalOut<boolx16> for u8

type Output = <u8x16 as NormalOutPromote<boolx16>>::Output

fn _add(self, rhs: boolx16) -> <u8 as NormalOut<boolx16>>::Output

fn _sub(self, rhs: boolx16) -> <u8 as NormalOut<boolx16>>::Output

fn _mul(self, rhs: boolx16) -> <u8 as NormalOut<boolx16>>::Output

fn _pow(self, rhs: boolx16) -> <u8 as NormalOut<boolx16>>::Output

fn _max(self, rhs: boolx16) -> <u8 as NormalOut<boolx16>>::Output

fn _min(self, rhs: boolx16) -> <u8 as NormalOut<boolx16>>::Output

fn _rem(self, rhs: boolx16) -> <u8 as NormalOut<boolx16>>::Output

fn _clamp( self, min: boolx16, max: boolx16, ) -> <u8 as NormalOut<boolx16>>::Output

fn _mul_add(self, a: boolx16, b: boolx16) -> <u8 as NormalOut<boolx16>>::Output

impl NormalOut<boolx16> for u16

type Output = <u16x8 as NormalOutPromote<boolx16>>::Output

fn _mul_add(self, a: boolx16, b: boolx16) -> <u16 as NormalOut<boolx16>>::Output

fn _add(self, rhs: boolx16) -> <u16 as NormalOut<boolx16>>::Output

fn _sub(self, rhs: boolx16) -> <u16 as NormalOut<boolx16>>::Output

fn _mul(self, rhs: boolx16) -> <u16 as NormalOut<boolx16>>::Output

fn _pow(self, rhs: boolx16) -> <u16 as NormalOut<boolx16>>::Output

fn _rem(self, rhs: boolx16) -> <u16 as NormalOut<boolx16>>::Output

fn _clamp( self, min: boolx16, max: boolx16, ) -> <u16 as NormalOut<boolx16>>::Output

fn _max(self, rhs: boolx16) -> <u16 as NormalOut<boolx16>>::Output

fn _min(self, rhs: boolx16) -> <u16 as NormalOut<boolx16>>::Output

impl NormalOut<boolx16> for u32

type Output = <u32x4 as NormalOutPromote<boolx16>>::Output

fn _mul_add(self, a: boolx16, b: boolx16) -> <u32 as NormalOut<boolx16>>::Output

fn _add(self, rhs: boolx16) -> <u32 as NormalOut<boolx16>>::Output

fn _sub(self, rhs: boolx16) -> <u32 as NormalOut<boolx16>>::Output

fn _mul(self, rhs: boolx16) -> <u32 as NormalOut<boolx16>>::Output

fn _pow(self, rhs: boolx16) -> <u32 as NormalOut<boolx16>>::Output

fn _rem(self, rhs: boolx16) -> <u32 as NormalOut<boolx16>>::Output

fn _clamp( self, min: boolx16, max: boolx16, ) -> <u32 as NormalOut<boolx16>>::Output

fn _max(self, rhs: boolx16) -> <u32 as NormalOut<boolx16>>::Output

fn _min(self, rhs: boolx16) -> <u32 as NormalOut<boolx16>>::Output

impl NormalOut<boolx16> for u64

type Output = <u64x2 as NormalOutPromote<boolx16>>::Output

fn _mul_add(self, a: boolx16, b: boolx16) -> <u64 as NormalOut<boolx16>>::Output

fn _add(self, rhs: boolx16) -> <u64 as NormalOut<boolx16>>::Output

fn _sub(self, rhs: boolx16) -> <u64 as NormalOut<boolx16>>::Output

fn _mul(self, rhs: boolx16) -> <u64 as NormalOut<boolx16>>::Output

fn _pow(self, rhs: boolx16) -> <u64 as NormalOut<boolx16>>::Output

fn _rem(self, rhs: boolx16) -> <u64 as NormalOut<boolx16>>::Output

fn _clamp( self, min: boolx16, max: boolx16, ) -> <u64 as NormalOut<boolx16>>::Output

fn _max(self, rhs: boolx16) -> <u64 as NormalOut<boolx16>>::Output

fn _min(self, rhs: boolx16) -> <u64 as NormalOut<boolx16>>::Output

impl NormalOut<boolx16> for usize

type Output = <usizex2 as NormalOutPromote<boolx16>>::Output

fn _mul_add( self, a: boolx16, b: boolx16, ) -> <usize as NormalOut<boolx16>>::Output

fn _add(self, rhs: boolx16) -> <usize as NormalOut<boolx16>>::Output

fn _sub(self, rhs: boolx16) -> <usize as NormalOut<boolx16>>::Output

fn _mul(self, rhs: boolx16) -> <usize as NormalOut<boolx16>>::Output

fn _pow(self, rhs: boolx16) -> <usize as NormalOut<boolx16>>::Output

fn _rem(self, rhs: boolx16) -> <usize as NormalOut<boolx16>>::Output

fn _clamp( self, min: boolx16, max: boolx16, ) -> <usize as NormalOut<boolx16>>::Output

fn _max(self, rhs: boolx16) -> <usize as NormalOut<boolx16>>::Output

fn _min(self, rhs: boolx16) -> <usize as NormalOut<boolx16>>::Output

impl NormalOut<boolx16> for bf16

type Output = <bf16x8 as NormalOutPromote<boolx16>>::Output

fn _mul_add( self, a: boolx16, b: boolx16, ) -> <bf16 as NormalOut<boolx16>>::Output

fn _add(self, rhs: boolx16) -> <bf16 as NormalOut<boolx16>>::Output

fn _sub(self, rhs: boolx16) -> <bf16 as NormalOut<boolx16>>::Output

fn _mul(self, rhs: boolx16) -> <bf16 as NormalOut<boolx16>>::Output

fn _pow(self, rhs: boolx16) -> <bf16 as NormalOut<boolx16>>::Output

fn _rem(self, rhs: boolx16) -> <bf16 as NormalOut<boolx16>>::Output

fn _clamp( self, min: boolx16, max: boolx16, ) -> <bf16 as NormalOut<boolx16>>::Output

fn _max(self, rhs: boolx16) -> <bf16 as NormalOut<boolx16>>::Output

fn _min(self, rhs: boolx16) -> <bf16 as NormalOut<boolx16>>::Output

impl NormalOut<boolx16> for f16

type Output = <f16x8 as NormalOutPromote<boolx16>>::Output

fn _mul_add(self, a: boolx16, b: boolx16) -> <f16 as NormalOut<boolx16>>::Output

fn _add(self, rhs: boolx16) -> <f16 as NormalOut<boolx16>>::Output

fn _sub(self, rhs: boolx16) -> <f16 as NormalOut<boolx16>>::Output

fn _mul(self, rhs: boolx16) -> <f16 as NormalOut<boolx16>>::Output

fn _pow(self, rhs: boolx16) -> <f16 as NormalOut<boolx16>>::Output

fn _rem(self, rhs: boolx16) -> <f16 as NormalOut<boolx16>>::Output

fn _clamp( self, min: boolx16, max: boolx16, ) -> <f16 as NormalOut<boolx16>>::Output

fn _max(self, rhs: boolx16) -> <f16 as NormalOut<boolx16>>::Output

fn _min(self, rhs: boolx16) -> <f16 as NormalOut<boolx16>>::Output

impl NormalOut<boolx16> for Complex<f32>

type Output = <cplx32x2 as NormalOutPromote<boolx16>>::Output

fn _mul_add( self, a: boolx16, b: boolx16, ) -> <Complex<f32> as NormalOut<boolx16>>::Output

fn _add(self, rhs: boolx16) -> <Complex<f32> as NormalOut<boolx16>>::Output

fn _sub(self, rhs: boolx16) -> <Complex<f32> as NormalOut<boolx16>>::Output

fn _mul(self, rhs: boolx16) -> <Complex<f32> as NormalOut<boolx16>>::Output

fn _pow(self, rhs: boolx16) -> <Complex<f32> as NormalOut<boolx16>>::Output

fn _rem(self, rhs: boolx16) -> <Complex<f32> as NormalOut<boolx16>>::Output

fn _clamp( self, min: boolx16, max: boolx16, ) -> <Complex<f32> as NormalOut<boolx16>>::Output

fn _max(self, rhs: boolx16) -> <Complex<f32> as NormalOut<boolx16>>::Output

fn _min(self, rhs: boolx16) -> <Complex<f32> as NormalOut<boolx16>>::Output

impl NormalOut<boolx16> for Complex<f64>

type Output = <cplx64x1 as NormalOutPromote<boolx16>>::Output

fn _mul_add( self, a: boolx16, b: boolx16, ) -> <Complex<f64> as NormalOut<boolx16>>::Output

fn _add(self, rhs: boolx16) -> <Complex<f64> as NormalOut<boolx16>>::Output

fn _sub(self, rhs: boolx16) -> <Complex<f64> as NormalOut<boolx16>>::Output

fn _mul(self, rhs: boolx16) -> <Complex<f64> as NormalOut<boolx16>>::Output

fn _pow(self, rhs: boolx16) -> <Complex<f64> as NormalOut<boolx16>>::Output

fn _rem(self, rhs: boolx16) -> <Complex<f64> as NormalOut<boolx16>>::Output

fn _clamp( self, min: boolx16, max: boolx16, ) -> <Complex<f64> as NormalOut<boolx16>>::Output

fn _max(self, rhs: boolx16) -> <Complex<f64> as NormalOut<boolx16>>::Output

fn _min(self, rhs: boolx16) -> <Complex<f64> as NormalOut<boolx16>>::Output

impl NormalOut<cplx32x2> for bool

type Output = <boolx16 as NormalOutPromote<cplx32x2>>::Output

fn _mul_add( self, a: cplx32x2, b: cplx32x2, ) -> <bool as NormalOut<cplx32x2>>::Output

fn _add(self, rhs: cplx32x2) -> <bool as NormalOut<cplx32x2>>::Output

fn _sub(self, rhs: cplx32x2) -> <bool as NormalOut<cplx32x2>>::Output

fn _mul(self, rhs: cplx32x2) -> <bool as NormalOut<cplx32x2>>::Output

fn _pow(self, rhs: cplx32x2) -> <bool as NormalOut<cplx32x2>>::Output

fn _rem(self, rhs: cplx32x2) -> <bool as NormalOut<cplx32x2>>::Output

fn _clamp( self, min: cplx32x2, max: cplx32x2, ) -> <bool as NormalOut<cplx32x2>>::Output

fn _max(self, rhs: cplx32x2) -> <bool as NormalOut<cplx32x2>>::Output

fn _min(self, rhs: cplx32x2) -> <bool as NormalOut<cplx32x2>>::Output

impl NormalOut<cplx32x2> for f32

type Output = <f32x4 as NormalOutPromote<cplx32x2>>::Output

fn _mul_add( self, a: cplx32x2, b: cplx32x2, ) -> <f32 as NormalOut<cplx32x2>>::Output

fn _add(self, rhs: cplx32x2) -> <f32 as NormalOut<cplx32x2>>::Output

fn _sub(self, rhs: cplx32x2) -> <f32 as NormalOut<cplx32x2>>::Output

fn _mul(self, rhs: cplx32x2) -> <f32 as NormalOut<cplx32x2>>::Output

fn _pow(self, rhs: cplx32x2) -> <f32 as NormalOut<cplx32x2>>::Output

fn _rem(self, rhs: cplx32x2) -> <f32 as NormalOut<cplx32x2>>::Output

fn _clamp( self, min: cplx32x2, max: cplx32x2, ) -> <f32 as NormalOut<cplx32x2>>::Output

fn _max(self, rhs: cplx32x2) -> <f32 as NormalOut<cplx32x2>>::Output

fn _min(self, rhs: cplx32x2) -> <f32 as NormalOut<cplx32x2>>::Output

impl NormalOut<cplx32x2> for f64

type Output = <f64x2 as NormalOutPromote<cplx32x2>>::Output

fn _add(self, rhs: cplx32x2) -> <f64 as NormalOut<cplx32x2>>::Output

fn _sub(self, rhs: cplx32x2) -> <f64 as NormalOut<cplx32x2>>::Output

fn _mul(self, rhs: cplx32x2) -> <f64 as NormalOut<cplx32x2>>::Output

fn _pow(self, rhs: cplx32x2) -> <f64 as NormalOut<cplx32x2>>::Output

fn _max(self, rhs: cplx32x2) -> <f64 as NormalOut<cplx32x2>>::Output

fn _min(self, rhs: cplx32x2) -> <f64 as NormalOut<cplx32x2>>::Output

fn _rem(self, rhs: cplx32x2) -> <f64 as NormalOut<cplx32x2>>::Output

fn _clamp( self, min: cplx32x2, max: cplx32x2, ) -> <f64 as NormalOut<cplx32x2>>::Output

fn _mul_add( self, a: cplx32x2, b: cplx32x2, ) -> <f64 as NormalOut<cplx32x2>>::Output

impl NormalOut<cplx32x2> for i8

type Output = <i8x16 as NormalOutPromote<cplx32x2>>::Output

fn _mul_add( self, a: cplx32x2, b: cplx32x2, ) -> <i8 as NormalOut<cplx32x2>>::Output

fn _add(self, rhs: cplx32x2) -> <i8 as NormalOut<cplx32x2>>::Output

fn _sub(self, rhs: cplx32x2) -> <i8 as NormalOut<cplx32x2>>::Output

fn _mul(self, rhs: cplx32x2) -> <i8 as NormalOut<cplx32x2>>::Output

fn _pow(self, rhs: cplx32x2) -> <i8 as NormalOut<cplx32x2>>::Output

fn _rem(self, rhs: cplx32x2) -> <i8 as NormalOut<cplx32x2>>::Output

fn _clamp( self, min: cplx32x2, max: cplx32x2, ) -> <i8 as NormalOut<cplx32x2>>::Output

fn _max(self, rhs: cplx32x2) -> <i8 as NormalOut<cplx32x2>>::Output

fn _min(self, rhs: cplx32x2) -> <i8 as NormalOut<cplx32x2>>::Output

impl NormalOut<cplx32x2> for i16

type Output = <i16x8 as NormalOutPromote<cplx32x2>>::Output

fn _mul_add( self, a: cplx32x2, b: cplx32x2, ) -> <i16 as NormalOut<cplx32x2>>::Output

fn _add(self, rhs: cplx32x2) -> <i16 as NormalOut<cplx32x2>>::Output

fn _sub(self, rhs: cplx32x2) -> <i16 as NormalOut<cplx32x2>>::Output

fn _mul(self, rhs: cplx32x2) -> <i16 as NormalOut<cplx32x2>>::Output

fn _pow(self, rhs: cplx32x2) -> <i16 as NormalOut<cplx32x2>>::Output

fn _rem(self, rhs: cplx32x2) -> <i16 as NormalOut<cplx32x2>>::Output

fn _clamp( self, min: cplx32x2, max: cplx32x2, ) -> <i16 as NormalOut<cplx32x2>>::Output

fn _max(self, rhs: cplx32x2) -> <i16 as NormalOut<cplx32x2>>::Output

fn _min(self, rhs: cplx32x2) -> <i16 as NormalOut<cplx32x2>>::Output

impl NormalOut<cplx32x2> for i32

type Output = <i32x4 as NormalOutPromote<cplx32x2>>::Output

fn _mul_add( self, a: cplx32x2, b: cplx32x2, ) -> <i32 as NormalOut<cplx32x2>>::Output

fn _add(self, rhs: cplx32x2) -> <i32 as NormalOut<cplx32x2>>::Output

fn _sub(self, rhs: cplx32x2) -> <i32 as NormalOut<cplx32x2>>::Output

fn _mul(self, rhs: cplx32x2) -> <i32 as NormalOut<cplx32x2>>::Output

fn _pow(self, rhs: cplx32x2) -> <i32 as NormalOut<cplx32x2>>::Output

fn _rem(self, rhs: cplx32x2) -> <i32 as NormalOut<cplx32x2>>::Output

fn _clamp( self, min: cplx32x2, max: cplx32x2, ) -> <i32 as NormalOut<cplx32x2>>::Output

fn _max(self, rhs: cplx32x2) -> <i32 as NormalOut<cplx32x2>>::Output

fn _min(self, rhs: cplx32x2) -> <i32 as NormalOut<cplx32x2>>::Output

impl NormalOut<cplx32x2> for i64

type Output = <i64x2 as NormalOutPromote<cplx32x2>>::Output

fn _add(self, rhs: cplx32x2) -> <i64 as NormalOut<cplx32x2>>::Output

fn _sub(self, rhs: cplx32x2) -> <i64 as NormalOut<cplx32x2>>::Output

fn _mul(self, rhs: cplx32x2) -> <i64 as NormalOut<cplx32x2>>::Output

fn _pow(self, rhs: cplx32x2) -> <i64 as NormalOut<cplx32x2>>::Output

fn _max(self, rhs: cplx32x2) -> <i64 as NormalOut<cplx32x2>>::Output

fn _min(self, rhs: cplx32x2) -> <i64 as NormalOut<cplx32x2>>::Output

fn _rem(self, rhs: cplx32x2) -> <i64 as NormalOut<cplx32x2>>::Output

fn _clamp( self, min: cplx32x2, max: cplx32x2, ) -> <i64 as NormalOut<cplx32x2>>::Output

fn _mul_add( self, a: cplx32x2, b: cplx32x2, ) -> <i64 as NormalOut<cplx32x2>>::Output

impl NormalOut<cplx32x2> for isize

type Output = <isizex2 as NormalOutPromote<cplx32x2>>::Output

fn _add(self, rhs: cplx32x2) -> <isize as NormalOut<cplx32x2>>::Output

fn _sub(self, rhs: cplx32x2) -> <isize as NormalOut<cplx32x2>>::Output

fn _mul(self, rhs: cplx32x2) -> <isize as NormalOut<cplx32x2>>::Output

fn _pow(self, rhs: cplx32x2) -> <isize as NormalOut<cplx32x2>>::Output

fn _max(self, rhs: cplx32x2) -> <isize as NormalOut<cplx32x2>>::Output

fn _min(self, rhs: cplx32x2) -> <isize as NormalOut<cplx32x2>>::Output

fn _rem(self, rhs: cplx32x2) -> <isize as NormalOut<cplx32x2>>::Output

fn _clamp( self, min: cplx32x2, max: cplx32x2, ) -> <isize as NormalOut<cplx32x2>>::Output

fn _mul_add( self, a: cplx32x2, b: cplx32x2, ) -> <isize as NormalOut<cplx32x2>>::Output

impl NormalOut<cplx32x2> for u8

type Output = <u8x16 as NormalOutPromote<cplx32x2>>::Output

fn _mul_add( self, a: cplx32x2, b: cplx32x2, ) -> <u8 as NormalOut<cplx32x2>>::Output

fn _add(self, rhs: cplx32x2) -> <u8 as NormalOut<cplx32x2>>::Output

fn _sub(self, rhs: cplx32x2) -> <u8 as NormalOut<cplx32x2>>::Output

fn _mul(self, rhs: cplx32x2) -> <u8 as NormalOut<cplx32x2>>::Output

fn _pow(self, rhs: cplx32x2) -> <u8 as NormalOut<cplx32x2>>::Output

fn _rem(self, rhs: cplx32x2) -> <u8 as NormalOut<cplx32x2>>::Output

fn _clamp( self, min: cplx32x2, max: cplx32x2, ) -> <u8 as NormalOut<cplx32x2>>::Output

fn _max(self, rhs: cplx32x2) -> <u8 as NormalOut<cplx32x2>>::Output

fn _min(self, rhs: cplx32x2) -> <u8 as NormalOut<cplx32x2>>::Output

impl NormalOut<cplx32x2> for u16

type Output = <u16x8 as NormalOutPromote<cplx32x2>>::Output

fn _mul_add( self, a: cplx32x2, b: cplx32x2, ) -> <u16 as NormalOut<cplx32x2>>::Output

fn _add(self, rhs: cplx32x2) -> <u16 as NormalOut<cplx32x2>>::Output

fn _sub(self, rhs: cplx32x2) -> <u16 as NormalOut<cplx32x2>>::Output

fn _mul(self, rhs: cplx32x2) -> <u16 as NormalOut<cplx32x2>>::Output

fn _pow(self, rhs: cplx32x2) -> <u16 as NormalOut<cplx32x2>>::Output

fn _rem(self, rhs: cplx32x2) -> <u16 as NormalOut<cplx32x2>>::Output

fn _clamp( self, min: cplx32x2, max: cplx32x2, ) -> <u16 as NormalOut<cplx32x2>>::Output

fn _max(self, rhs: cplx32x2) -> <u16 as NormalOut<cplx32x2>>::Output

fn _min(self, rhs: cplx32x2) -> <u16 as NormalOut<cplx32x2>>::Output

impl NormalOut<cplx32x2> for u32

type Output = <u32x4 as NormalOutPromote<cplx32x2>>::Output

fn _mul_add( self, a: cplx32x2, b: cplx32x2, ) -> <u32 as NormalOut<cplx32x2>>::Output

fn _add(self, rhs: cplx32x2) -> <u32 as NormalOut<cplx32x2>>::Output

fn _sub(self, rhs: cplx32x2) -> <u32 as NormalOut<cplx32x2>>::Output

fn _mul(self, rhs: cplx32x2) -> <u32 as NormalOut<cplx32x2>>::Output

fn _pow(self, rhs: cplx32x2) -> <u32 as NormalOut<cplx32x2>>::Output

fn _rem(self, rhs: cplx32x2) -> <u32 as NormalOut<cplx32x2>>::Output

fn _clamp( self, min: cplx32x2, max: cplx32x2, ) -> <u32 as NormalOut<cplx32x2>>::Output

fn _max(self, rhs: cplx32x2) -> <u32 as NormalOut<cplx32x2>>::Output

fn _min(self, rhs: cplx32x2) -> <u32 as NormalOut<cplx32x2>>::Output

impl NormalOut<cplx32x2> for u64

type Output = <u64x2 as NormalOutPromote<cplx32x2>>::Output

fn _add(self, rhs: cplx32x2) -> <u64 as NormalOut<cplx32x2>>::Output

fn _sub(self, rhs: cplx32x2) -> <u64 as NormalOut<cplx32x2>>::Output

fn _mul(self, rhs: cplx32x2) -> <u64 as NormalOut<cplx32x2>>::Output

fn _pow(self, rhs: cplx32x2) -> <u64 as NormalOut<cplx32x2>>::Output

fn _max(self, rhs: cplx32x2) -> <u64 as NormalOut<cplx32x2>>::Output

fn _min(self, rhs: cplx32x2) -> <u64 as NormalOut<cplx32x2>>::Output

fn _rem(self, rhs: cplx32x2) -> <u64 as NormalOut<cplx32x2>>::Output

fn _clamp( self, min: cplx32x2, max: cplx32x2, ) -> <u64 as NormalOut<cplx32x2>>::Output

fn _mul_add( self, a: cplx32x2, b: cplx32x2, ) -> <u64 as NormalOut<cplx32x2>>::Output

impl NormalOut<cplx32x2> for usize

type Output = <usizex2 as NormalOutPromote<cplx32x2>>::Output

fn _add(self, rhs: cplx32x2) -> <usize as NormalOut<cplx32x2>>::Output

fn _sub(self, rhs: cplx32x2) -> <usize as NormalOut<cplx32x2>>::Output

fn _mul(self, rhs: cplx32x2) -> <usize as NormalOut<cplx32x2>>::Output

fn _pow(self, rhs: cplx32x2) -> <usize as NormalOut<cplx32x2>>::Output

fn _max(self, rhs: cplx32x2) -> <usize as NormalOut<cplx32x2>>::Output

fn _min(self, rhs: cplx32x2) -> <usize as NormalOut<cplx32x2>>::Output

fn _rem(self, rhs: cplx32x2) -> <usize as NormalOut<cplx32x2>>::Output

fn _clamp( self, min: cplx32x2, max: cplx32x2, ) -> <usize as NormalOut<cplx32x2>>::Output

fn _mul_add( self, a: cplx32x2, b: cplx32x2, ) -> <usize as NormalOut<cplx32x2>>::Output

impl NormalOut<cplx32x2> for bf16

type Output = <bf16x8 as NormalOutPromote<cplx32x2>>::Output

fn _mul_add( self, a: cplx32x2, b: cplx32x2, ) -> <bf16 as NormalOut<cplx32x2>>::Output

fn _add(self, rhs: cplx32x2) -> <bf16 as NormalOut<cplx32x2>>::Output

fn _sub(self, rhs: cplx32x2) -> <bf16 as NormalOut<cplx32x2>>::Output

fn _mul(self, rhs: cplx32x2) -> <bf16 as NormalOut<cplx32x2>>::Output

fn _pow(self, rhs: cplx32x2) -> <bf16 as NormalOut<cplx32x2>>::Output

fn _rem(self, rhs: cplx32x2) -> <bf16 as NormalOut<cplx32x2>>::Output

fn _clamp( self, min: cplx32x2, max: cplx32x2, ) -> <bf16 as NormalOut<cplx32x2>>::Output

fn _max(self, rhs: cplx32x2) -> <bf16 as NormalOut<cplx32x2>>::Output

fn _min(self, rhs: cplx32x2) -> <bf16 as NormalOut<cplx32x2>>::Output

impl NormalOut<cplx32x2> for f16

type Output = <f16x8 as NormalOutPromote<cplx32x2>>::Output

fn _mul_add( self, a: cplx32x2, b: cplx32x2, ) -> <f16 as NormalOut<cplx32x2>>::Output

fn _add(self, rhs: cplx32x2) -> <f16 as NormalOut<cplx32x2>>::Output

fn _sub(self, rhs: cplx32x2) -> <f16 as NormalOut<cplx32x2>>::Output

fn _mul(self, rhs: cplx32x2) -> <f16 as NormalOut<cplx32x2>>::Output

fn _pow(self, rhs: cplx32x2) -> <f16 as NormalOut<cplx32x2>>::Output

fn _rem(self, rhs: cplx32x2) -> <f16 as NormalOut<cplx32x2>>::Output

fn _clamp( self, min: cplx32x2, max: cplx32x2, ) -> <f16 as NormalOut<cplx32x2>>::Output

fn _max(self, rhs: cplx32x2) -> <f16 as NormalOut<cplx32x2>>::Output

fn _min(self, rhs: cplx32x2) -> <f16 as NormalOut<cplx32x2>>::Output

impl NormalOut<cplx32x2> for Complex<f32>

type Output = <cplx32x2 as NormalOutPromote>::Output

fn _add(self, rhs: cplx32x2) -> <Complex<f32> as NormalOut<cplx32x2>>::Output

fn _sub(self, rhs: cplx32x2) -> <Complex<f32> as NormalOut<cplx32x2>>::Output

fn _mul(self, rhs: cplx32x2) -> <Complex<f32> as NormalOut<cplx32x2>>::Output

fn _pow(self, rhs: cplx32x2) -> <Complex<f32> as NormalOut<cplx32x2>>::Output

fn _max(self, rhs: cplx32x2) -> <Complex<f32> as NormalOut<cplx32x2>>::Output

fn _min(self, rhs: cplx32x2) -> <Complex<f32> as NormalOut<cplx32x2>>::Output

fn _rem(self, rhs: cplx32x2) -> <Complex<f32> as NormalOut<cplx32x2>>::Output

fn _clamp( self, min: cplx32x2, max: cplx32x2, ) -> <Complex<f32> as NormalOut<cplx32x2>>::Output

fn _mul_add( self, a: cplx32x2, b: cplx32x2, ) -> <Complex<f32> as NormalOut<cplx32x2>>::Output

impl NormalOut<cplx32x2> for Complex<f64>

type Output = <cplx64x1 as NormalOutPromote<cplx32x2>>::Output

fn _mul_add( self, a: cplx32x2, b: cplx32x2, ) -> <Complex<f64> as NormalOut<cplx32x2>>::Output

fn _add(self, rhs: cplx32x2) -> <Complex<f64> as NormalOut<cplx32x2>>::Output

fn _sub(self, rhs: cplx32x2) -> <Complex<f64> as NormalOut<cplx32x2>>::Output

fn _mul(self, rhs: cplx32x2) -> <Complex<f64> as NormalOut<cplx32x2>>::Output

fn _pow(self, rhs: cplx32x2) -> <Complex<f64> as NormalOut<cplx32x2>>::Output

fn _rem(self, rhs: cplx32x2) -> <Complex<f64> as NormalOut<cplx32x2>>::Output

fn _clamp( self, min: cplx32x2, max: cplx32x2, ) -> <Complex<f64> as NormalOut<cplx32x2>>::Output

fn _max(self, rhs: cplx32x2) -> <Complex<f64> as NormalOut<cplx32x2>>::Output

fn _min(self, rhs: cplx32x2) -> <Complex<f64> as NormalOut<cplx32x2>>::Output

impl NormalOut<cplx64x1> for bool

type Output = <boolx16 as NormalOutPromote<cplx64x1>>::Output

fn _mul_add( self, a: cplx64x1, b: cplx64x1, ) -> <bool as NormalOut<cplx64x1>>::Output

fn _add(self, rhs: cplx64x1) -> <bool as NormalOut<cplx64x1>>::Output

fn _sub(self, rhs: cplx64x1) -> <bool as NormalOut<cplx64x1>>::Output

fn _mul(self, rhs: cplx64x1) -> <bool as NormalOut<cplx64x1>>::Output

fn _pow(self, rhs: cplx64x1) -> <bool as NormalOut<cplx64x1>>::Output

fn _rem(self, rhs: cplx64x1) -> <bool as NormalOut<cplx64x1>>::Output

fn _clamp( self, min: cplx64x1, max: cplx64x1, ) -> <bool as NormalOut<cplx64x1>>::Output

fn _max(self, rhs: cplx64x1) -> <bool as NormalOut<cplx64x1>>::Output

fn _min(self, rhs: cplx64x1) -> <bool as NormalOut<cplx64x1>>::Output

impl NormalOut<cplx64x1> for f32

type Output = <f32x4 as NormalOutPromote<cplx64x1>>::Output

fn _mul_add( self, a: cplx64x1, b: cplx64x1, ) -> <f32 as NormalOut<cplx64x1>>::Output

fn _add(self, rhs: cplx64x1) -> <f32 as NormalOut<cplx64x1>>::Output

fn _sub(self, rhs: cplx64x1) -> <f32 as NormalOut<cplx64x1>>::Output

fn _mul(self, rhs: cplx64x1) -> <f32 as NormalOut<cplx64x1>>::Output

fn _pow(self, rhs: cplx64x1) -> <f32 as NormalOut<cplx64x1>>::Output

fn _rem(self, rhs: cplx64x1) -> <f32 as NormalOut<cplx64x1>>::Output

fn _clamp( self, min: cplx64x1, max: cplx64x1, ) -> <f32 as NormalOut<cplx64x1>>::Output

fn _max(self, rhs: cplx64x1) -> <f32 as NormalOut<cplx64x1>>::Output

fn _min(self, rhs: cplx64x1) -> <f32 as NormalOut<cplx64x1>>::Output

impl NormalOut<cplx64x1> for f64

type Output = <f64x2 as NormalOutPromote<cplx64x1>>::Output

fn _mul_add( self, a: cplx64x1, b: cplx64x1, ) -> <f64 as NormalOut<cplx64x1>>::Output

fn _add(self, rhs: cplx64x1) -> <f64 as NormalOut<cplx64x1>>::Output

fn _sub(self, rhs: cplx64x1) -> <f64 as NormalOut<cplx64x1>>::Output

fn _mul(self, rhs: cplx64x1) -> <f64 as NormalOut<cplx64x1>>::Output

fn _pow(self, rhs: cplx64x1) -> <f64 as NormalOut<cplx64x1>>::Output

fn _rem(self, rhs: cplx64x1) -> <f64 as NormalOut<cplx64x1>>::Output

fn _clamp( self, min: cplx64x1, max: cplx64x1, ) -> <f64 as NormalOut<cplx64x1>>::Output

fn _max(self, rhs: cplx64x1) -> <f64 as NormalOut<cplx64x1>>::Output

fn _min(self, rhs: cplx64x1) -> <f64 as NormalOut<cplx64x1>>::Output

impl NormalOut<cplx64x1> for i8

type Output = <i8x16 as NormalOutPromote<cplx64x1>>::Output

fn _mul_add( self, a: cplx64x1, b: cplx64x1, ) -> <i8 as NormalOut<cplx64x1>>::Output

fn _add(self, rhs: cplx64x1) -> <i8 as NormalOut<cplx64x1>>::Output

fn _sub(self, rhs: cplx64x1) -> <i8 as NormalOut<cplx64x1>>::Output

fn _mul(self, rhs: cplx64x1) -> <i8 as NormalOut<cplx64x1>>::Output

fn _pow(self, rhs: cplx64x1) -> <i8 as NormalOut<cplx64x1>>::Output

fn _rem(self, rhs: cplx64x1) -> <i8 as NormalOut<cplx64x1>>::Output

fn _clamp( self, min: cplx64x1, max: cplx64x1, ) -> <i8 as NormalOut<cplx64x1>>::Output

fn _max(self, rhs: cplx64x1) -> <i8 as NormalOut<cplx64x1>>::Output

fn _min(self, rhs: cplx64x1) -> <i8 as NormalOut<cplx64x1>>::Output

impl NormalOut<cplx64x1> for i16

type Output = <i16x8 as NormalOutPromote<cplx64x1>>::Output

fn _mul_add( self, a: cplx64x1, b: cplx64x1, ) -> <i16 as NormalOut<cplx64x1>>::Output

fn _add(self, rhs: cplx64x1) -> <i16 as NormalOut<cplx64x1>>::Output

fn _sub(self, rhs: cplx64x1) -> <i16 as NormalOut<cplx64x1>>::Output

fn _mul(self, rhs: cplx64x1) -> <i16 as NormalOut<cplx64x1>>::Output

fn _pow(self, rhs: cplx64x1) -> <i16 as NormalOut<cplx64x1>>::Output

fn _rem(self, rhs: cplx64x1) -> <i16 as NormalOut<cplx64x1>>::Output

fn _clamp( self, min: cplx64x1, max: cplx64x1, ) -> <i16 as NormalOut<cplx64x1>>::Output

fn _max(self, rhs: cplx64x1) -> <i16 as NormalOut<cplx64x1>>::Output

fn _min(self, rhs: cplx64x1) -> <i16 as NormalOut<cplx64x1>>::Output

impl NormalOut<cplx64x1> for i32

type Output = <i32x4 as NormalOutPromote<cplx64x1>>::Output

fn _mul_add( self, a: cplx64x1, b: cplx64x1, ) -> <i32 as NormalOut<cplx64x1>>::Output

fn _add(self, rhs: cplx64x1) -> <i32 as NormalOut<cplx64x1>>::Output

fn _sub(self, rhs: cplx64x1) -> <i32 as NormalOut<cplx64x1>>::Output

fn _mul(self, rhs: cplx64x1) -> <i32 as NormalOut<cplx64x1>>::Output

fn _pow(self, rhs: cplx64x1) -> <i32 as NormalOut<cplx64x1>>::Output

fn _rem(self, rhs: cplx64x1) -> <i32 as NormalOut<cplx64x1>>::Output

fn _clamp( self, min: cplx64x1, max: cplx64x1, ) -> <i32 as NormalOut<cplx64x1>>::Output

fn _max(self, rhs: cplx64x1) -> <i32 as NormalOut<cplx64x1>>::Output

fn _min(self, rhs: cplx64x1) -> <i32 as NormalOut<cplx64x1>>::Output

impl NormalOut<cplx64x1> for i64

type Output = <i64x2 as NormalOutPromote<cplx64x1>>::Output

fn _mul_add( self, a: cplx64x1, b: cplx64x1, ) -> <i64 as NormalOut<cplx64x1>>::Output

fn _add(self, rhs: cplx64x1) -> <i64 as NormalOut<cplx64x1>>::Output

fn _sub(self, rhs: cplx64x1) -> <i64 as NormalOut<cplx64x1>>::Output

fn _mul(self, rhs: cplx64x1) -> <i64 as NormalOut<cplx64x1>>::Output

fn _pow(self, rhs: cplx64x1) -> <i64 as NormalOut<cplx64x1>>::Output

fn _rem(self, rhs: cplx64x1) -> <i64 as NormalOut<cplx64x1>>::Output

fn _clamp( self, min: cplx64x1, max: cplx64x1, ) -> <i64 as NormalOut<cplx64x1>>::Output

fn _max(self, rhs: cplx64x1) -> <i64 as NormalOut<cplx64x1>>::Output

fn _min(self, rhs: cplx64x1) -> <i64 as NormalOut<cplx64x1>>::Output

impl NormalOut<cplx64x1> for isize

type Output = <isizex2 as NormalOutPromote<cplx64x1>>::Output

fn _mul_add( self, a: cplx64x1, b: cplx64x1, ) -> <isize as NormalOut<cplx64x1>>::Output

fn _add(self, rhs: cplx64x1) -> <isize as NormalOut<cplx64x1>>::Output

fn _sub(self, rhs: cplx64x1) -> <isize as NormalOut<cplx64x1>>::Output

fn _mul(self, rhs: cplx64x1) -> <isize as NormalOut<cplx64x1>>::Output

fn _pow(self, rhs: cplx64x1) -> <isize as NormalOut<cplx64x1>>::Output

fn _rem(self, rhs: cplx64x1) -> <isize as NormalOut<cplx64x1>>::Output

fn _clamp( self, min: cplx64x1, max: cplx64x1, ) -> <isize as NormalOut<cplx64x1>>::Output

fn _max(self, rhs: cplx64x1) -> <isize as NormalOut<cplx64x1>>::Output

fn _min(self, rhs: cplx64x1) -> <isize as NormalOut<cplx64x1>>::Output

impl NormalOut<cplx64x1> for u8

type Output = <u8x16 as NormalOutPromote<cplx64x1>>::Output

fn _mul_add( self, a: cplx64x1, b: cplx64x1, ) -> <u8 as NormalOut<cplx64x1>>::Output

fn _add(self, rhs: cplx64x1) -> <u8 as NormalOut<cplx64x1>>::Output

fn _sub(self, rhs: cplx64x1) -> <u8 as NormalOut<cplx64x1>>::Output

fn _mul(self, rhs: cplx64x1) -> <u8 as NormalOut<cplx64x1>>::Output

fn _pow(self, rhs: cplx64x1) -> <u8 as NormalOut<cplx64x1>>::Output

fn _rem(self, rhs: cplx64x1) -> <u8 as NormalOut<cplx64x1>>::Output

fn _clamp( self, min: cplx64x1, max: cplx64x1, ) -> <u8 as NormalOut<cplx64x1>>::Output

fn _max(self, rhs: cplx64x1) -> <u8 as NormalOut<cplx64x1>>::Output

fn _min(self, rhs: cplx64x1) -> <u8 as NormalOut<cplx64x1>>::Output

impl NormalOut<cplx64x1> for u16

type Output = <u16x8 as NormalOutPromote<cplx64x1>>::Output

fn _mul_add( self, a: cplx64x1, b: cplx64x1, ) -> <u16 as NormalOut<cplx64x1>>::Output

fn _add(self, rhs: cplx64x1) -> <u16 as NormalOut<cplx64x1>>::Output

fn _sub(self, rhs: cplx64x1) -> <u16 as NormalOut<cplx64x1>>::Output

fn _mul(self, rhs: cplx64x1) -> <u16 as NormalOut<cplx64x1>>::Output

fn _pow(self, rhs: cplx64x1) -> <u16 as NormalOut<cplx64x1>>::Output

fn _rem(self, rhs: cplx64x1) -> <u16 as NormalOut<cplx64x1>>::Output

fn _clamp( self, min: cplx64x1, max: cplx64x1, ) -> <u16 as NormalOut<cplx64x1>>::Output

fn _max(self, rhs: cplx64x1) -> <u16 as NormalOut<cplx64x1>>::Output

fn _min(self, rhs: cplx64x1) -> <u16 as NormalOut<cplx64x1>>::Output

impl NormalOut<cplx64x1> for u32

type Output = <u32x4 as NormalOutPromote<cplx64x1>>::Output

fn _mul_add( self, a: cplx64x1, b: cplx64x1, ) -> <u32 as NormalOut<cplx64x1>>::Output

fn _add(self, rhs: cplx64x1) -> <u32 as NormalOut<cplx64x1>>::Output

fn _sub(self, rhs: cplx64x1) -> <u32 as NormalOut<cplx64x1>>::Output

fn _mul(self, rhs: cplx64x1) -> <u32 as NormalOut<cplx64x1>>::Output

fn _pow(self, rhs: cplx64x1) -> <u32 as NormalOut<cplx64x1>>::Output

fn _rem(self, rhs: cplx64x1) -> <u32 as NormalOut<cplx64x1>>::Output

fn _clamp( self, min: cplx64x1, max: cplx64x1, ) -> <u32 as NormalOut<cplx64x1>>::Output

fn _max(self, rhs: cplx64x1) -> <u32 as NormalOut<cplx64x1>>::Output

fn _min(self, rhs: cplx64x1) -> <u32 as NormalOut<cplx64x1>>::Output

impl NormalOut<cplx64x1> for u64

type Output = <u64x2 as NormalOutPromote<cplx64x1>>::Output

fn _mul_add( self, a: cplx64x1, b: cplx64x1, ) -> <u64 as NormalOut<cplx64x1>>::Output

fn _add(self, rhs: cplx64x1) -> <u64 as NormalOut<cplx64x1>>::Output

fn _sub(self, rhs: cplx64x1) -> <u64 as NormalOut<cplx64x1>>::Output

fn _mul(self, rhs: cplx64x1) -> <u64 as NormalOut<cplx64x1>>::Output

fn _pow(self, rhs: cplx64x1) -> <u64 as NormalOut<cplx64x1>>::Output

fn _rem(self, rhs: cplx64x1) -> <u64 as NormalOut<cplx64x1>>::Output

fn _clamp( self, min: cplx64x1, max: cplx64x1, ) -> <u64 as NormalOut<cplx64x1>>::Output

fn _max(self, rhs: cplx64x1) -> <u64 as NormalOut<cplx64x1>>::Output

fn _min(self, rhs: cplx64x1) -> <u64 as NormalOut<cplx64x1>>::Output

impl NormalOut<cplx64x1> for usize

type Output = <usizex2 as NormalOutPromote<cplx64x1>>::Output

fn _mul_add( self, a: cplx64x1, b: cplx64x1, ) -> <usize as NormalOut<cplx64x1>>::Output

fn _add(self, rhs: cplx64x1) -> <usize as NormalOut<cplx64x1>>::Output

fn _sub(self, rhs: cplx64x1) -> <usize as NormalOut<cplx64x1>>::Output

fn _mul(self, rhs: cplx64x1) -> <usize as NormalOut<cplx64x1>>::Output

fn _pow(self, rhs: cplx64x1) -> <usize as NormalOut<cplx64x1>>::Output

fn _rem(self, rhs: cplx64x1) -> <usize as NormalOut<cplx64x1>>::Output

fn _clamp( self, min: cplx64x1, max: cplx64x1, ) -> <usize as NormalOut<cplx64x1>>::Output

fn _max(self, rhs: cplx64x1) -> <usize as NormalOut<cplx64x1>>::Output

fn _min(self, rhs: cplx64x1) -> <usize as NormalOut<cplx64x1>>::Output

impl NormalOut<cplx64x1> for bf16

type Output = <bf16x8 as NormalOutPromote<cplx64x1>>::Output

fn _mul_add( self, a: cplx64x1, b: cplx64x1, ) -> <bf16 as NormalOut<cplx64x1>>::Output

fn _add(self, rhs: cplx64x1) -> <bf16 as NormalOut<cplx64x1>>::Output

fn _sub(self, rhs: cplx64x1) -> <bf16 as NormalOut<cplx64x1>>::Output

fn _mul(self, rhs: cplx64x1) -> <bf16 as NormalOut<cplx64x1>>::Output

fn _pow(self, rhs: cplx64x1) -> <bf16 as NormalOut<cplx64x1>>::Output

fn _rem(self, rhs: cplx64x1) -> <bf16 as NormalOut<cplx64x1>>::Output

fn _clamp( self, min: cplx64x1, max: cplx64x1, ) -> <bf16 as NormalOut<cplx64x1>>::Output

fn _max(self, rhs: cplx64x1) -> <bf16 as NormalOut<cplx64x1>>::Output

fn _min(self, rhs: cplx64x1) -> <bf16 as NormalOut<cplx64x1>>::Output

impl NormalOut<cplx64x1> for f16

type Output = <f16x8 as NormalOutPromote<cplx64x1>>::Output

fn _mul_add( self, a: cplx64x1, b: cplx64x1, ) -> <f16 as NormalOut<cplx64x1>>::Output

fn _add(self, rhs: cplx64x1) -> <f16 as NormalOut<cplx64x1>>::Output

fn _sub(self, rhs: cplx64x1) -> <f16 as NormalOut<cplx64x1>>::Output

fn _mul(self, rhs: cplx64x1) -> <f16 as NormalOut<cplx64x1>>::Output

fn _pow(self, rhs: cplx64x1) -> <f16 as NormalOut<cplx64x1>>::Output

fn _rem(self, rhs: cplx64x1) -> <f16 as NormalOut<cplx64x1>>::Output

fn _clamp( self, min: cplx64x1, max: cplx64x1, ) -> <f16 as NormalOut<cplx64x1>>::Output

fn _max(self, rhs: cplx64x1) -> <f16 as NormalOut<cplx64x1>>::Output

fn _min(self, rhs: cplx64x1) -> <f16 as NormalOut<cplx64x1>>::Output

impl NormalOut<cplx64x1> for Complex<f32>

type Output = <cplx32x2 as NormalOutPromote<cplx64x1>>::Output

fn _mul_add( self, a: cplx64x1, b: cplx64x1, ) -> <Complex<f32> as NormalOut<cplx64x1>>::Output

fn _add(self, rhs: cplx64x1) -> <Complex<f32> as NormalOut<cplx64x1>>::Output

fn _sub(self, rhs: cplx64x1) -> <Complex<f32> as NormalOut<cplx64x1>>::Output

fn _mul(self, rhs: cplx64x1) -> <Complex<f32> as NormalOut<cplx64x1>>::Output

fn _pow(self, rhs: cplx64x1) -> <Complex<f32> as NormalOut<cplx64x1>>::Output

fn _rem(self, rhs: cplx64x1) -> <Complex<f32> as NormalOut<cplx64x1>>::Output

fn _clamp( self, min: cplx64x1, max: cplx64x1, ) -> <Complex<f32> as NormalOut<cplx64x1>>::Output

fn _max(self, rhs: cplx64x1) -> <Complex<f32> as NormalOut<cplx64x1>>::Output

fn _min(self, rhs: cplx64x1) -> <Complex<f32> as NormalOut<cplx64x1>>::Output

impl NormalOut<cplx64x1> for Complex<f64>

type Output = <cplx64x1 as NormalOutPromote>::Output

fn _add(self, rhs: cplx64x1) -> <Complex<f64> as NormalOut<cplx64x1>>::Output

fn _sub(self, rhs: cplx64x1) -> <Complex<f64> as NormalOut<cplx64x1>>::Output

fn _mul(self, rhs: cplx64x1) -> <Complex<f64> as NormalOut<cplx64x1>>::Output

fn _pow(self, rhs: cplx64x1) -> <Complex<f64> as NormalOut<cplx64x1>>::Output

fn _max(self, rhs: cplx64x1) -> <Complex<f64> as NormalOut<cplx64x1>>::Output

fn _min(self, rhs: cplx64x1) -> <Complex<f64> as NormalOut<cplx64x1>>::Output

fn _rem(self, rhs: cplx64x1) -> <Complex<f64> as NormalOut<cplx64x1>>::Output

fn _clamp( self, min: cplx64x1, max: cplx64x1, ) -> <Complex<f64> as NormalOut<cplx64x1>>::Output

fn _mul_add( self, a: cplx64x1, b: cplx64x1, ) -> <Complex<f64> as NormalOut<cplx64x1>>::Output

impl NormalOut<f16x8> for bool

type Output = <boolx16 as NormalOutPromote<f16x8>>::Output

fn _mul_add(self, a: f16x8, b: f16x8) -> <bool as NormalOut<f16x8>>::Output

fn _add(self, rhs: f16x8) -> <bool as NormalOut<f16x8>>::Output

fn _sub(self, rhs: f16x8) -> <bool as NormalOut<f16x8>>::Output

fn _mul(self, rhs: f16x8) -> <bool as NormalOut<f16x8>>::Output

fn _pow(self, rhs: f16x8) -> <bool as NormalOut<f16x8>>::Output

fn _rem(self, rhs: f16x8) -> <bool as NormalOut<f16x8>>::Output

fn _clamp(self, min: f16x8, max: f16x8) -> <bool as NormalOut<f16x8>>::Output

fn _max(self, rhs: f16x8) -> <bool as NormalOut<f16x8>>::Output

fn _min(self, rhs: f16x8) -> <bool as NormalOut<f16x8>>::Output

impl NormalOut<f16x8> for f32

type Output = <f32x4 as NormalOutPromote<f16x8>>::Output

fn _mul_add(self, a: f16x8, b: f16x8) -> <f32 as NormalOut<f16x8>>::Output

fn _add(self, rhs: f16x8) -> <f32 as NormalOut<f16x8>>::Output

fn _sub(self, rhs: f16x8) -> <f32 as NormalOut<f16x8>>::Output

fn _mul(self, rhs: f16x8) -> <f32 as NormalOut<f16x8>>::Output

fn _pow(self, rhs: f16x8) -> <f32 as NormalOut<f16x8>>::Output

fn _rem(self, rhs: f16x8) -> <f32 as NormalOut<f16x8>>::Output

fn _clamp(self, min: f16x8, max: f16x8) -> <f32 as NormalOut<f16x8>>::Output

fn _max(self, rhs: f16x8) -> <f32 as NormalOut<f16x8>>::Output

fn _min(self, rhs: f16x8) -> <f32 as NormalOut<f16x8>>::Output

impl NormalOut<f16x8> for f64

type Output = <f64x2 as NormalOutPromote<f16x8>>::Output

fn _mul_add(self, a: f16x8, b: f16x8) -> <f64 as NormalOut<f16x8>>::Output

fn _add(self, rhs: f16x8) -> <f64 as NormalOut<f16x8>>::Output

fn _sub(self, rhs: f16x8) -> <f64 as NormalOut<f16x8>>::Output

fn _mul(self, rhs: f16x8) -> <f64 as NormalOut<f16x8>>::Output

fn _pow(self, rhs: f16x8) -> <f64 as NormalOut<f16x8>>::Output

fn _rem(self, rhs: f16x8) -> <f64 as NormalOut<f16x8>>::Output

fn _clamp(self, min: f16x8, max: f16x8) -> <f64 as NormalOut<f16x8>>::Output

fn _max(self, rhs: f16x8) -> <f64 as NormalOut<f16x8>>::Output

fn _min(self, rhs: f16x8) -> <f64 as NormalOut<f16x8>>::Output

impl NormalOut<f16x8> for i8

type Output = <i8x16 as NormalOutPromote<f16x8>>::Output

fn _mul_add(self, a: f16x8, b: f16x8) -> <i8 as NormalOut<f16x8>>::Output

fn _add(self, rhs: f16x8) -> <i8 as NormalOut<f16x8>>::Output

fn _sub(self, rhs: f16x8) -> <i8 as NormalOut<f16x8>>::Output

fn _mul(self, rhs: f16x8) -> <i8 as NormalOut<f16x8>>::Output

fn _pow(self, rhs: f16x8) -> <i8 as NormalOut<f16x8>>::Output

fn _rem(self, rhs: f16x8) -> <i8 as NormalOut<f16x8>>::Output

fn _clamp(self, min: f16x8, max: f16x8) -> <i8 as NormalOut<f16x8>>::Output

fn _max(self, rhs: f16x8) -> <i8 as NormalOut<f16x8>>::Output

fn _min(self, rhs: f16x8) -> <i8 as NormalOut<f16x8>>::Output

impl NormalOut<f16x8> for i16

type Output = <i16x8 as NormalOutPromote<f16x8>>::Output

fn _add(self, rhs: f16x8) -> <i16 as NormalOut<f16x8>>::Output

fn _sub(self, rhs: f16x8) -> <i16 as NormalOut<f16x8>>::Output

fn _mul(self, rhs: f16x8) -> <i16 as NormalOut<f16x8>>::Output

fn _pow(self, rhs: f16x8) -> <i16 as NormalOut<f16x8>>::Output

fn _max(self, rhs: f16x8) -> <i16 as NormalOut<f16x8>>::Output

fn _min(self, rhs: f16x8) -> <i16 as NormalOut<f16x8>>::Output

fn _rem(self, rhs: f16x8) -> <i16 as NormalOut<f16x8>>::Output

fn _clamp(self, min: f16x8, max: f16x8) -> <i16 as NormalOut<f16x8>>::Output

fn _mul_add(self, a: f16x8, b: f16x8) -> <i16 as NormalOut<f16x8>>::Output

impl NormalOut<f16x8> for i32

type Output = <i32x4 as NormalOutPromote<f16x8>>::Output

fn _mul_add(self, a: f16x8, b: f16x8) -> <i32 as NormalOut<f16x8>>::Output

fn _add(self, rhs: f16x8) -> <i32 as NormalOut<f16x8>>::Output

fn _sub(self, rhs: f16x8) -> <i32 as NormalOut<f16x8>>::Output

fn _mul(self, rhs: f16x8) -> <i32 as NormalOut<f16x8>>::Output

fn _pow(self, rhs: f16x8) -> <i32 as NormalOut<f16x8>>::Output

fn _rem(self, rhs: f16x8) -> <i32 as NormalOut<f16x8>>::Output

fn _clamp(self, min: f16x8, max: f16x8) -> <i32 as NormalOut<f16x8>>::Output

fn _max(self, rhs: f16x8) -> <i32 as NormalOut<f16x8>>::Output

fn _min(self, rhs: f16x8) -> <i32 as NormalOut<f16x8>>::Output

impl NormalOut<f16x8> for i64

type Output = <i64x2 as NormalOutPromote<f16x8>>::Output

fn _mul_add(self, a: f16x8, b: f16x8) -> <i64 as NormalOut<f16x8>>::Output

fn _add(self, rhs: f16x8) -> <i64 as NormalOut<f16x8>>::Output

fn _sub(self, rhs: f16x8) -> <i64 as NormalOut<f16x8>>::Output

fn _mul(self, rhs: f16x8) -> <i64 as NormalOut<f16x8>>::Output

fn _pow(self, rhs: f16x8) -> <i64 as NormalOut<f16x8>>::Output

fn _rem(self, rhs: f16x8) -> <i64 as NormalOut<f16x8>>::Output

fn _clamp(self, min: f16x8, max: f16x8) -> <i64 as NormalOut<f16x8>>::Output

fn _max(self, rhs: f16x8) -> <i64 as NormalOut<f16x8>>::Output

fn _min(self, rhs: f16x8) -> <i64 as NormalOut<f16x8>>::Output

impl NormalOut<f16x8> for isize

type Output = <isizex2 as NormalOutPromote<f16x8>>::Output

fn _mul_add(self, a: f16x8, b: f16x8) -> <isize as NormalOut<f16x8>>::Output

fn _add(self, rhs: f16x8) -> <isize as NormalOut<f16x8>>::Output

fn _sub(self, rhs: f16x8) -> <isize as NormalOut<f16x8>>::Output

fn _mul(self, rhs: f16x8) -> <isize as NormalOut<f16x8>>::Output

fn _pow(self, rhs: f16x8) -> <isize as NormalOut<f16x8>>::Output

fn _rem(self, rhs: f16x8) -> <isize as NormalOut<f16x8>>::Output

fn _clamp(self, min: f16x8, max: f16x8) -> <isize as NormalOut<f16x8>>::Output

fn _max(self, rhs: f16x8) -> <isize as NormalOut<f16x8>>::Output

fn _min(self, rhs: f16x8) -> <isize as NormalOut<f16x8>>::Output

impl NormalOut<f16x8> for u8

type Output = <u8x16 as NormalOutPromote<f16x8>>::Output

fn _mul_add(self, a: f16x8, b: f16x8) -> <u8 as NormalOut<f16x8>>::Output

fn _add(self, rhs: f16x8) -> <u8 as NormalOut<f16x8>>::Output

fn _sub(self, rhs: f16x8) -> <u8 as NormalOut<f16x8>>::Output

fn _mul(self, rhs: f16x8) -> <u8 as NormalOut<f16x8>>::Output

fn _pow(self, rhs: f16x8) -> <u8 as NormalOut<f16x8>>::Output

fn _rem(self, rhs: f16x8) -> <u8 as NormalOut<f16x8>>::Output

fn _clamp(self, min: f16x8, max: f16x8) -> <u8 as NormalOut<f16x8>>::Output

fn _max(self, rhs: f16x8) -> <u8 as NormalOut<f16x8>>::Output

fn _min(self, rhs: f16x8) -> <u8 as NormalOut<f16x8>>::Output

impl NormalOut<f16x8> for u16

type Output = <u16x8 as NormalOutPromote<f16x8>>::Output

fn _add(self, rhs: f16x8) -> <u16 as NormalOut<f16x8>>::Output

fn _sub(self, rhs: f16x8) -> <u16 as NormalOut<f16x8>>::Output

fn _mul(self, rhs: f16x8) -> <u16 as NormalOut<f16x8>>::Output

fn _pow(self, rhs: f16x8) -> <u16 as NormalOut<f16x8>>::Output

fn _max(self, rhs: f16x8) -> <u16 as NormalOut<f16x8>>::Output

fn _min(self, rhs: f16x8) -> <u16 as NormalOut<f16x8>>::Output

fn _rem(self, rhs: f16x8) -> <u16 as NormalOut<f16x8>>::Output

fn _clamp(self, min: f16x8, max: f16x8) -> <u16 as NormalOut<f16x8>>::Output

fn _mul_add(self, a: f16x8, b: f16x8) -> <u16 as NormalOut<f16x8>>::Output

impl NormalOut<f16x8> for u32

type Output = <u32x4 as NormalOutPromote<f16x8>>::Output

fn _mul_add(self, a: f16x8, b: f16x8) -> <u32 as NormalOut<f16x8>>::Output

fn _add(self, rhs: f16x8) -> <u32 as NormalOut<f16x8>>::Output

fn _sub(self, rhs: f16x8) -> <u32 as NormalOut<f16x8>>::Output

fn _mul(self, rhs: f16x8) -> <u32 as NormalOut<f16x8>>::Output

fn _pow(self, rhs: f16x8) -> <u32 as NormalOut<f16x8>>::Output

fn _rem(self, rhs: f16x8) -> <u32 as NormalOut<f16x8>>::Output

fn _clamp(self, min: f16x8, max: f16x8) -> <u32 as NormalOut<f16x8>>::Output

fn _max(self, rhs: f16x8) -> <u32 as NormalOut<f16x8>>::Output

fn _min(self, rhs: f16x8) -> <u32 as NormalOut<f16x8>>::Output

impl NormalOut<f16x8> for u64

type Output = <u64x2 as NormalOutPromote<f16x8>>::Output

fn _mul_add(self, a: f16x8, b: f16x8) -> <u64 as NormalOut<f16x8>>::Output

fn _add(self, rhs: f16x8) -> <u64 as NormalOut<f16x8>>::Output

fn _sub(self, rhs: f16x8) -> <u64 as NormalOut<f16x8>>::Output

fn _mul(self, rhs: f16x8) -> <u64 as NormalOut<f16x8>>::Output

fn _pow(self, rhs: f16x8) -> <u64 as NormalOut<f16x8>>::Output

fn _rem(self, rhs: f16x8) -> <u64 as NormalOut<f16x8>>::Output

fn _clamp(self, min: f16x8, max: f16x8) -> <u64 as NormalOut<f16x8>>::Output

fn _max(self, rhs: f16x8) -> <u64 as NormalOut<f16x8>>::Output

fn _min(self, rhs: f16x8) -> <u64 as NormalOut<f16x8>>::Output

impl NormalOut<f16x8> for usize

type Output = <usizex2 as NormalOutPromote<f16x8>>::Output

fn _mul_add(self, a: f16x8, b: f16x8) -> <usize as NormalOut<f16x8>>::Output

fn _add(self, rhs: f16x8) -> <usize as NormalOut<f16x8>>::Output

fn _sub(self, rhs: f16x8) -> <usize as NormalOut<f16x8>>::Output

fn _mul(self, rhs: f16x8) -> <usize as NormalOut<f16x8>>::Output

fn _pow(self, rhs: f16x8) -> <usize as NormalOut<f16x8>>::Output

fn _rem(self, rhs: f16x8) -> <usize as NormalOut<f16x8>>::Output

fn _clamp(self, min: f16x8, max: f16x8) -> <usize as NormalOut<f16x8>>::Output

fn _max(self, rhs: f16x8) -> <usize as NormalOut<f16x8>>::Output

fn _min(self, rhs: f16x8) -> <usize as NormalOut<f16x8>>::Output

impl NormalOut<f16x8> for bf16

type Output = <bf16x8 as NormalOutPromote<f16x8>>::Output

fn _add(self, rhs: f16x8) -> <bf16 as NormalOut<f16x8>>::Output

fn _sub(self, rhs: f16x8) -> <bf16 as NormalOut<f16x8>>::Output

fn _mul(self, rhs: f16x8) -> <bf16 as NormalOut<f16x8>>::Output

fn _pow(self, rhs: f16x8) -> <bf16 as NormalOut<f16x8>>::Output

fn _max(self, rhs: f16x8) -> <bf16 as NormalOut<f16x8>>::Output

fn _min(self, rhs: f16x8) -> <bf16 as NormalOut<f16x8>>::Output

fn _rem(self, rhs: f16x8) -> <bf16 as NormalOut<f16x8>>::Output

fn _clamp(self, min: f16x8, max: f16x8) -> <bf16 as NormalOut<f16x8>>::Output

fn _mul_add(self, a: f16x8, b: f16x8) -> <bf16 as NormalOut<f16x8>>::Output

impl NormalOut<f16x8> for f16

type Output = <f16x8 as NormalOutPromote>::Output

fn _add(self, rhs: f16x8) -> <f16 as NormalOut<f16x8>>::Output

fn _sub(self, rhs: f16x8) -> <f16 as NormalOut<f16x8>>::Output

fn _mul(self, rhs: f16x8) -> <f16 as NormalOut<f16x8>>::Output

fn _pow(self, rhs: f16x8) -> <f16 as NormalOut<f16x8>>::Output

fn _max(self, rhs: f16x8) -> <f16 as NormalOut<f16x8>>::Output

fn _min(self, rhs: f16x8) -> <f16 as NormalOut<f16x8>>::Output

fn _rem(self, rhs: f16x8) -> <f16 as NormalOut<f16x8>>::Output

fn _clamp(self, min: f16x8, max: f16x8) -> <f16 as NormalOut<f16x8>>::Output

fn _mul_add(self, a: f16x8, b: f16x8) -> <f16 as NormalOut<f16x8>>::Output

impl NormalOut<f16x8> for Complex<f32>

type Output = <cplx32x2 as NormalOutPromote<f16x8>>::Output

fn _mul_add( self, a: f16x8, b: f16x8, ) -> <Complex<f32> as NormalOut<f16x8>>::Output

fn _add(self, rhs: f16x8) -> <Complex<f32> as NormalOut<f16x8>>::Output

fn _sub(self, rhs: f16x8) -> <Complex<f32> as NormalOut<f16x8>>::Output

fn _mul(self, rhs: f16x8) -> <Complex<f32> as NormalOut<f16x8>>::Output

fn _pow(self, rhs: f16x8) -> <Complex<f32> as NormalOut<f16x8>>::Output

fn _rem(self, rhs: f16x8) -> <Complex<f32> as NormalOut<f16x8>>::Output

fn _clamp( self, min: f16x8, max: f16x8, ) -> <Complex<f32> as NormalOut<f16x8>>::Output

fn _max(self, rhs: f16x8) -> <Complex<f32> as NormalOut<f16x8>>::Output

fn _min(self, rhs: f16x8) -> <Complex<f32> as NormalOut<f16x8>>::Output

impl NormalOut<f16x8> for Complex<f64>

type Output = <cplx64x1 as NormalOutPromote<f16x8>>::Output

fn _mul_add( self, a: f16x8, b: f16x8, ) -> <Complex<f64> as NormalOut<f16x8>>::Output

fn _add(self, rhs: f16x8) -> <Complex<f64> as NormalOut<f16x8>>::Output

fn _sub(self, rhs: f16x8) -> <Complex<f64> as NormalOut<f16x8>>::Output

fn _mul(self, rhs: f16x8) -> <Complex<f64> as NormalOut<f16x8>>::Output

fn _pow(self, rhs: f16x8) -> <Complex<f64> as NormalOut<f16x8>>::Output

fn _rem(self, rhs: f16x8) -> <Complex<f64> as NormalOut<f16x8>>::Output

fn _clamp( self, min: f16x8, max: f16x8, ) -> <Complex<f64> as NormalOut<f16x8>>::Output

fn _max(self, rhs: f16x8) -> <Complex<f64> as NormalOut<f16x8>>::Output

fn _min(self, rhs: f16x8) -> <Complex<f64> as NormalOut<f16x8>>::Output

impl NormalOut<f32x4> for bool

type Output = <boolx16 as NormalOutPromote<f32x4>>::Output

fn _mul_add(self, a: f32x4, b: f32x4) -> <bool as NormalOut<f32x4>>::Output

fn _add(self, rhs: f32x4) -> <bool as NormalOut<f32x4>>::Output

fn _sub(self, rhs: f32x4) -> <bool as NormalOut<f32x4>>::Output

fn _mul(self, rhs: f32x4) -> <bool as NormalOut<f32x4>>::Output

fn _pow(self, rhs: f32x4) -> <bool as NormalOut<f32x4>>::Output

fn _rem(self, rhs: f32x4) -> <bool as NormalOut<f32x4>>::Output

fn _clamp(self, min: f32x4, max: f32x4) -> <bool as NormalOut<f32x4>>::Output

fn _max(self, rhs: f32x4) -> <bool as NormalOut<f32x4>>::Output

fn _min(self, rhs: f32x4) -> <bool as NormalOut<f32x4>>::Output

impl NormalOut<f32x4> for f32

type Output = <f32x4 as NormalOutPromote>::Output

fn _add(self, rhs: f32x4) -> <f32 as NormalOut<f32x4>>::Output

fn _sub(self, rhs: f32x4) -> <f32 as NormalOut<f32x4>>::Output

fn _mul(self, rhs: f32x4) -> <f32 as NormalOut<f32x4>>::Output

fn _pow(self, rhs: f32x4) -> <f32 as NormalOut<f32x4>>::Output

fn _max(self, rhs: f32x4) -> <f32 as NormalOut<f32x4>>::Output

fn _min(self, rhs: f32x4) -> <f32 as NormalOut<f32x4>>::Output

fn _rem(self, rhs: f32x4) -> <f32 as NormalOut<f32x4>>::Output

fn _clamp(self, min: f32x4, max: f32x4) -> <f32 as NormalOut<f32x4>>::Output

fn _mul_add(self, a: f32x4, b: f32x4) -> <f32 as NormalOut<f32x4>>::Output

impl NormalOut<f32x4> for f64

type Output = <f64x2 as NormalOutPromote<f32x4>>::Output

fn _mul_add(self, a: f32x4, b: f32x4) -> <f64 as NormalOut<f32x4>>::Output

fn _add(self, rhs: f32x4) -> <f64 as NormalOut<f32x4>>::Output

fn _sub(self, rhs: f32x4) -> <f64 as NormalOut<f32x4>>::Output

fn _mul(self, rhs: f32x4) -> <f64 as NormalOut<f32x4>>::Output

fn _pow(self, rhs: f32x4) -> <f64 as NormalOut<f32x4>>::Output

fn _rem(self, rhs: f32x4) -> <f64 as NormalOut<f32x4>>::Output

fn _clamp(self, min: f32x4, max: f32x4) -> <f64 as NormalOut<f32x4>>::Output

fn _max(self, rhs: f32x4) -> <f64 as NormalOut<f32x4>>::Output

fn _min(self, rhs: f32x4) -> <f64 as NormalOut<f32x4>>::Output

impl NormalOut<f32x4> for i8

type Output = <i8x16 as NormalOutPromote<f32x4>>::Output

fn _mul_add(self, a: f32x4, b: f32x4) -> <i8 as NormalOut<f32x4>>::Output

fn _add(self, rhs: f32x4) -> <i8 as NormalOut<f32x4>>::Output

fn _sub(self, rhs: f32x4) -> <i8 as NormalOut<f32x4>>::Output

fn _mul(self, rhs: f32x4) -> <i8 as NormalOut<f32x4>>::Output

fn _pow(self, rhs: f32x4) -> <i8 as NormalOut<f32x4>>::Output

fn _rem(self, rhs: f32x4) -> <i8 as NormalOut<f32x4>>::Output

fn _clamp(self, min: f32x4, max: f32x4) -> <i8 as NormalOut<f32x4>>::Output

fn _max(self, rhs: f32x4) -> <i8 as NormalOut<f32x4>>::Output

fn _min(self, rhs: f32x4) -> <i8 as NormalOut<f32x4>>::Output

impl NormalOut<f32x4> for i16

type Output = <i16x8 as NormalOutPromote<f32x4>>::Output

fn _mul_add(self, a: f32x4, b: f32x4) -> <i16 as NormalOut<f32x4>>::Output

fn _add(self, rhs: f32x4) -> <i16 as NormalOut<f32x4>>::Output

fn _sub(self, rhs: f32x4) -> <i16 as NormalOut<f32x4>>::Output

fn _mul(self, rhs: f32x4) -> <i16 as NormalOut<f32x4>>::Output

fn _pow(self, rhs: f32x4) -> <i16 as NormalOut<f32x4>>::Output

fn _rem(self, rhs: f32x4) -> <i16 as NormalOut<f32x4>>::Output

fn _clamp(self, min: f32x4, max: f32x4) -> <i16 as NormalOut<f32x4>>::Output

fn _max(self, rhs: f32x4) -> <i16 as NormalOut<f32x4>>::Output

fn _min(self, rhs: f32x4) -> <i16 as NormalOut<f32x4>>::Output

impl NormalOut<f32x4> for i32

type Output = <i32x4 as NormalOutPromote<f32x4>>::Output

fn _add(self, rhs: f32x4) -> <i32 as NormalOut<f32x4>>::Output

fn _sub(self, rhs: f32x4) -> <i32 as NormalOut<f32x4>>::Output

fn _mul(self, rhs: f32x4) -> <i32 as NormalOut<f32x4>>::Output

fn _pow(self, rhs: f32x4) -> <i32 as NormalOut<f32x4>>::Output

fn _max(self, rhs: f32x4) -> <i32 as NormalOut<f32x4>>::Output

fn _min(self, rhs: f32x4) -> <i32 as NormalOut<f32x4>>::Output

fn _rem(self, rhs: f32x4) -> <i32 as NormalOut<f32x4>>::Output

fn _clamp(self, min: f32x4, max: f32x4) -> <i32 as NormalOut<f32x4>>::Output

fn _mul_add(self, a: f32x4, b: f32x4) -> <i32 as NormalOut<f32x4>>::Output

impl NormalOut<f32x4> for i64

type Output = <i64x2 as NormalOutPromote<f32x4>>::Output

fn _mul_add(self, a: f32x4, b: f32x4) -> <i64 as NormalOut<f32x4>>::Output

fn _add(self, rhs: f32x4) -> <i64 as NormalOut<f32x4>>::Output

fn _sub(self, rhs: f32x4) -> <i64 as NormalOut<f32x4>>::Output

fn _mul(self, rhs: f32x4) -> <i64 as NormalOut<f32x4>>::Output

fn _pow(self, rhs: f32x4) -> <i64 as NormalOut<f32x4>>::Output

fn _rem(self, rhs: f32x4) -> <i64 as NormalOut<f32x4>>::Output

fn _clamp(self, min: f32x4, max: f32x4) -> <i64 as NormalOut<f32x4>>::Output

fn _max(self, rhs: f32x4) -> <i64 as NormalOut<f32x4>>::Output

fn _min(self, rhs: f32x4) -> <i64 as NormalOut<f32x4>>::Output

impl NormalOut<f32x4> for isize

type Output = <isizex2 as NormalOutPromote<f32x4>>::Output

fn _mul_add(self, a: f32x4, b: f32x4) -> <isize as NormalOut<f32x4>>::Output

fn _add(self, rhs: f32x4) -> <isize as NormalOut<f32x4>>::Output

fn _sub(self, rhs: f32x4) -> <isize as NormalOut<f32x4>>::Output

fn _mul(self, rhs: f32x4) -> <isize as NormalOut<f32x4>>::Output

fn _pow(self, rhs: f32x4) -> <isize as NormalOut<f32x4>>::Output

fn _rem(self, rhs: f32x4) -> <isize as NormalOut<f32x4>>::Output

fn _clamp(self, min: f32x4, max: f32x4) -> <isize as NormalOut<f32x4>>::Output

fn _max(self, rhs: f32x4) -> <isize as NormalOut<f32x4>>::Output

fn _min(self, rhs: f32x4) -> <isize as NormalOut<f32x4>>::Output

impl NormalOut<f32x4> for u8

type Output = <u8x16 as NormalOutPromote<f32x4>>::Output

fn _mul_add(self, a: f32x4, b: f32x4) -> <u8 as NormalOut<f32x4>>::Output

fn _add(self, rhs: f32x4) -> <u8 as NormalOut<f32x4>>::Output

fn _sub(self, rhs: f32x4) -> <u8 as NormalOut<f32x4>>::Output

fn _mul(self, rhs: f32x4) -> <u8 as NormalOut<f32x4>>::Output

fn _pow(self, rhs: f32x4) -> <u8 as NormalOut<f32x4>>::Output

fn _rem(self, rhs: f32x4) -> <u8 as NormalOut<f32x4>>::Output

fn _clamp(self, min: f32x4, max: f32x4) -> <u8 as NormalOut<f32x4>>::Output

fn _max(self, rhs: f32x4) -> <u8 as NormalOut<f32x4>>::Output

fn _min(self, rhs: f32x4) -> <u8 as NormalOut<f32x4>>::Output

impl NormalOut<f32x4> for u16

type Output = <u16x8 as NormalOutPromote<f32x4>>::Output

fn _mul_add(self, a: f32x4, b: f32x4) -> <u16 as NormalOut<f32x4>>::Output

fn _add(self, rhs: f32x4) -> <u16 as NormalOut<f32x4>>::Output

fn _sub(self, rhs: f32x4) -> <u16 as NormalOut<f32x4>>::Output

fn _mul(self, rhs: f32x4) -> <u16 as NormalOut<f32x4>>::Output

fn _pow(self, rhs: f32x4) -> <u16 as NormalOut<f32x4>>::Output

fn _rem(self, rhs: f32x4) -> <u16 as NormalOut<f32x4>>::Output

fn _clamp(self, min: f32x4, max: f32x4) -> <u16 as NormalOut<f32x4>>::Output

fn _max(self, rhs: f32x4) -> <u16 as NormalOut<f32x4>>::Output

fn _min(self, rhs: f32x4) -> <u16 as NormalOut<f32x4>>::Output

impl NormalOut<f32x4> for u32

type Output = <u32x4 as NormalOutPromote<f32x4>>::Output

fn _add(self, rhs: f32x4) -> <u32 as NormalOut<f32x4>>::Output

fn _sub(self, rhs: f32x4) -> <u32 as NormalOut<f32x4>>::Output

fn _mul(self, rhs: f32x4) -> <u32 as NormalOut<f32x4>>::Output

fn _pow(self, rhs: f32x4) -> <u32 as NormalOut<f32x4>>::Output

fn _max(self, rhs: f32x4) -> <u32 as NormalOut<f32x4>>::Output

fn _min(self, rhs: f32x4) -> <u32 as NormalOut<f32x4>>::Output

fn _rem(self, rhs: f32x4) -> <u32 as NormalOut<f32x4>>::Output

fn _clamp(self, min: f32x4, max: f32x4) -> <u32 as NormalOut<f32x4>>::Output

fn _mul_add(self, a: f32x4, b: f32x4) -> <u32 as NormalOut<f32x4>>::Output

impl NormalOut<f32x4> for u64

type Output = <u64x2 as NormalOutPromote<f32x4>>::Output

fn _mul_add(self, a: f32x4, b: f32x4) -> <u64 as NormalOut<f32x4>>::Output

fn _add(self, rhs: f32x4) -> <u64 as NormalOut<f32x4>>::Output

fn _sub(self, rhs: f32x4) -> <u64 as NormalOut<f32x4>>::Output

fn _mul(self, rhs: f32x4) -> <u64 as NormalOut<f32x4>>::Output

fn _pow(self, rhs: f32x4) -> <u64 as NormalOut<f32x4>>::Output

fn _rem(self, rhs: f32x4) -> <u64 as NormalOut<f32x4>>::Output

fn _clamp(self, min: f32x4, max: f32x4) -> <u64 as NormalOut<f32x4>>::Output

fn _max(self, rhs: f32x4) -> <u64 as NormalOut<f32x4>>::Output

fn _min(self, rhs: f32x4) -> <u64 as NormalOut<f32x4>>::Output

impl NormalOut<f32x4> for usize

type Output = <usizex2 as NormalOutPromote<f32x4>>::Output

fn _mul_add(self, a: f32x4, b: f32x4) -> <usize as NormalOut<f32x4>>::Output

fn _add(self, rhs: f32x4) -> <usize as NormalOut<f32x4>>::Output

fn _sub(self, rhs: f32x4) -> <usize as NormalOut<f32x4>>::Output

fn _mul(self, rhs: f32x4) -> <usize as NormalOut<f32x4>>::Output

fn _pow(self, rhs: f32x4) -> <usize as NormalOut<f32x4>>::Output

fn _rem(self, rhs: f32x4) -> <usize as NormalOut<f32x4>>::Output

fn _clamp(self, min: f32x4, max: f32x4) -> <usize as NormalOut<f32x4>>::Output

fn _max(self, rhs: f32x4) -> <usize as NormalOut<f32x4>>::Output

fn _min(self, rhs: f32x4) -> <usize as NormalOut<f32x4>>::Output

impl NormalOut<f32x4> for bf16

type Output = <bf16x8 as NormalOutPromote<f32x4>>::Output

fn _mul_add(self, a: f32x4, b: f32x4) -> <bf16 as NormalOut<f32x4>>::Output

fn _add(self, rhs: f32x4) -> <bf16 as NormalOut<f32x4>>::Output

fn _sub(self, rhs: f32x4) -> <bf16 as NormalOut<f32x4>>::Output

fn _mul(self, rhs: f32x4) -> <bf16 as NormalOut<f32x4>>::Output

fn _pow(self, rhs: f32x4) -> <bf16 as NormalOut<f32x4>>::Output

fn _rem(self, rhs: f32x4) -> <bf16 as NormalOut<f32x4>>::Output

fn _clamp(self, min: f32x4, max: f32x4) -> <bf16 as NormalOut<f32x4>>::Output

fn _max(self, rhs: f32x4) -> <bf16 as NormalOut<f32x4>>::Output

fn _min(self, rhs: f32x4) -> <bf16 as NormalOut<f32x4>>::Output

impl NormalOut<f32x4> for f16

type Output = <f16x8 as NormalOutPromote<f32x4>>::Output

fn _mul_add(self, a: f32x4, b: f32x4) -> <f16 as NormalOut<f32x4>>::Output

fn _add(self, rhs: f32x4) -> <f16 as NormalOut<f32x4>>::Output

fn _sub(self, rhs: f32x4) -> <f16 as NormalOut<f32x4>>::Output

fn _mul(self, rhs: f32x4) -> <f16 as NormalOut<f32x4>>::Output

fn _pow(self, rhs: f32x4) -> <f16 as NormalOut<f32x4>>::Output

fn _rem(self, rhs: f32x4) -> <f16 as NormalOut<f32x4>>::Output

fn _clamp(self, min: f32x4, max: f32x4) -> <f16 as NormalOut<f32x4>>::Output

fn _max(self, rhs: f32x4) -> <f16 as NormalOut<f32x4>>::Output

fn _min(self, rhs: f32x4) -> <f16 as NormalOut<f32x4>>::Output

impl NormalOut<f32x4> for Complex<f32>

type Output = <cplx32x2 as NormalOutPromote<f32x4>>::Output

fn _mul_add( self, a: f32x4, b: f32x4, ) -> <Complex<f32> as NormalOut<f32x4>>::Output

fn _add(self, rhs: f32x4) -> <Complex<f32> as NormalOut<f32x4>>::Output

fn _sub(self, rhs: f32x4) -> <Complex<f32> as NormalOut<f32x4>>::Output

fn _mul(self, rhs: f32x4) -> <Complex<f32> as NormalOut<f32x4>>::Output

fn _pow(self, rhs: f32x4) -> <Complex<f32> as NormalOut<f32x4>>::Output

fn _rem(self, rhs: f32x4) -> <Complex<f32> as NormalOut<f32x4>>::Output

fn _clamp( self, min: f32x4, max: f32x4, ) -> <Complex<f32> as NormalOut<f32x4>>::Output

fn _max(self, rhs: f32x4) -> <Complex<f32> as NormalOut<f32x4>>::Output

fn _min(self, rhs: f32x4) -> <Complex<f32> as NormalOut<f32x4>>::Output

impl NormalOut<f32x4> for Complex<f64>

type Output = <cplx64x1 as NormalOutPromote<f32x4>>::Output

fn _mul_add( self, a: f32x4, b: f32x4, ) -> <Complex<f64> as NormalOut<f32x4>>::Output

fn _add(self, rhs: f32x4) -> <Complex<f64> as NormalOut<f32x4>>::Output

fn _sub(self, rhs: f32x4) -> <Complex<f64> as NormalOut<f32x4>>::Output

fn _mul(self, rhs: f32x4) -> <Complex<f64> as NormalOut<f32x4>>::Output

fn _pow(self, rhs: f32x4) -> <Complex<f64> as NormalOut<f32x4>>::Output

fn _rem(self, rhs: f32x4) -> <Complex<f64> as NormalOut<f32x4>>::Output

fn _clamp( self, min: f32x4, max: f32x4, ) -> <Complex<f64> as NormalOut<f32x4>>::Output

fn _max(self, rhs: f32x4) -> <Complex<f64> as NormalOut<f32x4>>::Output

fn _min(self, rhs: f32x4) -> <Complex<f64> as NormalOut<f32x4>>::Output

impl NormalOut<f64x2> for bool

type Output = <boolx16 as NormalOutPromote<f64x2>>::Output

fn _mul_add(self, a: f64x2, b: f64x2) -> <bool as NormalOut<f64x2>>::Output

fn _add(self, rhs: f64x2) -> <bool as NormalOut<f64x2>>::Output

fn _sub(self, rhs: f64x2) -> <bool as NormalOut<f64x2>>::Output

fn _mul(self, rhs: f64x2) -> <bool as NormalOut<f64x2>>::Output

fn _pow(self, rhs: f64x2) -> <bool as NormalOut<f64x2>>::Output

fn _rem(self, rhs: f64x2) -> <bool as NormalOut<f64x2>>::Output

fn _clamp(self, min: f64x2, max: f64x2) -> <bool as NormalOut<f64x2>>::Output

fn _max(self, rhs: f64x2) -> <bool as NormalOut<f64x2>>::Output

fn _min(self, rhs: f64x2) -> <bool as NormalOut<f64x2>>::Output

impl NormalOut<f64x2> for f32

type Output = <f32x4 as NormalOutPromote<f64x2>>::Output

fn _mul_add(self, a: f64x2, b: f64x2) -> <f32 as NormalOut<f64x2>>::Output

fn _add(self, rhs: f64x2) -> <f32 as NormalOut<f64x2>>::Output

fn _sub(self, rhs: f64x2) -> <f32 as NormalOut<f64x2>>::Output

fn _mul(self, rhs: f64x2) -> <f32 as NormalOut<f64x2>>::Output

fn _pow(self, rhs: f64x2) -> <f32 as NormalOut<f64x2>>::Output

fn _rem(self, rhs: f64x2) -> <f32 as NormalOut<f64x2>>::Output

fn _clamp(self, min: f64x2, max: f64x2) -> <f32 as NormalOut<f64x2>>::Output

fn _max(self, rhs: f64x2) -> <f32 as NormalOut<f64x2>>::Output

fn _min(self, rhs: f64x2) -> <f32 as NormalOut<f64x2>>::Output

impl NormalOut<f64x2> for f64

type Output = <f64x2 as NormalOutPromote>::Output

fn _add(self, rhs: f64x2) -> <f64 as NormalOut<f64x2>>::Output

fn _sub(self, rhs: f64x2) -> <f64 as NormalOut<f64x2>>::Output

fn _mul(self, rhs: f64x2) -> <f64 as NormalOut<f64x2>>::Output

fn _pow(self, rhs: f64x2) -> <f64 as NormalOut<f64x2>>::Output

fn _max(self, rhs: f64x2) -> <f64 as NormalOut<f64x2>>::Output

fn _min(self, rhs: f64x2) -> <f64 as NormalOut<f64x2>>::Output

fn _rem(self, rhs: f64x2) -> <f64 as NormalOut<f64x2>>::Output

fn _clamp(self, min: f64x2, max: f64x2) -> <f64 as NormalOut<f64x2>>::Output

fn _mul_add(self, a: f64x2, b: f64x2) -> <f64 as NormalOut<f64x2>>::Output

impl NormalOut<f64x2> for i8

type Output = <i8x16 as NormalOutPromote<f64x2>>::Output

fn _mul_add(self, a: f64x2, b: f64x2) -> <i8 as NormalOut<f64x2>>::Output

fn _add(self, rhs: f64x2) -> <i8 as NormalOut<f64x2>>::Output

fn _sub(self, rhs: f64x2) -> <i8 as NormalOut<f64x2>>::Output

fn _mul(self, rhs: f64x2) -> <i8 as NormalOut<f64x2>>::Output

fn _pow(self, rhs: f64x2) -> <i8 as NormalOut<f64x2>>::Output

fn _rem(self, rhs: f64x2) -> <i8 as NormalOut<f64x2>>::Output

fn _clamp(self, min: f64x2, max: f64x2) -> <i8 as NormalOut<f64x2>>::Output

fn _max(self, rhs: f64x2) -> <i8 as NormalOut<f64x2>>::Output

fn _min(self, rhs: f64x2) -> <i8 as NormalOut<f64x2>>::Output

impl NormalOut<f64x2> for i16

type Output = <i16x8 as NormalOutPromote<f64x2>>::Output

fn _mul_add(self, a: f64x2, b: f64x2) -> <i16 as NormalOut<f64x2>>::Output

fn _add(self, rhs: f64x2) -> <i16 as NormalOut<f64x2>>::Output

fn _sub(self, rhs: f64x2) -> <i16 as NormalOut<f64x2>>::Output

fn _mul(self, rhs: f64x2) -> <i16 as NormalOut<f64x2>>::Output

fn _pow(self, rhs: f64x2) -> <i16 as NormalOut<f64x2>>::Output

fn _rem(self, rhs: f64x2) -> <i16 as NormalOut<f64x2>>::Output

fn _clamp(self, min: f64x2, max: f64x2) -> <i16 as NormalOut<f64x2>>::Output

fn _max(self, rhs: f64x2) -> <i16 as NormalOut<f64x2>>::Output

fn _min(self, rhs: f64x2) -> <i16 as NormalOut<f64x2>>::Output

impl NormalOut<f64x2> for i32

type Output = <i32x4 as NormalOutPromote<f64x2>>::Output

fn _mul_add(self, a: f64x2, b: f64x2) -> <i32 as NormalOut<f64x2>>::Output

fn _add(self, rhs: f64x2) -> <i32 as NormalOut<f64x2>>::Output

fn _sub(self, rhs: f64x2) -> <i32 as NormalOut<f64x2>>::Output

fn _mul(self, rhs: f64x2) -> <i32 as NormalOut<f64x2>>::Output

fn _pow(self, rhs: f64x2) -> <i32 as NormalOut<f64x2>>::Output

fn _rem(self, rhs: f64x2) -> <i32 as NormalOut<f64x2>>::Output

fn _clamp(self, min: f64x2, max: f64x2) -> <i32 as NormalOut<f64x2>>::Output

fn _max(self, rhs: f64x2) -> <i32 as NormalOut<f64x2>>::Output

fn _min(self, rhs: f64x2) -> <i32 as NormalOut<f64x2>>::Output

impl NormalOut<f64x2> for i64

type Output = <i64x2 as NormalOutPromote<f64x2>>::Output

fn _add(self, rhs: f64x2) -> <i64 as NormalOut<f64x2>>::Output

fn _sub(self, rhs: f64x2) -> <i64 as NormalOut<f64x2>>::Output

fn _mul(self, rhs: f64x2) -> <i64 as NormalOut<f64x2>>::Output

fn _pow(self, rhs: f64x2) -> <i64 as NormalOut<f64x2>>::Output

fn _max(self, rhs: f64x2) -> <i64 as NormalOut<f64x2>>::Output

fn _min(self, rhs: f64x2) -> <i64 as NormalOut<f64x2>>::Output

fn _rem(self, rhs: f64x2) -> <i64 as NormalOut<f64x2>>::Output

fn _clamp(self, min: f64x2, max: f64x2) -> <i64 as NormalOut<f64x2>>::Output

fn _mul_add(self, a: f64x2, b: f64x2) -> <i64 as NormalOut<f64x2>>::Output

impl NormalOut<f64x2> for isize

type Output = <isizex2 as NormalOutPromote<f64x2>>::Output

fn _add(self, rhs: f64x2) -> <isize as NormalOut<f64x2>>::Output

fn _sub(self, rhs: f64x2) -> <isize as NormalOut<f64x2>>::Output

fn _mul(self, rhs: f64x2) -> <isize as NormalOut<f64x2>>::Output

fn _pow(self, rhs: f64x2) -> <isize as NormalOut<f64x2>>::Output

fn _max(self, rhs: f64x2) -> <isize as NormalOut<f64x2>>::Output

fn _min(self, rhs: f64x2) -> <isize as NormalOut<f64x2>>::Output

fn _rem(self, rhs: f64x2) -> <isize as NormalOut<f64x2>>::Output

fn _clamp(self, min: f64x2, max: f64x2) -> <isize as NormalOut<f64x2>>::Output

fn _mul_add(self, a: f64x2, b: f64x2) -> <isize as NormalOut<f64x2>>::Output

impl NormalOut<f64x2> for u8

type Output = <u8x16 as NormalOutPromote<f64x2>>::Output

fn _mul_add(self, a: f64x2, b: f64x2) -> <u8 as NormalOut<f64x2>>::Output

fn _add(self, rhs: f64x2) -> <u8 as NormalOut<f64x2>>::Output

fn _sub(self, rhs: f64x2) -> <u8 as NormalOut<f64x2>>::Output

fn _mul(self, rhs: f64x2) -> <u8 as NormalOut<f64x2>>::Output

fn _pow(self, rhs: f64x2) -> <u8 as NormalOut<f64x2>>::Output

fn _rem(self, rhs: f64x2) -> <u8 as NormalOut<f64x2>>::Output

fn _clamp(self, min: f64x2, max: f64x2) -> <u8 as NormalOut<f64x2>>::Output

fn _max(self, rhs: f64x2) -> <u8 as NormalOut<f64x2>>::Output

fn _min(self, rhs: f64x2) -> <u8 as NormalOut<f64x2>>::Output

impl NormalOut<f64x2> for u16

type Output = <u16x8 as NormalOutPromote<f64x2>>::Output

fn _mul_add(self, a: f64x2, b: f64x2) -> <u16 as NormalOut<f64x2>>::Output

fn _add(self, rhs: f64x2) -> <u16 as NormalOut<f64x2>>::Output

fn _sub(self, rhs: f64x2) -> <u16 as NormalOut<f64x2>>::Output

fn _mul(self, rhs: f64x2) -> <u16 as NormalOut<f64x2>>::Output

fn _pow(self, rhs: f64x2) -> <u16 as NormalOut<f64x2>>::Output

fn _rem(self, rhs: f64x2) -> <u16 as NormalOut<f64x2>>::Output

fn _clamp(self, min: f64x2, max: f64x2) -> <u16 as NormalOut<f64x2>>::Output

fn _max(self, rhs: f64x2) -> <u16 as NormalOut<f64x2>>::Output

fn _min(self, rhs: f64x2) -> <u16 as NormalOut<f64x2>>::Output

impl NormalOut<f64x2> for u32

type Output = <u32x4 as NormalOutPromote<f64x2>>::Output

fn _mul_add(self, a: f64x2, b: f64x2) -> <u32 as NormalOut<f64x2>>::Output

fn _add(self, rhs: f64x2) -> <u32 as NormalOut<f64x2>>::Output

fn _sub(self, rhs: f64x2) -> <u32 as NormalOut<f64x2>>::Output

fn _mul(self, rhs: f64x2) -> <u32 as NormalOut<f64x2>>::Output

fn _pow(self, rhs: f64x2) -> <u32 as NormalOut<f64x2>>::Output

fn _rem(self, rhs: f64x2) -> <u32 as NormalOut<f64x2>>::Output

fn _clamp(self, min: f64x2, max: f64x2) -> <u32 as NormalOut<f64x2>>::Output

fn _max(self, rhs: f64x2) -> <u32 as NormalOut<f64x2>>::Output

fn _min(self, rhs: f64x2) -> <u32 as NormalOut<f64x2>>::Output

impl NormalOut<f64x2> for u64

type Output = <u64x2 as NormalOutPromote<f64x2>>::Output

fn _add(self, rhs: f64x2) -> <u64 as NormalOut<f64x2>>::Output

fn _sub(self, rhs: f64x2) -> <u64 as NormalOut<f64x2>>::Output

fn _mul(self, rhs: f64x2) -> <u64 as NormalOut<f64x2>>::Output

fn _pow(self, rhs: f64x2) -> <u64 as NormalOut<f64x2>>::Output

fn _max(self, rhs: f64x2) -> <u64 as NormalOut<f64x2>>::Output

fn _min(self, rhs: f64x2) -> <u64 as NormalOut<f64x2>>::Output

fn _rem(self, rhs: f64x2) -> <u64 as NormalOut<f64x2>>::Output

fn _clamp(self, min: f64x2, max: f64x2) -> <u64 as NormalOut<f64x2>>::Output

fn _mul_add(self, a: f64x2, b: f64x2) -> <u64 as NormalOut<f64x2>>::Output

impl NormalOut<f64x2> for usize

type Output = <usizex2 as NormalOutPromote<f64x2>>::Output

fn _add(self, rhs: f64x2) -> <usize as NormalOut<f64x2>>::Output

fn _sub(self, rhs: f64x2) -> <usize as NormalOut<f64x2>>::Output

fn _mul(self, rhs: f64x2) -> <usize as NormalOut<f64x2>>::Output

fn _pow(self, rhs: f64x2) -> <usize as NormalOut<f64x2>>::Output

fn _max(self, rhs: f64x2) -> <usize as NormalOut<f64x2>>::Output

fn _min(self, rhs: f64x2) -> <usize as NormalOut<f64x2>>::Output

fn _rem(self, rhs: f64x2) -> <usize as NormalOut<f64x2>>::Output

fn _clamp(self, min: f64x2, max: f64x2) -> <usize as NormalOut<f64x2>>::Output

fn _mul_add(self, a: f64x2, b: f64x2) -> <usize as NormalOut<f64x2>>::Output

impl NormalOut<f64x2> for bf16

type Output = <bf16x8 as NormalOutPromote<f64x2>>::Output

fn _mul_add(self, a: f64x2, b: f64x2) -> <bf16 as NormalOut<f64x2>>::Output

fn _add(self, rhs: f64x2) -> <bf16 as NormalOut<f64x2>>::Output

fn _sub(self, rhs: f64x2) -> <bf16 as NormalOut<f64x2>>::Output

fn _mul(self, rhs: f64x2) -> <bf16 as NormalOut<f64x2>>::Output

fn _pow(self, rhs: f64x2) -> <bf16 as NormalOut<f64x2>>::Output

fn _rem(self, rhs: f64x2) -> <bf16 as NormalOut<f64x2>>::Output

fn _clamp(self, min: f64x2, max: f64x2) -> <bf16 as NormalOut<f64x2>>::Output

fn _max(self, rhs: f64x2) -> <bf16 as NormalOut<f64x2>>::Output

fn _min(self, rhs: f64x2) -> <bf16 as NormalOut<f64x2>>::Output

impl NormalOut<f64x2> for f16

type Output = <f16x8 as NormalOutPromote<f64x2>>::Output

fn _mul_add(self, a: f64x2, b: f64x2) -> <f16 as NormalOut<f64x2>>::Output

fn _add(self, rhs: f64x2) -> <f16 as NormalOut<f64x2>>::Output

fn _sub(self, rhs: f64x2) -> <f16 as NormalOut<f64x2>>::Output

fn _mul(self, rhs: f64x2) -> <f16 as NormalOut<f64x2>>::Output

fn _pow(self, rhs: f64x2) -> <f16 as NormalOut<f64x2>>::Output

fn _rem(self, rhs: f64x2) -> <f16 as NormalOut<f64x2>>::Output

fn _clamp(self, min: f64x2, max: f64x2) -> <f16 as NormalOut<f64x2>>::Output

fn _max(self, rhs: f64x2) -> <f16 as NormalOut<f64x2>>::Output

fn _min(self, rhs: f64x2) -> <f16 as NormalOut<f64x2>>::Output

impl NormalOut<f64x2> for Complex<f32>

type Output = <cplx32x2 as NormalOutPromote<f64x2>>::Output

fn _add(self, rhs: f64x2) -> <Complex<f32> as NormalOut<f64x2>>::Output

fn _sub(self, rhs: f64x2) -> <Complex<f32> as NormalOut<f64x2>>::Output

fn _mul(self, rhs: f64x2) -> <Complex<f32> as NormalOut<f64x2>>::Output

fn _pow(self, rhs: f64x2) -> <Complex<f32> as NormalOut<f64x2>>::Output

fn _max(self, rhs: f64x2) -> <Complex<f32> as NormalOut<f64x2>>::Output

fn _min(self, rhs: f64x2) -> <Complex<f32> as NormalOut<f64x2>>::Output

fn _rem(self, rhs: f64x2) -> <Complex<f32> as NormalOut<f64x2>>::Output

fn _clamp( self, min: f64x2, max: f64x2, ) -> <Complex<f32> as NormalOut<f64x2>>::Output

fn _mul_add( self, a: f64x2, b: f64x2, ) -> <Complex<f32> as NormalOut<f64x2>>::Output

impl NormalOut<f64x2> for Complex<f64>

type Output = <cplx64x1 as NormalOutPromote<f64x2>>::Output

fn _mul_add( self, a: f64x2, b: f64x2, ) -> <Complex<f64> as NormalOut<f64x2>>::Output

fn _add(self, rhs: f64x2) -> <Complex<f64> as NormalOut<f64x2>>::Output

fn _sub(self, rhs: f64x2) -> <Complex<f64> as NormalOut<f64x2>>::Output

fn _mul(self, rhs: f64x2) -> <Complex<f64> as NormalOut<f64x2>>::Output

fn _pow(self, rhs: f64x2) -> <Complex<f64> as NormalOut<f64x2>>::Output

fn _rem(self, rhs: f64x2) -> <Complex<f64> as NormalOut<f64x2>>::Output

fn _clamp( self, min: f64x2, max: f64x2, ) -> <Complex<f64> as NormalOut<f64x2>>::Output

fn _max(self, rhs: f64x2) -> <Complex<f64> as NormalOut<f64x2>>::Output

fn _min(self, rhs: f64x2) -> <Complex<f64> as NormalOut<f64x2>>::Output

impl NormalOut<i8x16> for bool

type Output = <boolx16 as NormalOutPromote<i8x16>>::Output

fn _add(self, rhs: i8x16) -> <bool as NormalOut<i8x16>>::Output

fn _sub(self, rhs: i8x16) -> <bool as NormalOut<i8x16>>::Output

fn _mul(self, rhs: i8x16) -> <bool as NormalOut<i8x16>>::Output

fn _pow(self, rhs: i8x16) -> <bool as NormalOut<i8x16>>::Output

fn _max(self, rhs: i8x16) -> <bool as NormalOut<i8x16>>::Output

fn _min(self, rhs: i8x16) -> <bool as NormalOut<i8x16>>::Output

fn _rem(self, rhs: i8x16) -> <bool as NormalOut<i8x16>>::Output

fn _clamp(self, min: i8x16, max: i8x16) -> <bool as NormalOut<i8x16>>::Output

fn _mul_add(self, a: i8x16, b: i8x16) -> <bool as NormalOut<i8x16>>::Output

impl NormalOut<i8x16> for f32

type Output = <f32x4 as NormalOutPromote<i8x16>>::Output

fn _mul_add(self, a: i8x16, b: i8x16) -> <f32 as NormalOut<i8x16>>::Output

fn _add(self, rhs: i8x16) -> <f32 as NormalOut<i8x16>>::Output

fn _sub(self, rhs: i8x16) -> <f32 as NormalOut<i8x16>>::Output

fn _mul(self, rhs: i8x16) -> <f32 as NormalOut<i8x16>>::Output

fn _pow(self, rhs: i8x16) -> <f32 as NormalOut<i8x16>>::Output

fn _rem(self, rhs: i8x16) -> <f32 as NormalOut<i8x16>>::Output

fn _clamp(self, min: i8x16, max: i8x16) -> <f32 as NormalOut<i8x16>>::Output

fn _max(self, rhs: i8x16) -> <f32 as NormalOut<i8x16>>::Output

fn _min(self, rhs: i8x16) -> <f32 as NormalOut<i8x16>>::Output

impl NormalOut<i8x16> for f64

type Output = <f64x2 as NormalOutPromote<i8x16>>::Output

fn _mul_add(self, a: i8x16, b: i8x16) -> <f64 as NormalOut<i8x16>>::Output

fn _add(self, rhs: i8x16) -> <f64 as NormalOut<i8x16>>::Output

fn _sub(self, rhs: i8x16) -> <f64 as NormalOut<i8x16>>::Output

fn _mul(self, rhs: i8x16) -> <f64 as NormalOut<i8x16>>::Output

fn _pow(self, rhs: i8x16) -> <f64 as NormalOut<i8x16>>::Output

fn _rem(self, rhs: i8x16) -> <f64 as NormalOut<i8x16>>::Output

fn _clamp(self, min: i8x16, max: i8x16) -> <f64 as NormalOut<i8x16>>::Output

fn _max(self, rhs: i8x16) -> <f64 as NormalOut<i8x16>>::Output

fn _min(self, rhs: i8x16) -> <f64 as NormalOut<i8x16>>::Output

impl NormalOut<i8x16> for i8

type Output = <i8x16 as NormalOutPromote>::Output

fn _add(self, rhs: i8x16) -> <i8 as NormalOut<i8x16>>::Output

fn _sub(self, rhs: i8x16) -> <i8 as NormalOut<i8x16>>::Output

fn _mul(self, rhs: i8x16) -> <i8 as NormalOut<i8x16>>::Output

fn _pow(self, rhs: i8x16) -> <i8 as NormalOut<i8x16>>::Output

fn _max(self, rhs: i8x16) -> <i8 as NormalOut<i8x16>>::Output

fn _min(self, rhs: i8x16) -> <i8 as NormalOut<i8x16>>::Output

fn _rem(self, rhs: i8x16) -> <i8 as NormalOut<i8x16>>::Output

fn _clamp(self, min: i8x16, max: i8x16) -> <i8 as NormalOut<i8x16>>::Output

fn _mul_add(self, a: i8x16, b: i8x16) -> <i8 as NormalOut<i8x16>>::Output

impl NormalOut<i8x16> for i16

type Output = <i16x8 as NormalOutPromote<i8x16>>::Output

fn _mul_add(self, a: i8x16, b: i8x16) -> <i16 as NormalOut<i8x16>>::Output

fn _add(self, rhs: i8x16) -> <i16 as NormalOut<i8x16>>::Output

fn _sub(self, rhs: i8x16) -> <i16 as NormalOut<i8x16>>::Output

fn _mul(self, rhs: i8x16) -> <i16 as NormalOut<i8x16>>::Output

fn _pow(self, rhs: i8x16) -> <i16 as NormalOut<i8x16>>::Output

fn _rem(self, rhs: i8x16) -> <i16 as NormalOut<i8x16>>::Output

fn _clamp(self, min: i8x16, max: i8x16) -> <i16 as NormalOut<i8x16>>::Output

fn _max(self, rhs: i8x16) -> <i16 as NormalOut<i8x16>>::Output

fn _min(self, rhs: i8x16) -> <i16 as NormalOut<i8x16>>::Output

impl NormalOut<i8x16> for i32

type Output = <i32x4 as NormalOutPromote<i8x16>>::Output

fn _mul_add(self, a: i8x16, b: i8x16) -> <i32 as NormalOut<i8x16>>::Output

fn _add(self, rhs: i8x16) -> <i32 as NormalOut<i8x16>>::Output

fn _sub(self, rhs: i8x16) -> <i32 as NormalOut<i8x16>>::Output

fn _mul(self, rhs: i8x16) -> <i32 as NormalOut<i8x16>>::Output

fn _pow(self, rhs: i8x16) -> <i32 as NormalOut<i8x16>>::Output

fn _rem(self, rhs: i8x16) -> <i32 as NormalOut<i8x16>>::Output

fn _clamp(self, min: i8x16, max: i8x16) -> <i32 as NormalOut<i8x16>>::Output

fn _max(self, rhs: i8x16) -> <i32 as NormalOut<i8x16>>::Output

fn _min(self, rhs: i8x16) -> <i32 as NormalOut<i8x16>>::Output

impl NormalOut<i8x16> for i64

type Output = <i64x2 as NormalOutPromote<i8x16>>::Output

fn _mul_add(self, a: i8x16, b: i8x16) -> <i64 as NormalOut<i8x16>>::Output

fn _add(self, rhs: i8x16) -> <i64 as NormalOut<i8x16>>::Output

fn _sub(self, rhs: i8x16) -> <i64 as NormalOut<i8x16>>::Output

fn _mul(self, rhs: i8x16) -> <i64 as NormalOut<i8x16>>::Output

fn _pow(self, rhs: i8x16) -> <i64 as NormalOut<i8x16>>::Output

fn _rem(self, rhs: i8x16) -> <i64 as NormalOut<i8x16>>::Output

fn _clamp(self, min: i8x16, max: i8x16) -> <i64 as NormalOut<i8x16>>::Output

fn _max(self, rhs: i8x16) -> <i64 as NormalOut<i8x16>>::Output

fn _min(self, rhs: i8x16) -> <i64 as NormalOut<i8x16>>::Output

impl NormalOut<i8x16> for isize

type Output = <isizex2 as NormalOutPromote<i8x16>>::Output

fn _mul_add(self, a: i8x16, b: i8x16) -> <isize as NormalOut<i8x16>>::Output

fn _add(self, rhs: i8x16) -> <isize as NormalOut<i8x16>>::Output

fn _sub(self, rhs: i8x16) -> <isize as NormalOut<i8x16>>::Output

fn _mul(self, rhs: i8x16) -> <isize as NormalOut<i8x16>>::Output

fn _pow(self, rhs: i8x16) -> <isize as NormalOut<i8x16>>::Output

fn _rem(self, rhs: i8x16) -> <isize as NormalOut<i8x16>>::Output

fn _clamp(self, min: i8x16, max: i8x16) -> <isize as NormalOut<i8x16>>::Output

fn _max(self, rhs: i8x16) -> <isize as NormalOut<i8x16>>::Output

fn _min(self, rhs: i8x16) -> <isize as NormalOut<i8x16>>::Output

impl NormalOut<i8x16> for u8

type Output = <u8x16 as NormalOutPromote<i8x16>>::Output

fn _add(self, rhs: i8x16) -> <u8 as NormalOut<i8x16>>::Output

fn _sub(self, rhs: i8x16) -> <u8 as NormalOut<i8x16>>::Output

fn _mul(self, rhs: i8x16) -> <u8 as NormalOut<i8x16>>::Output

fn _pow(self, rhs: i8x16) -> <u8 as NormalOut<i8x16>>::Output

fn _max(self, rhs: i8x16) -> <u8 as NormalOut<i8x16>>::Output

fn _min(self, rhs: i8x16) -> <u8 as NormalOut<i8x16>>::Output

fn _rem(self, rhs: i8x16) -> <u8 as NormalOut<i8x16>>::Output

fn _clamp(self, min: i8x16, max: i8x16) -> <u8 as NormalOut<i8x16>>::Output

fn _mul_add(self, a: i8x16, b: i8x16) -> <u8 as NormalOut<i8x16>>::Output

impl NormalOut<i8x16> for u16

type Output = <u16x8 as NormalOutPromote<i8x16>>::Output

fn _mul_add(self, a: i8x16, b: i8x16) -> <u16 as NormalOut<i8x16>>::Output

fn _add(self, rhs: i8x16) -> <u16 as NormalOut<i8x16>>::Output

fn _sub(self, rhs: i8x16) -> <u16 as NormalOut<i8x16>>::Output

fn _mul(self, rhs: i8x16) -> <u16 as NormalOut<i8x16>>::Output

fn _pow(self, rhs: i8x16) -> <u16 as NormalOut<i8x16>>::Output

fn _rem(self, rhs: i8x16) -> <u16 as NormalOut<i8x16>>::Output

fn _clamp(self, min: i8x16, max: i8x16) -> <u16 as NormalOut<i8x16>>::Output

fn _max(self, rhs: i8x16) -> <u16 as NormalOut<i8x16>>::Output

fn _min(self, rhs: i8x16) -> <u16 as NormalOut<i8x16>>::Output

impl NormalOut<i8x16> for u32

type Output = <u32x4 as NormalOutPromote<i8x16>>::Output

fn _mul_add(self, a: i8x16, b: i8x16) -> <u32 as NormalOut<i8x16>>::Output

fn _add(self, rhs: i8x16) -> <u32 as NormalOut<i8x16>>::Output

fn _sub(self, rhs: i8x16) -> <u32 as NormalOut<i8x16>>::Output

fn _mul(self, rhs: i8x16) -> <u32 as NormalOut<i8x16>>::Output

fn _pow(self, rhs: i8x16) -> <u32 as NormalOut<i8x16>>::Output

fn _rem(self, rhs: i8x16) -> <u32 as NormalOut<i8x16>>::Output

fn _clamp(self, min: i8x16, max: i8x16) -> <u32 as NormalOut<i8x16>>::Output

fn _max(self, rhs: i8x16) -> <u32 as NormalOut<i8x16>>::Output

fn _min(self, rhs: i8x16) -> <u32 as NormalOut<i8x16>>::Output

impl NormalOut<i8x16> for u64

type Output = <u64x2 as NormalOutPromote<i8x16>>::Output

fn _mul_add(self, a: i8x16, b: i8x16) -> <u64 as NormalOut<i8x16>>::Output

fn _add(self, rhs: i8x16) -> <u64 as NormalOut<i8x16>>::Output

fn _sub(self, rhs: i8x16) -> <u64 as NormalOut<i8x16>>::Output

fn _mul(self, rhs: i8x16) -> <u64 as NormalOut<i8x16>>::Output

fn _pow(self, rhs: i8x16) -> <u64 as NormalOut<i8x16>>::Output

fn _rem(self, rhs: i8x16) -> <u64 as NormalOut<i8x16>>::Output

fn _clamp(self, min: i8x16, max: i8x16) -> <u64 as NormalOut<i8x16>>::Output

fn _max(self, rhs: i8x16) -> <u64 as NormalOut<i8x16>>::Output

fn _min(self, rhs: i8x16) -> <u64 as NormalOut<i8x16>>::Output

impl NormalOut<i8x16> for usize

type Output = <usizex2 as NormalOutPromote<i8x16>>::Output

fn _mul_add(self, a: i8x16, b: i8x16) -> <usize as NormalOut<i8x16>>::Output

fn _add(self, rhs: i8x16) -> <usize as NormalOut<i8x16>>::Output

fn _sub(self, rhs: i8x16) -> <usize as NormalOut<i8x16>>::Output

fn _mul(self, rhs: i8x16) -> <usize as NormalOut<i8x16>>::Output

fn _pow(self, rhs: i8x16) -> <usize as NormalOut<i8x16>>::Output

fn _rem(self, rhs: i8x16) -> <usize as NormalOut<i8x16>>::Output

fn _clamp(self, min: i8x16, max: i8x16) -> <usize as NormalOut<i8x16>>::Output

fn _max(self, rhs: i8x16) -> <usize as NormalOut<i8x16>>::Output

fn _min(self, rhs: i8x16) -> <usize as NormalOut<i8x16>>::Output

impl NormalOut<i8x16> for bf16

type Output = <bf16x8 as NormalOutPromote<i8x16>>::Output

fn _mul_add(self, a: i8x16, b: i8x16) -> <bf16 as NormalOut<i8x16>>::Output

fn _add(self, rhs: i8x16) -> <bf16 as NormalOut<i8x16>>::Output

fn _sub(self, rhs: i8x16) -> <bf16 as NormalOut<i8x16>>::Output

fn _mul(self, rhs: i8x16) -> <bf16 as NormalOut<i8x16>>::Output

fn _pow(self, rhs: i8x16) -> <bf16 as NormalOut<i8x16>>::Output

fn _rem(self, rhs: i8x16) -> <bf16 as NormalOut<i8x16>>::Output

fn _clamp(self, min: i8x16, max: i8x16) -> <bf16 as NormalOut<i8x16>>::Output

fn _max(self, rhs: i8x16) -> <bf16 as NormalOut<i8x16>>::Output

fn _min(self, rhs: i8x16) -> <bf16 as NormalOut<i8x16>>::Output

impl NormalOut<i8x16> for f16

type Output = <f16x8 as NormalOutPromote<i8x16>>::Output

fn _mul_add(self, a: i8x16, b: i8x16) -> <f16 as NormalOut<i8x16>>::Output

fn _add(self, rhs: i8x16) -> <f16 as NormalOut<i8x16>>::Output

fn _sub(self, rhs: i8x16) -> <f16 as NormalOut<i8x16>>::Output

fn _mul(self, rhs: i8x16) -> <f16 as NormalOut<i8x16>>::Output

fn _pow(self, rhs: i8x16) -> <f16 as NormalOut<i8x16>>::Output

fn _rem(self, rhs: i8x16) -> <f16 as NormalOut<i8x16>>::Output

fn _clamp(self, min: i8x16, max: i8x16) -> <f16 as NormalOut<i8x16>>::Output

fn _max(self, rhs: i8x16) -> <f16 as NormalOut<i8x16>>::Output

fn _min(self, rhs: i8x16) -> <f16 as NormalOut<i8x16>>::Output

impl NormalOut<i8x16> for Complex<f32>

type Output = <cplx32x2 as NormalOutPromote<i8x16>>::Output

fn _mul_add( self, a: i8x16, b: i8x16, ) -> <Complex<f32> as NormalOut<i8x16>>::Output

fn _add(self, rhs: i8x16) -> <Complex<f32> as NormalOut<i8x16>>::Output

fn _sub(self, rhs: i8x16) -> <Complex<f32> as NormalOut<i8x16>>::Output

fn _mul(self, rhs: i8x16) -> <Complex<f32> as NormalOut<i8x16>>::Output

fn _pow(self, rhs: i8x16) -> <Complex<f32> as NormalOut<i8x16>>::Output

fn _rem(self, rhs: i8x16) -> <Complex<f32> as NormalOut<i8x16>>::Output

fn _clamp( self, min: i8x16, max: i8x16, ) -> <Complex<f32> as NormalOut<i8x16>>::Output

fn _max(self, rhs: i8x16) -> <Complex<f32> as NormalOut<i8x16>>::Output

fn _min(self, rhs: i8x16) -> <Complex<f32> as NormalOut<i8x16>>::Output

impl NormalOut<i8x16> for Complex<f64>

type Output = <cplx64x1 as NormalOutPromote<i8x16>>::Output

fn _mul_add( self, a: i8x16, b: i8x16, ) -> <Complex<f64> as NormalOut<i8x16>>::Output

fn _add(self, rhs: i8x16) -> <Complex<f64> as NormalOut<i8x16>>::Output

fn _sub(self, rhs: i8x16) -> <Complex<f64> as NormalOut<i8x16>>::Output

fn _mul(self, rhs: i8x16) -> <Complex<f64> as NormalOut<i8x16>>::Output

fn _pow(self, rhs: i8x16) -> <Complex<f64> as NormalOut<i8x16>>::Output

fn _rem(self, rhs: i8x16) -> <Complex<f64> as NormalOut<i8x16>>::Output

fn _clamp( self, min: i8x16, max: i8x16, ) -> <Complex<f64> as NormalOut<i8x16>>::Output

fn _max(self, rhs: i8x16) -> <Complex<f64> as NormalOut<i8x16>>::Output

fn _min(self, rhs: i8x16) -> <Complex<f64> as NormalOut<i8x16>>::Output

impl NormalOut<i16x8> for bool

type Output = <boolx16 as NormalOutPromote<i16x8>>::Output

fn _mul_add(self, a: i16x8, b: i16x8) -> <bool as NormalOut<i16x8>>::Output

fn _add(self, rhs: i16x8) -> <bool as NormalOut<i16x8>>::Output

fn _sub(self, rhs: i16x8) -> <bool as NormalOut<i16x8>>::Output

fn _mul(self, rhs: i16x8) -> <bool as NormalOut<i16x8>>::Output

fn _pow(self, rhs: i16x8) -> <bool as NormalOut<i16x8>>::Output

fn _rem(self, rhs: i16x8) -> <bool as NormalOut<i16x8>>::Output

fn _clamp(self, min: i16x8, max: i16x8) -> <bool as NormalOut<i16x8>>::Output

fn _max(self, rhs: i16x8) -> <bool as NormalOut<i16x8>>::Output

fn _min(self, rhs: i16x8) -> <bool as NormalOut<i16x8>>::Output

impl NormalOut<i16x8> for f32

type Output = <f32x4 as NormalOutPromote<i16x8>>::Output

fn _mul_add(self, a: i16x8, b: i16x8) -> <f32 as NormalOut<i16x8>>::Output

fn _add(self, rhs: i16x8) -> <f32 as NormalOut<i16x8>>::Output

fn _sub(self, rhs: i16x8) -> <f32 as NormalOut<i16x8>>::Output

fn _mul(self, rhs: i16x8) -> <f32 as NormalOut<i16x8>>::Output

fn _pow(self, rhs: i16x8) -> <f32 as NormalOut<i16x8>>::Output

fn _rem(self, rhs: i16x8) -> <f32 as NormalOut<i16x8>>::Output

fn _clamp(self, min: i16x8, max: i16x8) -> <f32 as NormalOut<i16x8>>::Output

fn _max(self, rhs: i16x8) -> <f32 as NormalOut<i16x8>>::Output

fn _min(self, rhs: i16x8) -> <f32 as NormalOut<i16x8>>::Output

impl NormalOut<i16x8> for f64

type Output = <f64x2 as NormalOutPromote<i16x8>>::Output

fn _mul_add(self, a: i16x8, b: i16x8) -> <f64 as NormalOut<i16x8>>::Output

fn _add(self, rhs: i16x8) -> <f64 as NormalOut<i16x8>>::Output

fn _sub(self, rhs: i16x8) -> <f64 as NormalOut<i16x8>>::Output

fn _mul(self, rhs: i16x8) -> <f64 as NormalOut<i16x8>>::Output

fn _pow(self, rhs: i16x8) -> <f64 as NormalOut<i16x8>>::Output

fn _rem(self, rhs: i16x8) -> <f64 as NormalOut<i16x8>>::Output

fn _clamp(self, min: i16x8, max: i16x8) -> <f64 as NormalOut<i16x8>>::Output

fn _max(self, rhs: i16x8) -> <f64 as NormalOut<i16x8>>::Output

fn _min(self, rhs: i16x8) -> <f64 as NormalOut<i16x8>>::Output

impl NormalOut<i16x8> for i8

type Output = <i8x16 as NormalOutPromote<i16x8>>::Output

fn _mul_add(self, a: i16x8, b: i16x8) -> <i8 as NormalOut<i16x8>>::Output

fn _add(self, rhs: i16x8) -> <i8 as NormalOut<i16x8>>::Output

fn _sub(self, rhs: i16x8) -> <i8 as NormalOut<i16x8>>::Output

fn _mul(self, rhs: i16x8) -> <i8 as NormalOut<i16x8>>::Output

fn _pow(self, rhs: i16x8) -> <i8 as NormalOut<i16x8>>::Output

fn _rem(self, rhs: i16x8) -> <i8 as NormalOut<i16x8>>::Output

fn _clamp(self, min: i16x8, max: i16x8) -> <i8 as NormalOut<i16x8>>::Output

fn _max(self, rhs: i16x8) -> <i8 as NormalOut<i16x8>>::Output

fn _min(self, rhs: i16x8) -> <i8 as NormalOut<i16x8>>::Output

impl NormalOut<i16x8> for i16

type Output = <i16x8 as NormalOutPromote>::Output

fn _add(self, rhs: i16x8) -> <i16 as NormalOut<i16x8>>::Output

fn _sub(self, rhs: i16x8) -> <i16 as NormalOut<i16x8>>::Output

fn _mul(self, rhs: i16x8) -> <i16 as NormalOut<i16x8>>::Output

fn _pow(self, rhs: i16x8) -> <i16 as NormalOut<i16x8>>::Output

fn _max(self, rhs: i16x8) -> <i16 as NormalOut<i16x8>>::Output

fn _min(self, rhs: i16x8) -> <i16 as NormalOut<i16x8>>::Output

fn _rem(self, rhs: i16x8) -> <i16 as NormalOut<i16x8>>::Output

fn _clamp(self, min: i16x8, max: i16x8) -> <i16 as NormalOut<i16x8>>::Output

fn _mul_add(self, a: i16x8, b: i16x8) -> <i16 as NormalOut<i16x8>>::Output

impl NormalOut<i16x8> for i32

type Output = <i32x4 as NormalOutPromote<i16x8>>::Output

fn _mul_add(self, a: i16x8, b: i16x8) -> <i32 as NormalOut<i16x8>>::Output

fn _add(self, rhs: i16x8) -> <i32 as NormalOut<i16x8>>::Output

fn _sub(self, rhs: i16x8) -> <i32 as NormalOut<i16x8>>::Output

fn _mul(self, rhs: i16x8) -> <i32 as NormalOut<i16x8>>::Output

fn _pow(self, rhs: i16x8) -> <i32 as NormalOut<i16x8>>::Output

fn _rem(self, rhs: i16x8) -> <i32 as NormalOut<i16x8>>::Output

fn _clamp(self, min: i16x8, max: i16x8) -> <i32 as NormalOut<i16x8>>::Output

fn _max(self, rhs: i16x8) -> <i32 as NormalOut<i16x8>>::Output

fn _min(self, rhs: i16x8) -> <i32 as NormalOut<i16x8>>::Output

impl NormalOut<i16x8> for i64

type Output = <i64x2 as NormalOutPromote<i16x8>>::Output

fn _mul_add(self, a: i16x8, b: i16x8) -> <i64 as NormalOut<i16x8>>::Output

fn _add(self, rhs: i16x8) -> <i64 as NormalOut<i16x8>>::Output

fn _sub(self, rhs: i16x8) -> <i64 as NormalOut<i16x8>>::Output

fn _mul(self, rhs: i16x8) -> <i64 as NormalOut<i16x8>>::Output

fn _pow(self, rhs: i16x8) -> <i64 as NormalOut<i16x8>>::Output

fn _rem(self, rhs: i16x8) -> <i64 as NormalOut<i16x8>>::Output

fn _clamp(self, min: i16x8, max: i16x8) -> <i64 as NormalOut<i16x8>>::Output

fn _max(self, rhs: i16x8) -> <i64 as NormalOut<i16x8>>::Output

fn _min(self, rhs: i16x8) -> <i64 as NormalOut<i16x8>>::Output

impl NormalOut<i16x8> for isize

type Output = <isizex2 as NormalOutPromote<i16x8>>::Output

fn _mul_add(self, a: i16x8, b: i16x8) -> <isize as NormalOut<i16x8>>::Output

fn _add(self, rhs: i16x8) -> <isize as NormalOut<i16x8>>::Output

fn _sub(self, rhs: i16x8) -> <isize as NormalOut<i16x8>>::Output

fn _mul(self, rhs: i16x8) -> <isize as NormalOut<i16x8>>::Output

fn _pow(self, rhs: i16x8) -> <isize as NormalOut<i16x8>>::Output

fn _rem(self, rhs: i16x8) -> <isize as NormalOut<i16x8>>::Output

fn _clamp(self, min: i16x8, max: i16x8) -> <isize as NormalOut<i16x8>>::Output

fn _max(self, rhs: i16x8) -> <isize as NormalOut<i16x8>>::Output

fn _min(self, rhs: i16x8) -> <isize as NormalOut<i16x8>>::Output

impl NormalOut<i16x8> for u8

type Output = <u8x16 as NormalOutPromote<i16x8>>::Output

fn _mul_add(self, a: i16x8, b: i16x8) -> <u8 as NormalOut<i16x8>>::Output

fn _add(self, rhs: i16x8) -> <u8 as NormalOut<i16x8>>::Output

fn _sub(self, rhs: i16x8) -> <u8 as NormalOut<i16x8>>::Output

fn _mul(self, rhs: i16x8) -> <u8 as NormalOut<i16x8>>::Output

fn _pow(self, rhs: i16x8) -> <u8 as NormalOut<i16x8>>::Output

fn _rem(self, rhs: i16x8) -> <u8 as NormalOut<i16x8>>::Output

fn _clamp(self, min: i16x8, max: i16x8) -> <u8 as NormalOut<i16x8>>::Output

fn _max(self, rhs: i16x8) -> <u8 as NormalOut<i16x8>>::Output

fn _min(self, rhs: i16x8) -> <u8 as NormalOut<i16x8>>::Output

impl NormalOut<i16x8> for u16

type Output = <u16x8 as NormalOutPromote<i16x8>>::Output

fn _add(self, rhs: i16x8) -> <u16 as NormalOut<i16x8>>::Output

fn _sub(self, rhs: i16x8) -> <u16 as NormalOut<i16x8>>::Output

fn _mul(self, rhs: i16x8) -> <u16 as NormalOut<i16x8>>::Output

fn _pow(self, rhs: i16x8) -> <u16 as NormalOut<i16x8>>::Output

fn _max(self, rhs: i16x8) -> <u16 as NormalOut<i16x8>>::Output

fn _min(self, rhs: i16x8) -> <u16 as NormalOut<i16x8>>::Output

fn _rem(self, rhs: i16x8) -> <u16 as NormalOut<i16x8>>::Output

fn _clamp(self, min: i16x8, max: i16x8) -> <u16 as NormalOut<i16x8>>::Output

fn _mul_add(self, a: i16x8, b: i16x8) -> <u16 as NormalOut<i16x8>>::Output

impl NormalOut<i16x8> for u32

type Output = <u32x4 as NormalOutPromote<i16x8>>::Output

fn _mul_add(self, a: i16x8, b: i16x8) -> <u32 as NormalOut<i16x8>>::Output

fn _add(self, rhs: i16x8) -> <u32 as NormalOut<i16x8>>::Output

fn _sub(self, rhs: i16x8) -> <u32 as NormalOut<i16x8>>::Output

fn _mul(self, rhs: i16x8) -> <u32 as NormalOut<i16x8>>::Output

fn _pow(self, rhs: i16x8) -> <u32 as NormalOut<i16x8>>::Output

fn _rem(self, rhs: i16x8) -> <u32 as NormalOut<i16x8>>::Output

fn _clamp(self, min: i16x8, max: i16x8) -> <u32 as NormalOut<i16x8>>::Output

fn _max(self, rhs: i16x8) -> <u32 as NormalOut<i16x8>>::Output

fn _min(self, rhs: i16x8) -> <u32 as NormalOut<i16x8>>::Output

impl NormalOut<i16x8> for u64

type Output = <u64x2 as NormalOutPromote<i16x8>>::Output

fn _mul_add(self, a: i16x8, b: i16x8) -> <u64 as NormalOut<i16x8>>::Output

fn _add(self, rhs: i16x8) -> <u64 as NormalOut<i16x8>>::Output

fn _sub(self, rhs: i16x8) -> <u64 as NormalOut<i16x8>>::Output

fn _mul(self, rhs: i16x8) -> <u64 as NormalOut<i16x8>>::Output

fn _pow(self, rhs: i16x8) -> <u64 as NormalOut<i16x8>>::Output

fn _rem(self, rhs: i16x8) -> <u64 as NormalOut<i16x8>>::Output

fn _clamp(self, min: i16x8, max: i16x8) -> <u64 as NormalOut<i16x8>>::Output

fn _max(self, rhs: i16x8) -> <u64 as NormalOut<i16x8>>::Output

fn _min(self, rhs: i16x8) -> <u64 as NormalOut<i16x8>>::Output

impl NormalOut<i16x8> for usize

type Output = <usizex2 as NormalOutPromote<i16x8>>::Output

fn _mul_add(self, a: i16x8, b: i16x8) -> <usize as NormalOut<i16x8>>::Output

fn _add(self, rhs: i16x8) -> <usize as NormalOut<i16x8>>::Output

fn _sub(self, rhs: i16x8) -> <usize as NormalOut<i16x8>>::Output

fn _mul(self, rhs: i16x8) -> <usize as NormalOut<i16x8>>::Output

fn _pow(self, rhs: i16x8) -> <usize as NormalOut<i16x8>>::Output

fn _rem(self, rhs: i16x8) -> <usize as NormalOut<i16x8>>::Output

fn _clamp(self, min: i16x8, max: i16x8) -> <usize as NormalOut<i16x8>>::Output

fn _max(self, rhs: i16x8) -> <usize as NormalOut<i16x8>>::Output

fn _min(self, rhs: i16x8) -> <usize as NormalOut<i16x8>>::Output

impl NormalOut<i16x8> for bf16

type Output = <bf16x8 as NormalOutPromote<i16x8>>::Output

fn _add(self, rhs: i16x8) -> <bf16 as NormalOut<i16x8>>::Output

fn _sub(self, rhs: i16x8) -> <bf16 as NormalOut<i16x8>>::Output

fn _mul(self, rhs: i16x8) -> <bf16 as NormalOut<i16x8>>::Output

fn _pow(self, rhs: i16x8) -> <bf16 as NormalOut<i16x8>>::Output

fn _max(self, rhs: i16x8) -> <bf16 as NormalOut<i16x8>>::Output

fn _min(self, rhs: i16x8) -> <bf16 as NormalOut<i16x8>>::Output

fn _rem(self, rhs: i16x8) -> <bf16 as NormalOut<i16x8>>::Output

fn _clamp(self, min: i16x8, max: i16x8) -> <bf16 as NormalOut<i16x8>>::Output

fn _mul_add(self, a: i16x8, b: i16x8) -> <bf16 as NormalOut<i16x8>>::Output

impl NormalOut<i16x8> for f16

type Output = <f16x8 as NormalOutPromote<i16x8>>::Output

fn _add(self, rhs: i16x8) -> <f16 as NormalOut<i16x8>>::Output

fn _sub(self, rhs: i16x8) -> <f16 as NormalOut<i16x8>>::Output

fn _mul(self, rhs: i16x8) -> <f16 as NormalOut<i16x8>>::Output

fn _pow(self, rhs: i16x8) -> <f16 as NormalOut<i16x8>>::Output

fn _max(self, rhs: i16x8) -> <f16 as NormalOut<i16x8>>::Output

fn _min(self, rhs: i16x8) -> <f16 as NormalOut<i16x8>>::Output

fn _rem(self, rhs: i16x8) -> <f16 as NormalOut<i16x8>>::Output

fn _clamp(self, min: i16x8, max: i16x8) -> <f16 as NormalOut<i16x8>>::Output

fn _mul_add(self, a: i16x8, b: i16x8) -> <f16 as NormalOut<i16x8>>::Output

impl NormalOut<i16x8> for Complex<f32>

type Output = <cplx32x2 as NormalOutPromote<i16x8>>::Output

fn _mul_add( self, a: i16x8, b: i16x8, ) -> <Complex<f32> as NormalOut<i16x8>>::Output

fn _add(self, rhs: i16x8) -> <Complex<f32> as NormalOut<i16x8>>::Output

fn _sub(self, rhs: i16x8) -> <Complex<f32> as NormalOut<i16x8>>::Output

fn _mul(self, rhs: i16x8) -> <Complex<f32> as NormalOut<i16x8>>::Output

fn _pow(self, rhs: i16x8) -> <Complex<f32> as NormalOut<i16x8>>::Output

fn _rem(self, rhs: i16x8) -> <Complex<f32> as NormalOut<i16x8>>::Output

fn _clamp( self, min: i16x8, max: i16x8, ) -> <Complex<f32> as NormalOut<i16x8>>::Output

fn _max(self, rhs: i16x8) -> <Complex<f32> as NormalOut<i16x8>>::Output

fn _min(self, rhs: i16x8) -> <Complex<f32> as NormalOut<i16x8>>::Output

impl NormalOut<i16x8> for Complex<f64>

type Output = <cplx64x1 as NormalOutPromote<i16x8>>::Output

fn _mul_add( self, a: i16x8, b: i16x8, ) -> <Complex<f64> as NormalOut<i16x8>>::Output

fn _add(self, rhs: i16x8) -> <Complex<f64> as NormalOut<i16x8>>::Output

fn _sub(self, rhs: i16x8) -> <Complex<f64> as NormalOut<i16x8>>::Output

fn _mul(self, rhs: i16x8) -> <Complex<f64> as NormalOut<i16x8>>::Output

fn _pow(self, rhs: i16x8) -> <Complex<f64> as NormalOut<i16x8>>::Output

fn _rem(self, rhs: i16x8) -> <Complex<f64> as NormalOut<i16x8>>::Output

fn _clamp( self, min: i16x8, max: i16x8, ) -> <Complex<f64> as NormalOut<i16x8>>::Output

fn _max(self, rhs: i16x8) -> <Complex<f64> as NormalOut<i16x8>>::Output

fn _min(self, rhs: i16x8) -> <Complex<f64> as NormalOut<i16x8>>::Output

impl NormalOut<i32x4> for bool

type Output = <boolx16 as NormalOutPromote<i32x4>>::Output

fn _mul_add(self, a: i32x4, b: i32x4) -> <bool as NormalOut<i32x4>>::Output

fn _add(self, rhs: i32x4) -> <bool as NormalOut<i32x4>>::Output

fn _sub(self, rhs: i32x4) -> <bool as NormalOut<i32x4>>::Output

fn _mul(self, rhs: i32x4) -> <bool as NormalOut<i32x4>>::Output

fn _pow(self, rhs: i32x4) -> <bool as NormalOut<i32x4>>::Output

fn _rem(self, rhs: i32x4) -> <bool as NormalOut<i32x4>>::Output

fn _clamp(self, min: i32x4, max: i32x4) -> <bool as NormalOut<i32x4>>::Output

fn _max(self, rhs: i32x4) -> <bool as NormalOut<i32x4>>::Output

fn _min(self, rhs: i32x4) -> <bool as NormalOut<i32x4>>::Output

impl NormalOut<i32x4> for f32

type Output = <f32x4 as NormalOutPromote<i32x4>>::Output

fn _add(self, rhs: i32x4) -> <f32 as NormalOut<i32x4>>::Output

fn _sub(self, rhs: i32x4) -> <f32 as NormalOut<i32x4>>::Output

fn _mul(self, rhs: i32x4) -> <f32 as NormalOut<i32x4>>::Output

fn _pow(self, rhs: i32x4) -> <f32 as NormalOut<i32x4>>::Output

fn _max(self, rhs: i32x4) -> <f32 as NormalOut<i32x4>>::Output

fn _min(self, rhs: i32x4) -> <f32 as NormalOut<i32x4>>::Output

fn _rem(self, rhs: i32x4) -> <f32 as NormalOut<i32x4>>::Output

fn _clamp(self, min: i32x4, max: i32x4) -> <f32 as NormalOut<i32x4>>::Output

fn _mul_add(self, a: i32x4, b: i32x4) -> <f32 as NormalOut<i32x4>>::Output

impl NormalOut<i32x4> for f64

type Output = <f64x2 as NormalOutPromote<i32x4>>::Output

fn _mul_add(self, a: i32x4, b: i32x4) -> <f64 as NormalOut<i32x4>>::Output

fn _add(self, rhs: i32x4) -> <f64 as NormalOut<i32x4>>::Output

fn _sub(self, rhs: i32x4) -> <f64 as NormalOut<i32x4>>::Output

fn _mul(self, rhs: i32x4) -> <f64 as NormalOut<i32x4>>::Output

fn _pow(self, rhs: i32x4) -> <f64 as NormalOut<i32x4>>::Output

fn _rem(self, rhs: i32x4) -> <f64 as NormalOut<i32x4>>::Output

fn _clamp(self, min: i32x4, max: i32x4) -> <f64 as NormalOut<i32x4>>::Output

fn _max(self, rhs: i32x4) -> <f64 as NormalOut<i32x4>>::Output

fn _min(self, rhs: i32x4) -> <f64 as NormalOut<i32x4>>::Output

impl NormalOut<i32x4> for i8

type Output = <i8x16 as NormalOutPromote<i32x4>>::Output

fn _mul_add(self, a: i32x4, b: i32x4) -> <i8 as NormalOut<i32x4>>::Output

fn _add(self, rhs: i32x4) -> <i8 as NormalOut<i32x4>>::Output

fn _sub(self, rhs: i32x4) -> <i8 as NormalOut<i32x4>>::Output

fn _mul(self, rhs: i32x4) -> <i8 as NormalOut<i32x4>>::Output

fn _pow(self, rhs: i32x4) -> <i8 as NormalOut<i32x4>>::Output

fn _rem(self, rhs: i32x4) -> <i8 as NormalOut<i32x4>>::Output

fn _clamp(self, min: i32x4, max: i32x4) -> <i8 as NormalOut<i32x4>>::Output

fn _max(self, rhs: i32x4) -> <i8 as NormalOut<i32x4>>::Output

fn _min(self, rhs: i32x4) -> <i8 as NormalOut<i32x4>>::Output

impl NormalOut<i32x4> for i16

type Output = <i16x8 as NormalOutPromote<i32x4>>::Output

fn _mul_add(self, a: i32x4, b: i32x4) -> <i16 as NormalOut<i32x4>>::Output

fn _add(self, rhs: i32x4) -> <i16 as NormalOut<i32x4>>::Output

fn _sub(self, rhs: i32x4) -> <i16 as NormalOut<i32x4>>::Output

fn _mul(self, rhs: i32x4) -> <i16 as NormalOut<i32x4>>::Output

fn _pow(self, rhs: i32x4) -> <i16 as NormalOut<i32x4>>::Output

fn _rem(self, rhs: i32x4) -> <i16 as NormalOut<i32x4>>::Output

fn _clamp(self, min: i32x4, max: i32x4) -> <i16 as NormalOut<i32x4>>::Output

fn _max(self, rhs: i32x4) -> <i16 as NormalOut<i32x4>>::Output

fn _min(self, rhs: i32x4) -> <i16 as NormalOut<i32x4>>::Output

impl NormalOut<i32x4> for i32

type Output = <i32x4 as NormalOutPromote>::Output

fn _add(self, rhs: i32x4) -> <i32 as NormalOut<i32x4>>::Output

fn _sub(self, rhs: i32x4) -> <i32 as NormalOut<i32x4>>::Output

fn _mul(self, rhs: i32x4) -> <i32 as NormalOut<i32x4>>::Output

fn _pow(self, rhs: i32x4) -> <i32 as NormalOut<i32x4>>::Output

fn _max(self, rhs: i32x4) -> <i32 as NormalOut<i32x4>>::Output

fn _min(self, rhs: i32x4) -> <i32 as NormalOut<i32x4>>::Output

fn _rem(self, rhs: i32x4) -> <i32 as NormalOut<i32x4>>::Output

fn _clamp(self, min: i32x4, max: i32x4) -> <i32 as NormalOut<i32x4>>::Output

fn _mul_add(self, a: i32x4, b: i32x4) -> <i32 as NormalOut<i32x4>>::Output

impl NormalOut<i32x4> for i64

type Output = <i64x2 as NormalOutPromote<i32x4>>::Output

fn _mul_add(self, a: i32x4, b: i32x4) -> <i64 as NormalOut<i32x4>>::Output

fn _add(self, rhs: i32x4) -> <i64 as NormalOut<i32x4>>::Output

fn _sub(self, rhs: i32x4) -> <i64 as NormalOut<i32x4>>::Output

fn _mul(self, rhs: i32x4) -> <i64 as NormalOut<i32x4>>::Output

fn _pow(self, rhs: i32x4) -> <i64 as NormalOut<i32x4>>::Output

fn _rem(self, rhs: i32x4) -> <i64 as NormalOut<i32x4>>::Output

fn _clamp(self, min: i32x4, max: i32x4) -> <i64 as NormalOut<i32x4>>::Output

fn _max(self, rhs: i32x4) -> <i64 as NormalOut<i32x4>>::Output

fn _min(self, rhs: i32x4) -> <i64 as NormalOut<i32x4>>::Output

impl NormalOut<i32x4> for isize

type Output = <isizex2 as NormalOutPromote<i32x4>>::Output

fn _mul_add(self, a: i32x4, b: i32x4) -> <isize as NormalOut<i32x4>>::Output

fn _add(self, rhs: i32x4) -> <isize as NormalOut<i32x4>>::Output

fn _sub(self, rhs: i32x4) -> <isize as NormalOut<i32x4>>::Output

fn _mul(self, rhs: i32x4) -> <isize as NormalOut<i32x4>>::Output

fn _pow(self, rhs: i32x4) -> <isize as NormalOut<i32x4>>::Output

fn _rem(self, rhs: i32x4) -> <isize as NormalOut<i32x4>>::Output

fn _clamp(self, min: i32x4, max: i32x4) -> <isize as NormalOut<i32x4>>::Output

fn _max(self, rhs: i32x4) -> <isize as NormalOut<i32x4>>::Output

fn _min(self, rhs: i32x4) -> <isize as NormalOut<i32x4>>::Output

impl NormalOut<i32x4> for u8

type Output = <u8x16 as NormalOutPromote<i32x4>>::Output

fn _mul_add(self, a: i32x4, b: i32x4) -> <u8 as NormalOut<i32x4>>::Output

fn _add(self, rhs: i32x4) -> <u8 as NormalOut<i32x4>>::Output

fn _sub(self, rhs: i32x4) -> <u8 as NormalOut<i32x4>>::Output

fn _mul(self, rhs: i32x4) -> <u8 as NormalOut<i32x4>>::Output

fn _pow(self, rhs: i32x4) -> <u8 as NormalOut<i32x4>>::Output

fn _rem(self, rhs: i32x4) -> <u8 as NormalOut<i32x4>>::Output

fn _clamp(self, min: i32x4, max: i32x4) -> <u8 as NormalOut<i32x4>>::Output

fn _max(self, rhs: i32x4) -> <u8 as NormalOut<i32x4>>::Output

fn _min(self, rhs: i32x4) -> <u8 as NormalOut<i32x4>>::Output

impl NormalOut<i32x4> for u16

type Output = <u16x8 as NormalOutPromote<i32x4>>::Output

fn _mul_add(self, a: i32x4, b: i32x4) -> <u16 as NormalOut<i32x4>>::Output

fn _add(self, rhs: i32x4) -> <u16 as NormalOut<i32x4>>::Output

fn _sub(self, rhs: i32x4) -> <u16 as NormalOut<i32x4>>::Output

fn _mul(self, rhs: i32x4) -> <u16 as NormalOut<i32x4>>::Output

fn _pow(self, rhs: i32x4) -> <u16 as NormalOut<i32x4>>::Output

fn _rem(self, rhs: i32x4) -> <u16 as NormalOut<i32x4>>::Output

fn _clamp(self, min: i32x4, max: i32x4) -> <u16 as NormalOut<i32x4>>::Output

fn _max(self, rhs: i32x4) -> <u16 as NormalOut<i32x4>>::Output

fn _min(self, rhs: i32x4) -> <u16 as NormalOut<i32x4>>::Output

impl NormalOut<i32x4> for u32

type Output = <u32x4 as NormalOutPromote<i32x4>>::Output

fn _add(self, rhs: i32x4) -> <u32 as NormalOut<i32x4>>::Output

fn _sub(self, rhs: i32x4) -> <u32 as NormalOut<i32x4>>::Output

fn _mul(self, rhs: i32x4) -> <u32 as NormalOut<i32x4>>::Output

fn _pow(self, rhs: i32x4) -> <u32 as NormalOut<i32x4>>::Output

fn _max(self, rhs: i32x4) -> <u32 as NormalOut<i32x4>>::Output

fn _min(self, rhs: i32x4) -> <u32 as NormalOut<i32x4>>::Output

fn _rem(self, rhs: i32x4) -> <u32 as NormalOut<i32x4>>::Output

fn _clamp(self, min: i32x4, max: i32x4) -> <u32 as NormalOut<i32x4>>::Output

fn _mul_add(self, a: i32x4, b: i32x4) -> <u32 as NormalOut<i32x4>>::Output

impl NormalOut<i32x4> for u64

type Output = <u64x2 as NormalOutPromote<i32x4>>::Output

fn _mul_add(self, a: i32x4, b: i32x4) -> <u64 as NormalOut<i32x4>>::Output

fn _add(self, rhs: i32x4) -> <u64 as NormalOut<i32x4>>::Output

fn _sub(self, rhs: i32x4) -> <u64 as NormalOut<i32x4>>::Output

fn _mul(self, rhs: i32x4) -> <u64 as NormalOut<i32x4>>::Output

fn _pow(self, rhs: i32x4) -> <u64 as NormalOut<i32x4>>::Output

fn _rem(self, rhs: i32x4) -> <u64 as NormalOut<i32x4>>::Output

fn _clamp(self, min: i32x4, max: i32x4) -> <u64 as NormalOut<i32x4>>::Output

fn _max(self, rhs: i32x4) -> <u64 as NormalOut<i32x4>>::Output

fn _min(self, rhs: i32x4) -> <u64 as NormalOut<i32x4>>::Output

impl NormalOut<i32x4> for usize

type Output = <usizex2 as NormalOutPromote<i32x4>>::Output

fn _mul_add(self, a: i32x4, b: i32x4) -> <usize as NormalOut<i32x4>>::Output

fn _add(self, rhs: i32x4) -> <usize as NormalOut<i32x4>>::Output

fn _sub(self, rhs: i32x4) -> <usize as NormalOut<i32x4>>::Output

fn _mul(self, rhs: i32x4) -> <usize as NormalOut<i32x4>>::Output

fn _pow(self, rhs: i32x4) -> <usize as NormalOut<i32x4>>::Output

fn _rem(self, rhs: i32x4) -> <usize as NormalOut<i32x4>>::Output

fn _clamp(self, min: i32x4, max: i32x4) -> <usize as NormalOut<i32x4>>::Output

fn _max(self, rhs: i32x4) -> <usize as NormalOut<i32x4>>::Output

fn _min(self, rhs: i32x4) -> <usize as NormalOut<i32x4>>::Output

impl NormalOut<i32x4> for bf16

type Output = <bf16x8 as NormalOutPromote<i32x4>>::Output

fn _mul_add(self, a: i32x4, b: i32x4) -> <bf16 as NormalOut<i32x4>>::Output

fn _add(self, rhs: i32x4) -> <bf16 as NormalOut<i32x4>>::Output

fn _sub(self, rhs: i32x4) -> <bf16 as NormalOut<i32x4>>::Output

fn _mul(self, rhs: i32x4) -> <bf16 as NormalOut<i32x4>>::Output

fn _pow(self, rhs: i32x4) -> <bf16 as NormalOut<i32x4>>::Output

fn _rem(self, rhs: i32x4) -> <bf16 as NormalOut<i32x4>>::Output

fn _clamp(self, min: i32x4, max: i32x4) -> <bf16 as NormalOut<i32x4>>::Output

fn _max(self, rhs: i32x4) -> <bf16 as NormalOut<i32x4>>::Output

fn _min(self, rhs: i32x4) -> <bf16 as NormalOut<i32x4>>::Output

impl NormalOut<i32x4> for f16

type Output = <f16x8 as NormalOutPromote<i32x4>>::Output

fn _mul_add(self, a: i32x4, b: i32x4) -> <f16 as NormalOut<i32x4>>::Output

fn _add(self, rhs: i32x4) -> <f16 as NormalOut<i32x4>>::Output

fn _sub(self, rhs: i32x4) -> <f16 as NormalOut<i32x4>>::Output

fn _mul(self, rhs: i32x4) -> <f16 as NormalOut<i32x4>>::Output

fn _pow(self, rhs: i32x4) -> <f16 as NormalOut<i32x4>>::Output

fn _rem(self, rhs: i32x4) -> <f16 as NormalOut<i32x4>>::Output

fn _clamp(self, min: i32x4, max: i32x4) -> <f16 as NormalOut<i32x4>>::Output

fn _max(self, rhs: i32x4) -> <f16 as NormalOut<i32x4>>::Output

fn _min(self, rhs: i32x4) -> <f16 as NormalOut<i32x4>>::Output

impl NormalOut<i32x4> for Complex<f32>

type Output = <cplx32x2 as NormalOutPromote<i32x4>>::Output

fn _mul_add( self, a: i32x4, b: i32x4, ) -> <Complex<f32> as NormalOut<i32x4>>::Output

fn _add(self, rhs: i32x4) -> <Complex<f32> as NormalOut<i32x4>>::Output

fn _sub(self, rhs: i32x4) -> <Complex<f32> as NormalOut<i32x4>>::Output

fn _mul(self, rhs: i32x4) -> <Complex<f32> as NormalOut<i32x4>>::Output

fn _pow(self, rhs: i32x4) -> <Complex<f32> as NormalOut<i32x4>>::Output

fn _rem(self, rhs: i32x4) -> <Complex<f32> as NormalOut<i32x4>>::Output

fn _clamp( self, min: i32x4, max: i32x4, ) -> <Complex<f32> as NormalOut<i32x4>>::Output

fn _max(self, rhs: i32x4) -> <Complex<f32> as NormalOut<i32x4>>::Output

fn _min(self, rhs: i32x4) -> <Complex<f32> as NormalOut<i32x4>>::Output

impl NormalOut<i32x4> for Complex<f64>

type Output = <cplx64x1 as NormalOutPromote<i32x4>>::Output

fn _mul_add( self, a: i32x4, b: i32x4, ) -> <Complex<f64> as NormalOut<i32x4>>::Output

fn _add(self, rhs: i32x4) -> <Complex<f64> as NormalOut<i32x4>>::Output

fn _sub(self, rhs: i32x4) -> <Complex<f64> as NormalOut<i32x4>>::Output

fn _mul(self, rhs: i32x4) -> <Complex<f64> as NormalOut<i32x4>>::Output

fn _pow(self, rhs: i32x4) -> <Complex<f64> as NormalOut<i32x4>>::Output

fn _rem(self, rhs: i32x4) -> <Complex<f64> as NormalOut<i32x4>>::Output

fn _clamp( self, min: i32x4, max: i32x4, ) -> <Complex<f64> as NormalOut<i32x4>>::Output

fn _max(self, rhs: i32x4) -> <Complex<f64> as NormalOut<i32x4>>::Output

fn _min(self, rhs: i32x4) -> <Complex<f64> as NormalOut<i32x4>>::Output

impl NormalOut<i64x2> for bool

type Output = <boolx16 as NormalOutPromote<i64x2>>::Output

fn _mul_add(self, a: i64x2, b: i64x2) -> <bool as NormalOut<i64x2>>::Output

fn _add(self, rhs: i64x2) -> <bool as NormalOut<i64x2>>::Output

fn _sub(self, rhs: i64x2) -> <bool as NormalOut<i64x2>>::Output

fn _mul(self, rhs: i64x2) -> <bool as NormalOut<i64x2>>::Output

fn _pow(self, rhs: i64x2) -> <bool as NormalOut<i64x2>>::Output

fn _rem(self, rhs: i64x2) -> <bool as NormalOut<i64x2>>::Output

fn _clamp(self, min: i64x2, max: i64x2) -> <bool as NormalOut<i64x2>>::Output

fn _max(self, rhs: i64x2) -> <bool as NormalOut<i64x2>>::Output

fn _min(self, rhs: i64x2) -> <bool as NormalOut<i64x2>>::Output

impl NormalOut<i64x2> for f32

type Output = <f32x4 as NormalOutPromote<i64x2>>::Output

fn _mul_add(self, a: i64x2, b: i64x2) -> <f32 as NormalOut<i64x2>>::Output

fn _add(self, rhs: i64x2) -> <f32 as NormalOut<i64x2>>::Output

fn _sub(self, rhs: i64x2) -> <f32 as NormalOut<i64x2>>::Output

fn _mul(self, rhs: i64x2) -> <f32 as NormalOut<i64x2>>::Output

fn _pow(self, rhs: i64x2) -> <f32 as NormalOut<i64x2>>::Output

fn _rem(self, rhs: i64x2) -> <f32 as NormalOut<i64x2>>::Output

fn _clamp(self, min: i64x2, max: i64x2) -> <f32 as NormalOut<i64x2>>::Output

fn _max(self, rhs: i64x2) -> <f32 as NormalOut<i64x2>>::Output

fn _min(self, rhs: i64x2) -> <f32 as NormalOut<i64x2>>::Output

impl NormalOut<i64x2> for f64

type Output = <f64x2 as NormalOutPromote<i64x2>>::Output

fn _add(self, rhs: i64x2) -> <f64 as NormalOut<i64x2>>::Output

fn _sub(self, rhs: i64x2) -> <f64 as NormalOut<i64x2>>::Output

fn _mul(self, rhs: i64x2) -> <f64 as NormalOut<i64x2>>::Output

fn _pow(self, rhs: i64x2) -> <f64 as NormalOut<i64x2>>::Output

fn _max(self, rhs: i64x2) -> <f64 as NormalOut<i64x2>>::Output

fn _min(self, rhs: i64x2) -> <f64 as NormalOut<i64x2>>::Output

fn _rem(self, rhs: i64x2) -> <f64 as NormalOut<i64x2>>::Output

fn _clamp(self, min: i64x2, max: i64x2) -> <f64 as NormalOut<i64x2>>::Output

fn _mul_add(self, a: i64x2, b: i64x2) -> <f64 as NormalOut<i64x2>>::Output

impl NormalOut<i64x2> for i8

type Output = <i8x16 as NormalOutPromote<i64x2>>::Output

fn _mul_add(self, a: i64x2, b: i64x2) -> <i8 as NormalOut<i64x2>>::Output

fn _add(self, rhs: i64x2) -> <i8 as NormalOut<i64x2>>::Output

fn _sub(self, rhs: i64x2) -> <i8 as NormalOut<i64x2>>::Output

fn _mul(self, rhs: i64x2) -> <i8 as NormalOut<i64x2>>::Output

fn _pow(self, rhs: i64x2) -> <i8 as NormalOut<i64x2>>::Output

fn _rem(self, rhs: i64x2) -> <i8 as NormalOut<i64x2>>::Output

fn _clamp(self, min: i64x2, max: i64x2) -> <i8 as NormalOut<i64x2>>::Output

fn _max(self, rhs: i64x2) -> <i8 as NormalOut<i64x2>>::Output

fn _min(self, rhs: i64x2) -> <i8 as NormalOut<i64x2>>::Output

impl NormalOut<i64x2> for i16

type Output = <i16x8 as NormalOutPromote<i64x2>>::Output

fn _mul_add(self, a: i64x2, b: i64x2) -> <i16 as NormalOut<i64x2>>::Output

fn _add(self, rhs: i64x2) -> <i16 as NormalOut<i64x2>>::Output

fn _sub(self, rhs: i64x2) -> <i16 as NormalOut<i64x2>>::Output

fn _mul(self, rhs: i64x2) -> <i16 as NormalOut<i64x2>>::Output

fn _pow(self, rhs: i64x2) -> <i16 as NormalOut<i64x2>>::Output

fn _rem(self, rhs: i64x2) -> <i16 as NormalOut<i64x2>>::Output

fn _clamp(self, min: i64x2, max: i64x2) -> <i16 as NormalOut<i64x2>>::Output

fn _max(self, rhs: i64x2) -> <i16 as NormalOut<i64x2>>::Output

fn _min(self, rhs: i64x2) -> <i16 as NormalOut<i64x2>>::Output

impl NormalOut<i64x2> for i32

type Output = <i32x4 as NormalOutPromote<i64x2>>::Output

fn _mul_add(self, a: i64x2, b: i64x2) -> <i32 as NormalOut<i64x2>>::Output

fn _add(self, rhs: i64x2) -> <i32 as NormalOut<i64x2>>::Output

fn _sub(self, rhs: i64x2) -> <i32 as NormalOut<i64x2>>::Output

fn _mul(self, rhs: i64x2) -> <i32 as NormalOut<i64x2>>::Output

fn _pow(self, rhs: i64x2) -> <i32 as NormalOut<i64x2>>::Output

fn _rem(self, rhs: i64x2) -> <i32 as NormalOut<i64x2>>::Output

fn _clamp(self, min: i64x2, max: i64x2) -> <i32 as NormalOut<i64x2>>::Output

fn _max(self, rhs: i64x2) -> <i32 as NormalOut<i64x2>>::Output

fn _min(self, rhs: i64x2) -> <i32 as NormalOut<i64x2>>::Output

impl NormalOut<i64x2> for i64

type Output = <i64x2 as NormalOutPromote>::Output

fn _add(self, rhs: i64x2) -> <i64 as NormalOut<i64x2>>::Output

fn _sub(self, rhs: i64x2) -> <i64 as NormalOut<i64x2>>::Output

fn _mul(self, rhs: i64x2) -> <i64 as NormalOut<i64x2>>::Output

fn _pow(self, rhs: i64x2) -> <i64 as NormalOut<i64x2>>::Output

fn _max(self, rhs: i64x2) -> <i64 as NormalOut<i64x2>>::Output

fn _min(self, rhs: i64x2) -> <i64 as NormalOut<i64x2>>::Output

fn _rem(self, rhs: i64x2) -> <i64 as NormalOut<i64x2>>::Output

fn _clamp(self, min: i64x2, max: i64x2) -> <i64 as NormalOut<i64x2>>::Output

fn _mul_add(self, a: i64x2, b: i64x2) -> <i64 as NormalOut<i64x2>>::Output

impl NormalOut<i64x2> for isize

type Output = <isizex2 as NormalOutPromote<i64x2>>::Output

fn _add(self, rhs: i64x2) -> <isize as NormalOut<i64x2>>::Output

fn _sub(self, rhs: i64x2) -> <isize as NormalOut<i64x2>>::Output

fn _mul(self, rhs: i64x2) -> <isize as NormalOut<i64x2>>::Output

fn _pow(self, rhs: i64x2) -> <isize as NormalOut<i64x2>>::Output

fn _max(self, rhs: i64x2) -> <isize as NormalOut<i64x2>>::Output

fn _min(self, rhs: i64x2) -> <isize as NormalOut<i64x2>>::Output

fn _rem(self, rhs: i64x2) -> <isize as NormalOut<i64x2>>::Output

fn _clamp(self, min: i64x2, max: i64x2) -> <isize as NormalOut<i64x2>>::Output

fn _mul_add(self, a: i64x2, b: i64x2) -> <isize as NormalOut<i64x2>>::Output

impl NormalOut<i64x2> for u8

type Output = <u8x16 as NormalOutPromote<i64x2>>::Output

fn _mul_add(self, a: i64x2, b: i64x2) -> <u8 as NormalOut<i64x2>>::Output

fn _add(self, rhs: i64x2) -> <u8 as NormalOut<i64x2>>::Output

fn _sub(self, rhs: i64x2) -> <u8 as NormalOut<i64x2>>::Output

fn _mul(self, rhs: i64x2) -> <u8 as NormalOut<i64x2>>::Output

fn _pow(self, rhs: i64x2) -> <u8 as NormalOut<i64x2>>::Output

fn _rem(self, rhs: i64x2) -> <u8 as NormalOut<i64x2>>::Output

fn _clamp(self, min: i64x2, max: i64x2) -> <u8 as NormalOut<i64x2>>::Output

fn _max(self, rhs: i64x2) -> <u8 as NormalOut<i64x2>>::Output

fn _min(self, rhs: i64x2) -> <u8 as NormalOut<i64x2>>::Output

impl NormalOut<i64x2> for u16

type Output = <u16x8 as NormalOutPromote<i64x2>>::Output

fn _mul_add(self, a: i64x2, b: i64x2) -> <u16 as NormalOut<i64x2>>::Output

fn _add(self, rhs: i64x2) -> <u16 as NormalOut<i64x2>>::Output

fn _sub(self, rhs: i64x2) -> <u16 as NormalOut<i64x2>>::Output

fn _mul(self, rhs: i64x2) -> <u16 as NormalOut<i64x2>>::Output

fn _pow(self, rhs: i64x2) -> <u16 as NormalOut<i64x2>>::Output

fn _rem(self, rhs: i64x2) -> <u16 as NormalOut<i64x2>>::Output

fn _clamp(self, min: i64x2, max: i64x2) -> <u16 as NormalOut<i64x2>>::Output

fn _max(self, rhs: i64x2) -> <u16 as NormalOut<i64x2>>::Output

fn _min(self, rhs: i64x2) -> <u16 as NormalOut<i64x2>>::Output

impl NormalOut<i64x2> for u32

type Output = <u32x4 as NormalOutPromote<i64x2>>::Output

fn _mul_add(self, a: i64x2, b: i64x2) -> <u32 as NormalOut<i64x2>>::Output

fn _add(self, rhs: i64x2) -> <u32 as NormalOut<i64x2>>::Output

fn _sub(self, rhs: i64x2) -> <u32 as NormalOut<i64x2>>::Output

fn _mul(self, rhs: i64x2) -> <u32 as NormalOut<i64x2>>::Output

fn _pow(self, rhs: i64x2) -> <u32 as NormalOut<i64x2>>::Output

fn _rem(self, rhs: i64x2) -> <u32 as NormalOut<i64x2>>::Output

fn _clamp(self, min: i64x2, max: i64x2) -> <u32 as NormalOut<i64x2>>::Output

fn _max(self, rhs: i64x2) -> <u32 as NormalOut<i64x2>>::Output

fn _min(self, rhs: i64x2) -> <u32 as NormalOut<i64x2>>::Output

impl NormalOut<i64x2> for u64

type Output = <u64x2 as NormalOutPromote<i64x2>>::Output

fn _add(self, rhs: i64x2) -> <u64 as NormalOut<i64x2>>::Output

fn _sub(self, rhs: i64x2) -> <u64 as NormalOut<i64x2>>::Output

fn _mul(self, rhs: i64x2) -> <u64 as NormalOut<i64x2>>::Output

fn _pow(self, rhs: i64x2) -> <u64 as NormalOut<i64x2>>::Output

fn _max(self, rhs: i64x2) -> <u64 as NormalOut<i64x2>>::Output

fn _min(self, rhs: i64x2) -> <u64 as NormalOut<i64x2>>::Output

fn _rem(self, rhs: i64x2) -> <u64 as NormalOut<i64x2>>::Output

fn _clamp(self, min: i64x2, max: i64x2) -> <u64 as NormalOut<i64x2>>::Output

fn _mul_add(self, a: i64x2, b: i64x2) -> <u64 as NormalOut<i64x2>>::Output

impl NormalOut<i64x2> for usize

type Output = <usizex2 as NormalOutPromote<i64x2>>::Output

fn _add(self, rhs: i64x2) -> <usize as NormalOut<i64x2>>::Output

fn _sub(self, rhs: i64x2) -> <usize as NormalOut<i64x2>>::Output

fn _mul(self, rhs: i64x2) -> <usize as NormalOut<i64x2>>::Output

fn _pow(self, rhs: i64x2) -> <usize as NormalOut<i64x2>>::Output

fn _max(self, rhs: i64x2) -> <usize as NormalOut<i64x2>>::Output

fn _min(self, rhs: i64x2) -> <usize as NormalOut<i64x2>>::Output

fn _rem(self, rhs: i64x2) -> <usize as NormalOut<i64x2>>::Output

fn _clamp(self, min: i64x2, max: i64x2) -> <usize as NormalOut<i64x2>>::Output

fn _mul_add(self, a: i64x2, b: i64x2) -> <usize as NormalOut<i64x2>>::Output

impl NormalOut<i64x2> for bf16

type Output = <bf16x8 as NormalOutPromote<i64x2>>::Output

fn _mul_add(self, a: i64x2, b: i64x2) -> <bf16 as NormalOut<i64x2>>::Output

fn _add(self, rhs: i64x2) -> <bf16 as NormalOut<i64x2>>::Output

fn _sub(self, rhs: i64x2) -> <bf16 as NormalOut<i64x2>>::Output

fn _mul(self, rhs: i64x2) -> <bf16 as NormalOut<i64x2>>::Output

fn _pow(self, rhs: i64x2) -> <bf16 as NormalOut<i64x2>>::Output

fn _rem(self, rhs: i64x2) -> <bf16 as NormalOut<i64x2>>::Output

fn _clamp(self, min: i64x2, max: i64x2) -> <bf16 as NormalOut<i64x2>>::Output

fn _max(self, rhs: i64x2) -> <bf16 as NormalOut<i64x2>>::Output

fn _min(self, rhs: i64x2) -> <bf16 as NormalOut<i64x2>>::Output

impl NormalOut<i64x2> for f16

type Output = <f16x8 as NormalOutPromote<i64x2>>::Output

fn _mul_add(self, a: i64x2, b: i64x2) -> <f16 as NormalOut<i64x2>>::Output

fn _add(self, rhs: i64x2) -> <f16 as NormalOut<i64x2>>::Output

fn _sub(self, rhs: i64x2) -> <f16 as NormalOut<i64x2>>::Output

fn _mul(self, rhs: i64x2) -> <f16 as NormalOut<i64x2>>::Output

fn _pow(self, rhs: i64x2) -> <f16 as NormalOut<i64x2>>::Output

fn _rem(self, rhs: i64x2) -> <f16 as NormalOut<i64x2>>::Output

fn _clamp(self, min: i64x2, max: i64x2) -> <f16 as NormalOut<i64x2>>::Output

fn _max(self, rhs: i64x2) -> <f16 as NormalOut<i64x2>>::Output

fn _min(self, rhs: i64x2) -> <f16 as NormalOut<i64x2>>::Output

impl NormalOut<i64x2> for Complex<f32>

type Output = <cplx32x2 as NormalOutPromote<i64x2>>::Output

fn _add(self, rhs: i64x2) -> <Complex<f32> as NormalOut<i64x2>>::Output

fn _sub(self, rhs: i64x2) -> <Complex<f32> as NormalOut<i64x2>>::Output

fn _mul(self, rhs: i64x2) -> <Complex<f32> as NormalOut<i64x2>>::Output

fn _pow(self, rhs: i64x2) -> <Complex<f32> as NormalOut<i64x2>>::Output

fn _max(self, rhs: i64x2) -> <Complex<f32> as NormalOut<i64x2>>::Output

fn _min(self, rhs: i64x2) -> <Complex<f32> as NormalOut<i64x2>>::Output

fn _rem(self, rhs: i64x2) -> <Complex<f32> as NormalOut<i64x2>>::Output

fn _clamp( self, min: i64x2, max: i64x2, ) -> <Complex<f32> as NormalOut<i64x2>>::Output

fn _mul_add( self, a: i64x2, b: i64x2, ) -> <Complex<f32> as NormalOut<i64x2>>::Output

impl NormalOut<i64x2> for Complex<f64>

type Output = <cplx64x1 as NormalOutPromote<i64x2>>::Output

fn _mul_add( self, a: i64x2, b: i64x2, ) -> <Complex<f64> as NormalOut<i64x2>>::Output

fn _add(self, rhs: i64x2) -> <Complex<f64> as NormalOut<i64x2>>::Output

fn _sub(self, rhs: i64x2) -> <Complex<f64> as NormalOut<i64x2>>::Output

fn _mul(self, rhs: i64x2) -> <Complex<f64> as NormalOut<i64x2>>::Output

fn _pow(self, rhs: i64x2) -> <Complex<f64> as NormalOut<i64x2>>::Output

fn _rem(self, rhs: i64x2) -> <Complex<f64> as NormalOut<i64x2>>::Output

fn _clamp( self, min: i64x2, max: i64x2, ) -> <Complex<f64> as NormalOut<i64x2>>::Output

fn _max(self, rhs: i64x2) -> <Complex<f64> as NormalOut<i64x2>>::Output

fn _min(self, rhs: i64x2) -> <Complex<f64> as NormalOut<i64x2>>::Output

impl NormalOut<isizex2> for bool

type Output = <boolx16 as NormalOutPromote<isizex2>>::Output

fn _mul_add( self, a: isizex2, b: isizex2, ) -> <bool as NormalOut<isizex2>>::Output

fn _add(self, rhs: isizex2) -> <bool as NormalOut<isizex2>>::Output

fn _sub(self, rhs: isizex2) -> <bool as NormalOut<isizex2>>::Output

fn _mul(self, rhs: isizex2) -> <bool as NormalOut<isizex2>>::Output

fn _pow(self, rhs: isizex2) -> <bool as NormalOut<isizex2>>::Output

fn _rem(self, rhs: isizex2) -> <bool as NormalOut<isizex2>>::Output

fn _clamp( self, min: isizex2, max: isizex2, ) -> <bool as NormalOut<isizex2>>::Output

fn _max(self, rhs: isizex2) -> <bool as NormalOut<isizex2>>::Output

fn _min(self, rhs: isizex2) -> <bool as NormalOut<isizex2>>::Output

impl NormalOut<isizex2> for f32

type Output = <f32x4 as NormalOutPromote<isizex2>>::Output

fn _mul_add(self, a: isizex2, b: isizex2) -> <f32 as NormalOut<isizex2>>::Output

fn _add(self, rhs: isizex2) -> <f32 as NormalOut<isizex2>>::Output

fn _sub(self, rhs: isizex2) -> <f32 as NormalOut<isizex2>>::Output

fn _mul(self, rhs: isizex2) -> <f32 as NormalOut<isizex2>>::Output

fn _pow(self, rhs: isizex2) -> <f32 as NormalOut<isizex2>>::Output

fn _rem(self, rhs: isizex2) -> <f32 as NormalOut<isizex2>>::Output

fn _clamp( self, min: isizex2, max: isizex2, ) -> <f32 as NormalOut<isizex2>>::Output

fn _max(self, rhs: isizex2) -> <f32 as NormalOut<isizex2>>::Output

fn _min(self, rhs: isizex2) -> <f32 as NormalOut<isizex2>>::Output

impl NormalOut<isizex2> for f64

type Output = <f64x2 as NormalOutPromote<isizex2>>::Output

fn _add(self, rhs: isizex2) -> <f64 as NormalOut<isizex2>>::Output

fn _sub(self, rhs: isizex2) -> <f64 as NormalOut<isizex2>>::Output

fn _mul(self, rhs: isizex2) -> <f64 as NormalOut<isizex2>>::Output

fn _pow(self, rhs: isizex2) -> <f64 as NormalOut<isizex2>>::Output

fn _max(self, rhs: isizex2) -> <f64 as NormalOut<isizex2>>::Output

fn _min(self, rhs: isizex2) -> <f64 as NormalOut<isizex2>>::Output

fn _rem(self, rhs: isizex2) -> <f64 as NormalOut<isizex2>>::Output

fn _clamp( self, min: isizex2, max: isizex2, ) -> <f64 as NormalOut<isizex2>>::Output

fn _mul_add(self, a: isizex2, b: isizex2) -> <f64 as NormalOut<isizex2>>::Output

impl NormalOut<isizex2> for i8

type Output = <i8x16 as NormalOutPromote<isizex2>>::Output

fn _mul_add(self, a: isizex2, b: isizex2) -> <i8 as NormalOut<isizex2>>::Output

fn _add(self, rhs: isizex2) -> <i8 as NormalOut<isizex2>>::Output

fn _sub(self, rhs: isizex2) -> <i8 as NormalOut<isizex2>>::Output

fn _mul(self, rhs: isizex2) -> <i8 as NormalOut<isizex2>>::Output

fn _pow(self, rhs: isizex2) -> <i8 as NormalOut<isizex2>>::Output

fn _rem(self, rhs: isizex2) -> <i8 as NormalOut<isizex2>>::Output

fn _clamp( self, min: isizex2, max: isizex2, ) -> <i8 as NormalOut<isizex2>>::Output

fn _max(self, rhs: isizex2) -> <i8 as NormalOut<isizex2>>::Output

fn _min(self, rhs: isizex2) -> <i8 as NormalOut<isizex2>>::Output

impl NormalOut<isizex2> for i16

type Output = <i16x8 as NormalOutPromote<isizex2>>::Output

fn _mul_add(self, a: isizex2, b: isizex2) -> <i16 as NormalOut<isizex2>>::Output

fn _add(self, rhs: isizex2) -> <i16 as NormalOut<isizex2>>::Output

fn _sub(self, rhs: isizex2) -> <i16 as NormalOut<isizex2>>::Output

fn _mul(self, rhs: isizex2) -> <i16 as NormalOut<isizex2>>::Output

fn _pow(self, rhs: isizex2) -> <i16 as NormalOut<isizex2>>::Output

fn _rem(self, rhs: isizex2) -> <i16 as NormalOut<isizex2>>::Output

fn _clamp( self, min: isizex2, max: isizex2, ) -> <i16 as NormalOut<isizex2>>::Output

fn _max(self, rhs: isizex2) -> <i16 as NormalOut<isizex2>>::Output

fn _min(self, rhs: isizex2) -> <i16 as NormalOut<isizex2>>::Output

impl NormalOut<isizex2> for i32

type Output = <i32x4 as NormalOutPromote<isizex2>>::Output

fn _mul_add(self, a: isizex2, b: isizex2) -> <i32 as NormalOut<isizex2>>::Output

fn _add(self, rhs: isizex2) -> <i32 as NormalOut<isizex2>>::Output

fn _sub(self, rhs: isizex2) -> <i32 as NormalOut<isizex2>>::Output

fn _mul(self, rhs: isizex2) -> <i32 as NormalOut<isizex2>>::Output

fn _pow(self, rhs: isizex2) -> <i32 as NormalOut<isizex2>>::Output

fn _rem(self, rhs: isizex2) -> <i32 as NormalOut<isizex2>>::Output

fn _clamp( self, min: isizex2, max: isizex2, ) -> <i32 as NormalOut<isizex2>>::Output

fn _max(self, rhs: isizex2) -> <i32 as NormalOut<isizex2>>::Output

fn _min(self, rhs: isizex2) -> <i32 as NormalOut<isizex2>>::Output

impl NormalOut<isizex2> for i64

type Output = <i64x2 as NormalOutPromote<isizex2>>::Output

fn _add(self, rhs: isizex2) -> <i64 as NormalOut<isizex2>>::Output

fn _sub(self, rhs: isizex2) -> <i64 as NormalOut<isizex2>>::Output

fn _mul(self, rhs: isizex2) -> <i64 as NormalOut<isizex2>>::Output

fn _pow(self, rhs: isizex2) -> <i64 as NormalOut<isizex2>>::Output

fn _max(self, rhs: isizex2) -> <i64 as NormalOut<isizex2>>::Output

fn _min(self, rhs: isizex2) -> <i64 as NormalOut<isizex2>>::Output

fn _rem(self, rhs: isizex2) -> <i64 as NormalOut<isizex2>>::Output

fn _clamp( self, min: isizex2, max: isizex2, ) -> <i64 as NormalOut<isizex2>>::Output

fn _mul_add(self, a: isizex2, b: isizex2) -> <i64 as NormalOut<isizex2>>::Output

impl NormalOut<isizex2> for isize

type Output = <isizex2 as NormalOutPromote>::Output

fn _add(self, rhs: isizex2) -> <isize as NormalOut<isizex2>>::Output

fn _sub(self, rhs: isizex2) -> <isize as NormalOut<isizex2>>::Output

fn _mul(self, rhs: isizex2) -> <isize as NormalOut<isizex2>>::Output

fn _pow(self, rhs: isizex2) -> <isize as NormalOut<isizex2>>::Output

fn _max(self, rhs: isizex2) -> <isize as NormalOut<isizex2>>::Output

fn _min(self, rhs: isizex2) -> <isize as NormalOut<isizex2>>::Output

fn _rem(self, rhs: isizex2) -> <isize as NormalOut<isizex2>>::Output

fn _clamp( self, min: isizex2, max: isizex2, ) -> <isize as NormalOut<isizex2>>::Output

fn _mul_add( self, a: isizex2, b: isizex2, ) -> <isize as NormalOut<isizex2>>::Output

impl NormalOut<isizex2> for u8

type Output = <u8x16 as NormalOutPromote<isizex2>>::Output

fn _mul_add(self, a: isizex2, b: isizex2) -> <u8 as NormalOut<isizex2>>::Output

fn _add(self, rhs: isizex2) -> <u8 as NormalOut<isizex2>>::Output

fn _sub(self, rhs: isizex2) -> <u8 as NormalOut<isizex2>>::Output

fn _mul(self, rhs: isizex2) -> <u8 as NormalOut<isizex2>>::Output

fn _pow(self, rhs: isizex2) -> <u8 as NormalOut<isizex2>>::Output

fn _rem(self, rhs: isizex2) -> <u8 as NormalOut<isizex2>>::Output

fn _clamp( self, min: isizex2, max: isizex2, ) -> <u8 as NormalOut<isizex2>>::Output

fn _max(self, rhs: isizex2) -> <u8 as NormalOut<isizex2>>::Output

fn _min(self, rhs: isizex2) -> <u8 as NormalOut<isizex2>>::Output

impl NormalOut<isizex2> for u16

type Output = <u16x8 as NormalOutPromote<isizex2>>::Output

fn _mul_add(self, a: isizex2, b: isizex2) -> <u16 as NormalOut<isizex2>>::Output

fn _add(self, rhs: isizex2) -> <u16 as NormalOut<isizex2>>::Output

fn _sub(self, rhs: isizex2) -> <u16 as NormalOut<isizex2>>::Output

fn _mul(self, rhs: isizex2) -> <u16 as NormalOut<isizex2>>::Output

fn _pow(self, rhs: isizex2) -> <u16 as NormalOut<isizex2>>::Output

fn _rem(self, rhs: isizex2) -> <u16 as NormalOut<isizex2>>::Output

fn _clamp( self, min: isizex2, max: isizex2, ) -> <u16 as NormalOut<isizex2>>::Output

fn _max(self, rhs: isizex2) -> <u16 as NormalOut<isizex2>>::Output

fn _min(self, rhs: isizex2) -> <u16 as NormalOut<isizex2>>::Output

impl NormalOut<isizex2> for u32

type Output = <u32x4 as NormalOutPromote<isizex2>>::Output

fn _mul_add(self, a: isizex2, b: isizex2) -> <u32 as NormalOut<isizex2>>::Output

fn _add(self, rhs: isizex2) -> <u32 as NormalOut<isizex2>>::Output

fn _sub(self, rhs: isizex2) -> <u32 as NormalOut<isizex2>>::Output

fn _mul(self, rhs: isizex2) -> <u32 as NormalOut<isizex2>>::Output

fn _pow(self, rhs: isizex2) -> <u32 as NormalOut<isizex2>>::Output

fn _rem(self, rhs: isizex2) -> <u32 as NormalOut<isizex2>>::Output

fn _clamp( self, min: isizex2, max: isizex2, ) -> <u32 as NormalOut<isizex2>>::Output

fn _max(self, rhs: isizex2) -> <u32 as NormalOut<isizex2>>::Output

fn _min(self, rhs: isizex2) -> <u32 as NormalOut<isizex2>>::Output

impl NormalOut<isizex2> for u64

type Output = <u64x2 as NormalOutPromote<isizex2>>::Output

fn _add(self, rhs: isizex2) -> <u64 as NormalOut<isizex2>>::Output

fn _sub(self, rhs: isizex2) -> <u64 as NormalOut<isizex2>>::Output

fn _mul(self, rhs: isizex2) -> <u64 as NormalOut<isizex2>>::Output

fn _pow(self, rhs: isizex2) -> <u64 as NormalOut<isizex2>>::Output

fn _max(self, rhs: isizex2) -> <u64 as NormalOut<isizex2>>::Output

fn _min(self, rhs: isizex2) -> <u64 as NormalOut<isizex2>>::Output

fn _rem(self, rhs: isizex2) -> <u64 as NormalOut<isizex2>>::Output

fn _clamp( self, min: isizex2, max: isizex2, ) -> <u64 as NormalOut<isizex2>>::Output

fn _mul_add(self, a: isizex2, b: isizex2) -> <u64 as NormalOut<isizex2>>::Output

impl NormalOut<isizex2> for usize

type Output = <usizex2 as NormalOutPromote<isizex2>>::Output

fn _add(self, rhs: isizex2) -> <usize as NormalOut<isizex2>>::Output

fn _sub(self, rhs: isizex2) -> <usize as NormalOut<isizex2>>::Output

fn _mul(self, rhs: isizex2) -> <usize as NormalOut<isizex2>>::Output

fn _pow(self, rhs: isizex2) -> <usize as NormalOut<isizex2>>::Output

fn _max(self, rhs: isizex2) -> <usize as NormalOut<isizex2>>::Output

fn _min(self, rhs: isizex2) -> <usize as NormalOut<isizex2>>::Output

fn _rem(self, rhs: isizex2) -> <usize as NormalOut<isizex2>>::Output

fn _clamp( self, min: isizex2, max: isizex2, ) -> <usize as NormalOut<isizex2>>::Output

fn _mul_add( self, a: isizex2, b: isizex2, ) -> <usize as NormalOut<isizex2>>::Output

impl NormalOut<isizex2> for bf16

type Output = <bf16x8 as NormalOutPromote<isizex2>>::Output

fn _mul_add( self, a: isizex2, b: isizex2, ) -> <bf16 as NormalOut<isizex2>>::Output

fn _add(self, rhs: isizex2) -> <bf16 as NormalOut<isizex2>>::Output

fn _sub(self, rhs: isizex2) -> <bf16 as NormalOut<isizex2>>::Output

fn _mul(self, rhs: isizex2) -> <bf16 as NormalOut<isizex2>>::Output

fn _pow(self, rhs: isizex2) -> <bf16 as NormalOut<isizex2>>::Output

fn _rem(self, rhs: isizex2) -> <bf16 as NormalOut<isizex2>>::Output

fn _clamp( self, min: isizex2, max: isizex2, ) -> <bf16 as NormalOut<isizex2>>::Output

fn _max(self, rhs: isizex2) -> <bf16 as NormalOut<isizex2>>::Output

fn _min(self, rhs: isizex2) -> <bf16 as NormalOut<isizex2>>::Output

impl NormalOut<isizex2> for f16

type Output = <f16x8 as NormalOutPromote<isizex2>>::Output

fn _mul_add(self, a: isizex2, b: isizex2) -> <f16 as NormalOut<isizex2>>::Output

fn _add(self, rhs: isizex2) -> <f16 as NormalOut<isizex2>>::Output

fn _sub(self, rhs: isizex2) -> <f16 as NormalOut<isizex2>>::Output

fn _mul(self, rhs: isizex2) -> <f16 as NormalOut<isizex2>>::Output

fn _pow(self, rhs: isizex2) -> <f16 as NormalOut<isizex2>>::Output

fn _rem(self, rhs: isizex2) -> <f16 as NormalOut<isizex2>>::Output

fn _clamp( self, min: isizex2, max: isizex2, ) -> <f16 as NormalOut<isizex2>>::Output

fn _max(self, rhs: isizex2) -> <f16 as NormalOut<isizex2>>::Output

fn _min(self, rhs: isizex2) -> <f16 as NormalOut<isizex2>>::Output

impl NormalOut<isizex2> for Complex<f32>

type Output = <cplx32x2 as NormalOutPromote<isizex2>>::Output

fn _add(self, rhs: isizex2) -> <Complex<f32> as NormalOut<isizex2>>::Output

fn _sub(self, rhs: isizex2) -> <Complex<f32> as NormalOut<isizex2>>::Output

fn _mul(self, rhs: isizex2) -> <Complex<f32> as NormalOut<isizex2>>::Output

fn _pow(self, rhs: isizex2) -> <Complex<f32> as NormalOut<isizex2>>::Output

fn _max(self, rhs: isizex2) -> <Complex<f32> as NormalOut<isizex2>>::Output

fn _min(self, rhs: isizex2) -> <Complex<f32> as NormalOut<isizex2>>::Output

fn _rem(self, rhs: isizex2) -> <Complex<f32> as NormalOut<isizex2>>::Output

fn _clamp( self, min: isizex2, max: isizex2, ) -> <Complex<f32> as NormalOut<isizex2>>::Output

fn _mul_add( self, a: isizex2, b: isizex2, ) -> <Complex<f32> as NormalOut<isizex2>>::Output

impl NormalOut<isizex2> for Complex<f64>

type Output = <cplx64x1 as NormalOutPromote<isizex2>>::Output

fn _mul_add( self, a: isizex2, b: isizex2, ) -> <Complex<f64> as NormalOut<isizex2>>::Output

fn _add(self, rhs: isizex2) -> <Complex<f64> as NormalOut<isizex2>>::Output

fn _sub(self, rhs: isizex2) -> <Complex<f64> as NormalOut<isizex2>>::Output

fn _mul(self, rhs: isizex2) -> <Complex<f64> as NormalOut<isizex2>>::Output

fn _pow(self, rhs: isizex2) -> <Complex<f64> as NormalOut<isizex2>>::Output

fn _rem(self, rhs: isizex2) -> <Complex<f64> as NormalOut<isizex2>>::Output

fn _clamp( self, min: isizex2, max: isizex2, ) -> <Complex<f64> as NormalOut<isizex2>>::Output

fn _max(self, rhs: isizex2) -> <Complex<f64> as NormalOut<isizex2>>::Output

fn _min(self, rhs: isizex2) -> <Complex<f64> as NormalOut<isizex2>>::Output

impl NormalOut<u8x16> for bool

type Output = <boolx16 as NormalOutPromote<u8x16>>::Output

fn _add(self, rhs: u8x16) -> <bool as NormalOut<u8x16>>::Output

fn _sub(self, rhs: u8x16) -> <bool as NormalOut<u8x16>>::Output

fn _mul(self, rhs: u8x16) -> <bool as NormalOut<u8x16>>::Output

fn _pow(self, rhs: u8x16) -> <bool as NormalOut<u8x16>>::Output

fn _max(self, rhs: u8x16) -> <bool as NormalOut<u8x16>>::Output

fn _min(self, rhs: u8x16) -> <bool as NormalOut<u8x16>>::Output

fn _rem(self, rhs: u8x16) -> <bool as NormalOut<u8x16>>::Output

fn _clamp(self, min: u8x16, max: u8x16) -> <bool as NormalOut<u8x16>>::Output

fn _mul_add(self, a: u8x16, b: u8x16) -> <bool as NormalOut<u8x16>>::Output

impl NormalOut<u8x16> for f32

type Output = <f32x4 as NormalOutPromote<u8x16>>::Output

fn _mul_add(self, a: u8x16, b: u8x16) -> <f32 as NormalOut<u8x16>>::Output

fn _add(self, rhs: u8x16) -> <f32 as NormalOut<u8x16>>::Output

fn _sub(self, rhs: u8x16) -> <f32 as NormalOut<u8x16>>::Output

fn _mul(self, rhs: u8x16) -> <f32 as NormalOut<u8x16>>::Output

fn _pow(self, rhs: u8x16) -> <f32 as NormalOut<u8x16>>::Output

fn _rem(self, rhs: u8x16) -> <f32 as NormalOut<u8x16>>::Output

fn _clamp(self, min: u8x16, max: u8x16) -> <f32 as NormalOut<u8x16>>::Output

fn _max(self, rhs: u8x16) -> <f32 as NormalOut<u8x16>>::Output

fn _min(self, rhs: u8x16) -> <f32 as NormalOut<u8x16>>::Output

impl NormalOut<u8x16> for f64

type Output = <f64x2 as NormalOutPromote<u8x16>>::Output

fn _mul_add(self, a: u8x16, b: u8x16) -> <f64 as NormalOut<u8x16>>::Output

fn _add(self, rhs: u8x16) -> <f64 as NormalOut<u8x16>>::Output

fn _sub(self, rhs: u8x16) -> <f64 as NormalOut<u8x16>>::Output

fn _mul(self, rhs: u8x16) -> <f64 as NormalOut<u8x16>>::Output

fn _pow(self, rhs: u8x16) -> <f64 as NormalOut<u8x16>>::Output

fn _rem(self, rhs: u8x16) -> <f64 as NormalOut<u8x16>>::Output

fn _clamp(self, min: u8x16, max: u8x16) -> <f64 as NormalOut<u8x16>>::Output

fn _max(self, rhs: u8x16) -> <f64 as NormalOut<u8x16>>::Output

fn _min(self, rhs: u8x16) -> <f64 as NormalOut<u8x16>>::Output

impl NormalOut<u8x16> for i8

type Output = <i8x16 as NormalOutPromote<u8x16>>::Output

fn _add(self, rhs: u8x16) -> <i8 as NormalOut<u8x16>>::Output

fn _sub(self, rhs: u8x16) -> <i8 as NormalOut<u8x16>>::Output

fn _mul(self, rhs: u8x16) -> <i8 as NormalOut<u8x16>>::Output

fn _pow(self, rhs: u8x16) -> <i8 as NormalOut<u8x16>>::Output

fn _max(self, rhs: u8x16) -> <i8 as NormalOut<u8x16>>::Output

fn _min(self, rhs: u8x16) -> <i8 as NormalOut<u8x16>>::Output

fn _rem(self, rhs: u8x16) -> <i8 as NormalOut<u8x16>>::Output

fn _clamp(self, min: u8x16, max: u8x16) -> <i8 as NormalOut<u8x16>>::Output

fn _mul_add(self, a: u8x16, b: u8x16) -> <i8 as NormalOut<u8x16>>::Output

impl NormalOut<u8x16> for i16

type Output = <i16x8 as NormalOutPromote<u8x16>>::Output

fn _mul_add(self, a: u8x16, b: u8x16) -> <i16 as NormalOut<u8x16>>::Output

fn _add(self, rhs: u8x16) -> <i16 as NormalOut<u8x16>>::Output

fn _sub(self, rhs: u8x16) -> <i16 as NormalOut<u8x16>>::Output

fn _mul(self, rhs: u8x16) -> <i16 as NormalOut<u8x16>>::Output

fn _pow(self, rhs: u8x16) -> <i16 as NormalOut<u8x16>>::Output

fn _rem(self, rhs: u8x16) -> <i16 as NormalOut<u8x16>>::Output

fn _clamp(self, min: u8x16, max: u8x16) -> <i16 as NormalOut<u8x16>>::Output

fn _max(self, rhs: u8x16) -> <i16 as NormalOut<u8x16>>::Output

fn _min(self, rhs: u8x16) -> <i16 as NormalOut<u8x16>>::Output

impl NormalOut<u8x16> for i32

type Output = <i32x4 as NormalOutPromote<u8x16>>::Output

fn _mul_add(self, a: u8x16, b: u8x16) -> <i32 as NormalOut<u8x16>>::Output

fn _add(self, rhs: u8x16) -> <i32 as NormalOut<u8x16>>::Output

fn _sub(self, rhs: u8x16) -> <i32 as NormalOut<u8x16>>::Output

fn _mul(self, rhs: u8x16) -> <i32 as NormalOut<u8x16>>::Output

fn _pow(self, rhs: u8x16) -> <i32 as NormalOut<u8x16>>::Output

fn _rem(self, rhs: u8x16) -> <i32 as NormalOut<u8x16>>::Output

fn _clamp(self, min: u8x16, max: u8x16) -> <i32 as NormalOut<u8x16>>::Output

fn _max(self, rhs: u8x16) -> <i32 as NormalOut<u8x16>>::Output

fn _min(self, rhs: u8x16) -> <i32 as NormalOut<u8x16>>::Output

impl NormalOut<u8x16> for i64

type Output = <i64x2 as NormalOutPromote<u8x16>>::Output

fn _mul_add(self, a: u8x16, b: u8x16) -> <i64 as NormalOut<u8x16>>::Output

fn _add(self, rhs: u8x16) -> <i64 as NormalOut<u8x16>>::Output

fn _sub(self, rhs: u8x16) -> <i64 as NormalOut<u8x16>>::Output

fn _mul(self, rhs: u8x16) -> <i64 as NormalOut<u8x16>>::Output

fn _pow(self, rhs: u8x16) -> <i64 as NormalOut<u8x16>>::Output

fn _rem(self, rhs: u8x16) -> <i64 as NormalOut<u8x16>>::Output

fn _clamp(self, min: u8x16, max: u8x16) -> <i64 as NormalOut<u8x16>>::Output

fn _max(self, rhs: u8x16) -> <i64 as NormalOut<u8x16>>::Output

fn _min(self, rhs: u8x16) -> <i64 as NormalOut<u8x16>>::Output

impl NormalOut<u8x16> for isize

type Output = <isizex2 as NormalOutPromote<u8x16>>::Output

fn _mul_add(self, a: u8x16, b: u8x16) -> <isize as NormalOut<u8x16>>::Output

fn _add(self, rhs: u8x16) -> <isize as NormalOut<u8x16>>::Output

fn _sub(self, rhs: u8x16) -> <isize as NormalOut<u8x16>>::Output

fn _mul(self, rhs: u8x16) -> <isize as NormalOut<u8x16>>::Output

fn _pow(self, rhs: u8x16) -> <isize as NormalOut<u8x16>>::Output

fn _rem(self, rhs: u8x16) -> <isize as NormalOut<u8x16>>::Output

fn _clamp(self, min: u8x16, max: u8x16) -> <isize as NormalOut<u8x16>>::Output

fn _max(self, rhs: u8x16) -> <isize as NormalOut<u8x16>>::Output

fn _min(self, rhs: u8x16) -> <isize as NormalOut<u8x16>>::Output

impl NormalOut<u8x16> for u8

type Output = <u8x16 as NormalOutPromote>::Output

fn _add(self, rhs: u8x16) -> <u8 as NormalOut<u8x16>>::Output

fn _sub(self, rhs: u8x16) -> <u8 as NormalOut<u8x16>>::Output

fn _mul(self, rhs: u8x16) -> <u8 as NormalOut<u8x16>>::Output

fn _pow(self, rhs: u8x16) -> <u8 as NormalOut<u8x16>>::Output

fn _max(self, rhs: u8x16) -> <u8 as NormalOut<u8x16>>::Output

fn _min(self, rhs: u8x16) -> <u8 as NormalOut<u8x16>>::Output

fn _rem(self, rhs: u8x16) -> <u8 as NormalOut<u8x16>>::Output

fn _clamp(self, min: u8x16, max: u8x16) -> <u8 as NormalOut<u8x16>>::Output

fn _mul_add(self, a: u8x16, b: u8x16) -> <u8 as NormalOut<u8x16>>::Output

impl NormalOut<u8x16> for u16

type Output = <u16x8 as NormalOutPromote<u8x16>>::Output

fn _mul_add(self, a: u8x16, b: u8x16) -> <u16 as NormalOut<u8x16>>::Output

fn _add(self, rhs: u8x16) -> <u16 as NormalOut<u8x16>>::Output

fn _sub(self, rhs: u8x16) -> <u16 as NormalOut<u8x16>>::Output

fn _mul(self, rhs: u8x16) -> <u16 as NormalOut<u8x16>>::Output

fn _pow(self, rhs: u8x16) -> <u16 as NormalOut<u8x16>>::Output

fn _rem(self, rhs: u8x16) -> <u16 as NormalOut<u8x16>>::Output

fn _clamp(self, min: u8x16, max: u8x16) -> <u16 as NormalOut<u8x16>>::Output

fn _max(self, rhs: u8x16) -> <u16 as NormalOut<u8x16>>::Output

fn _min(self, rhs: u8x16) -> <u16 as NormalOut<u8x16>>::Output

impl NormalOut<u8x16> for u32

type Output = <u32x4 as NormalOutPromote<u8x16>>::Output

fn _mul_add(self, a: u8x16, b: u8x16) -> <u32 as NormalOut<u8x16>>::Output

fn _add(self, rhs: u8x16) -> <u32 as NormalOut<u8x16>>::Output

fn _sub(self, rhs: u8x16) -> <u32 as NormalOut<u8x16>>::Output

fn _mul(self, rhs: u8x16) -> <u32 as NormalOut<u8x16>>::Output

fn _pow(self, rhs: u8x16) -> <u32 as NormalOut<u8x16>>::Output

fn _rem(self, rhs: u8x16) -> <u32 as NormalOut<u8x16>>::Output

fn _clamp(self, min: u8x16, max: u8x16) -> <u32 as NormalOut<u8x16>>::Output

fn _max(self, rhs: u8x16) -> <u32 as NormalOut<u8x16>>::Output

fn _min(self, rhs: u8x16) -> <u32 as NormalOut<u8x16>>::Output

impl NormalOut<u8x16> for u64

type Output = <u64x2 as NormalOutPromote<u8x16>>::Output

fn _mul_add(self, a: u8x16, b: u8x16) -> <u64 as NormalOut<u8x16>>::Output

fn _add(self, rhs: u8x16) -> <u64 as NormalOut<u8x16>>::Output

fn _sub(self, rhs: u8x16) -> <u64 as NormalOut<u8x16>>::Output

fn _mul(self, rhs: u8x16) -> <u64 as NormalOut<u8x16>>::Output

fn _pow(self, rhs: u8x16) -> <u64 as NormalOut<u8x16>>::Output

fn _rem(self, rhs: u8x16) -> <u64 as NormalOut<u8x16>>::Output

fn _clamp(self, min: u8x16, max: u8x16) -> <u64 as NormalOut<u8x16>>::Output

fn _max(self, rhs: u8x16) -> <u64 as NormalOut<u8x16>>::Output

fn _min(self, rhs: u8x16) -> <u64 as NormalOut<u8x16>>::Output

impl NormalOut<u8x16> for usize

type Output = <usizex2 as NormalOutPromote<u8x16>>::Output

fn _mul_add(self, a: u8x16, b: u8x16) -> <usize as NormalOut<u8x16>>::Output

fn _add(self, rhs: u8x16) -> <usize as NormalOut<u8x16>>::Output

fn _sub(self, rhs: u8x16) -> <usize as NormalOut<u8x16>>::Output

fn _mul(self, rhs: u8x16) -> <usize as NormalOut<u8x16>>::Output

fn _pow(self, rhs: u8x16) -> <usize as NormalOut<u8x16>>::Output

fn _rem(self, rhs: u8x16) -> <usize as NormalOut<u8x16>>::Output

fn _clamp(self, min: u8x16, max: u8x16) -> <usize as NormalOut<u8x16>>::Output

fn _max(self, rhs: u8x16) -> <usize as NormalOut<u8x16>>::Output

fn _min(self, rhs: u8x16) -> <usize as NormalOut<u8x16>>::Output

impl NormalOut<u8x16> for bf16

type Output = <bf16x8 as NormalOutPromote<u8x16>>::Output

fn _mul_add(self, a: u8x16, b: u8x16) -> <bf16 as NormalOut<u8x16>>::Output

fn _add(self, rhs: u8x16) -> <bf16 as NormalOut<u8x16>>::Output

fn _sub(self, rhs: u8x16) -> <bf16 as NormalOut<u8x16>>::Output

fn _mul(self, rhs: u8x16) -> <bf16 as NormalOut<u8x16>>::Output

fn _pow(self, rhs: u8x16) -> <bf16 as NormalOut<u8x16>>::Output

fn _rem(self, rhs: u8x16) -> <bf16 as NormalOut<u8x16>>::Output

fn _clamp(self, min: u8x16, max: u8x16) -> <bf16 as NormalOut<u8x16>>::Output

fn _max(self, rhs: u8x16) -> <bf16 as NormalOut<u8x16>>::Output

fn _min(self, rhs: u8x16) -> <bf16 as NormalOut<u8x16>>::Output

impl NormalOut<u8x16> for f16

type Output = <f16x8 as NormalOutPromote<u8x16>>::Output

fn _mul_add(self, a: u8x16, b: u8x16) -> <f16 as NormalOut<u8x16>>::Output

fn _add(self, rhs: u8x16) -> <f16 as NormalOut<u8x16>>::Output

fn _sub(self, rhs: u8x16) -> <f16 as NormalOut<u8x16>>::Output

fn _mul(self, rhs: u8x16) -> <f16 as NormalOut<u8x16>>::Output

fn _pow(self, rhs: u8x16) -> <f16 as NormalOut<u8x16>>::Output

fn _rem(self, rhs: u8x16) -> <f16 as NormalOut<u8x16>>::Output

fn _clamp(self, min: u8x16, max: u8x16) -> <f16 as NormalOut<u8x16>>::Output

fn _max(self, rhs: u8x16) -> <f16 as NormalOut<u8x16>>::Output

fn _min(self, rhs: u8x16) -> <f16 as NormalOut<u8x16>>::Output

impl NormalOut<u8x16> for Complex<f32>

type Output = <cplx32x2 as NormalOutPromote<u8x16>>::Output

fn _mul_add( self, a: u8x16, b: u8x16, ) -> <Complex<f32> as NormalOut<u8x16>>::Output

fn _add(self, rhs: u8x16) -> <Complex<f32> as NormalOut<u8x16>>::Output

fn _sub(self, rhs: u8x16) -> <Complex<f32> as NormalOut<u8x16>>::Output

fn _mul(self, rhs: u8x16) -> <Complex<f32> as NormalOut<u8x16>>::Output

fn _pow(self, rhs: u8x16) -> <Complex<f32> as NormalOut<u8x16>>::Output

fn _rem(self, rhs: u8x16) -> <Complex<f32> as NormalOut<u8x16>>::Output

fn _clamp( self, min: u8x16, max: u8x16, ) -> <Complex<f32> as NormalOut<u8x16>>::Output

fn _max(self, rhs: u8x16) -> <Complex<f32> as NormalOut<u8x16>>::Output

fn _min(self, rhs: u8x16) -> <Complex<f32> as NormalOut<u8x16>>::Output

impl NormalOut<u8x16> for Complex<f64>

type Output = <cplx64x1 as NormalOutPromote<u8x16>>::Output

fn _mul_add( self, a: u8x16, b: u8x16, ) -> <Complex<f64> as NormalOut<u8x16>>::Output

fn _add(self, rhs: u8x16) -> <Complex<f64> as NormalOut<u8x16>>::Output

fn _sub(self, rhs: u8x16) -> <Complex<f64> as NormalOut<u8x16>>::Output

fn _mul(self, rhs: u8x16) -> <Complex<f64> as NormalOut<u8x16>>::Output

fn _pow(self, rhs: u8x16) -> <Complex<f64> as NormalOut<u8x16>>::Output

fn _rem(self, rhs: u8x16) -> <Complex<f64> as NormalOut<u8x16>>::Output

fn _clamp( self, min: u8x16, max: u8x16, ) -> <Complex<f64> as NormalOut<u8x16>>::Output

fn _max(self, rhs: u8x16) -> <Complex<f64> as NormalOut<u8x16>>::Output

fn _min(self, rhs: u8x16) -> <Complex<f64> as NormalOut<u8x16>>::Output

impl NormalOut<u16x8> for bool

type Output = <boolx16 as NormalOutPromote<u16x8>>::Output

fn _mul_add(self, a: u16x8, b: u16x8) -> <bool as NormalOut<u16x8>>::Output

fn _add(self, rhs: u16x8) -> <bool as NormalOut<u16x8>>::Output

fn _sub(self, rhs: u16x8) -> <bool as NormalOut<u16x8>>::Output

fn _mul(self, rhs: u16x8) -> <bool as NormalOut<u16x8>>::Output

fn _pow(self, rhs: u16x8) -> <bool as NormalOut<u16x8>>::Output

fn _rem(self, rhs: u16x8) -> <bool as NormalOut<u16x8>>::Output

fn _clamp(self, min: u16x8, max: u16x8) -> <bool as NormalOut<u16x8>>::Output

fn _max(self, rhs: u16x8) -> <bool as NormalOut<u16x8>>::Output

fn _min(self, rhs: u16x8) -> <bool as NormalOut<u16x8>>::Output

impl NormalOut<u16x8> for f32

type Output = <f32x4 as NormalOutPromote<u16x8>>::Output

fn _mul_add(self, a: u16x8, b: u16x8) -> <f32 as NormalOut<u16x8>>::Output

fn _add(self, rhs: u16x8) -> <f32 as NormalOut<u16x8>>::Output

fn _sub(self, rhs: u16x8) -> <f32 as NormalOut<u16x8>>::Output

fn _mul(self, rhs: u16x8) -> <f32 as NormalOut<u16x8>>::Output

fn _pow(self, rhs: u16x8) -> <f32 as NormalOut<u16x8>>::Output

fn _rem(self, rhs: u16x8) -> <f32 as NormalOut<u16x8>>::Output

fn _clamp(self, min: u16x8, max: u16x8) -> <f32 as NormalOut<u16x8>>::Output

fn _max(self, rhs: u16x8) -> <f32 as NormalOut<u16x8>>::Output

fn _min(self, rhs: u16x8) -> <f32 as NormalOut<u16x8>>::Output

impl NormalOut<u16x8> for f64

type Output = <f64x2 as NormalOutPromote<u16x8>>::Output

fn _mul_add(self, a: u16x8, b: u16x8) -> <f64 as NormalOut<u16x8>>::Output

fn _add(self, rhs: u16x8) -> <f64 as NormalOut<u16x8>>::Output

fn _sub(self, rhs: u16x8) -> <f64 as NormalOut<u16x8>>::Output

fn _mul(self, rhs: u16x8) -> <f64 as NormalOut<u16x8>>::Output

fn _pow(self, rhs: u16x8) -> <f64 as NormalOut<u16x8>>::Output

fn _rem(self, rhs: u16x8) -> <f64 as NormalOut<u16x8>>::Output

fn _clamp(self, min: u16x8, max: u16x8) -> <f64 as NormalOut<u16x8>>::Output

fn _max(self, rhs: u16x8) -> <f64 as NormalOut<u16x8>>::Output

fn _min(self, rhs: u16x8) -> <f64 as NormalOut<u16x8>>::Output

impl NormalOut<u16x8> for i8

type Output = <i8x16 as NormalOutPromote<u16x8>>::Output

fn _mul_add(self, a: u16x8, b: u16x8) -> <i8 as NormalOut<u16x8>>::Output

fn _add(self, rhs: u16x8) -> <i8 as NormalOut<u16x8>>::Output

fn _sub(self, rhs: u16x8) -> <i8 as NormalOut<u16x8>>::Output

fn _mul(self, rhs: u16x8) -> <i8 as NormalOut<u16x8>>::Output

fn _pow(self, rhs: u16x8) -> <i8 as NormalOut<u16x8>>::Output

fn _rem(self, rhs: u16x8) -> <i8 as NormalOut<u16x8>>::Output

fn _clamp(self, min: u16x8, max: u16x8) -> <i8 as NormalOut<u16x8>>::Output

fn _max(self, rhs: u16x8) -> <i8 as NormalOut<u16x8>>::Output

fn _min(self, rhs: u16x8) -> <i8 as NormalOut<u16x8>>::Output

impl NormalOut<u16x8> for i16

type Output = <i16x8 as NormalOutPromote<u16x8>>::Output

fn _add(self, rhs: u16x8) -> <i16 as NormalOut<u16x8>>::Output

fn _sub(self, rhs: u16x8) -> <i16 as NormalOut<u16x8>>::Output

fn _mul(self, rhs: u16x8) -> <i16 as NormalOut<u16x8>>::Output

fn _pow(self, rhs: u16x8) -> <i16 as NormalOut<u16x8>>::Output

fn _max(self, rhs: u16x8) -> <i16 as NormalOut<u16x8>>::Output

fn _min(self, rhs: u16x8) -> <i16 as NormalOut<u16x8>>::Output

fn _rem(self, rhs: u16x8) -> <i16 as NormalOut<u16x8>>::Output

fn _clamp(self, min: u16x8, max: u16x8) -> <i16 as NormalOut<u16x8>>::Output

fn _mul_add(self, a: u16x8, b: u16x8) -> <i16 as NormalOut<u16x8>>::Output

impl NormalOut<u16x8> for i32

type Output = <i32x4 as NormalOutPromote<u16x8>>::Output

fn _mul_add(self, a: u16x8, b: u16x8) -> <i32 as NormalOut<u16x8>>::Output

fn _add(self, rhs: u16x8) -> <i32 as NormalOut<u16x8>>::Output

fn _sub(self, rhs: u16x8) -> <i32 as NormalOut<u16x8>>::Output

fn _mul(self, rhs: u16x8) -> <i32 as NormalOut<u16x8>>::Output

fn _pow(self, rhs: u16x8) -> <i32 as NormalOut<u16x8>>::Output

fn _rem(self, rhs: u16x8) -> <i32 as NormalOut<u16x8>>::Output

fn _clamp(self, min: u16x8, max: u16x8) -> <i32 as NormalOut<u16x8>>::Output

fn _max(self, rhs: u16x8) -> <i32 as NormalOut<u16x8>>::Output

fn _min(self, rhs: u16x8) -> <i32 as NormalOut<u16x8>>::Output

impl NormalOut<u16x8> for i64

type Output = <i64x2 as NormalOutPromote<u16x8>>::Output

fn _mul_add(self, a: u16x8, b: u16x8) -> <i64 as NormalOut<u16x8>>::Output

fn _add(self, rhs: u16x8) -> <i64 as NormalOut<u16x8>>::Output

fn _sub(self, rhs: u16x8) -> <i64 as NormalOut<u16x8>>::Output

fn _mul(self, rhs: u16x8) -> <i64 as NormalOut<u16x8>>::Output

fn _pow(self, rhs: u16x8) -> <i64 as NormalOut<u16x8>>::Output

fn _rem(self, rhs: u16x8) -> <i64 as NormalOut<u16x8>>::Output

fn _clamp(self, min: u16x8, max: u16x8) -> <i64 as NormalOut<u16x8>>::Output

fn _max(self, rhs: u16x8) -> <i64 as NormalOut<u16x8>>::Output

fn _min(self, rhs: u16x8) -> <i64 as NormalOut<u16x8>>::Output

impl NormalOut<u16x8> for isize

type Output = <isizex2 as NormalOutPromote<u16x8>>::Output

fn _mul_add(self, a: u16x8, b: u16x8) -> <isize as NormalOut<u16x8>>::Output

fn _add(self, rhs: u16x8) -> <isize as NormalOut<u16x8>>::Output

fn _sub(self, rhs: u16x8) -> <isize as NormalOut<u16x8>>::Output

fn _mul(self, rhs: u16x8) -> <isize as NormalOut<u16x8>>::Output

fn _pow(self, rhs: u16x8) -> <isize as NormalOut<u16x8>>::Output

fn _rem(self, rhs: u16x8) -> <isize as NormalOut<u16x8>>::Output

fn _clamp(self, min: u16x8, max: u16x8) -> <isize as NormalOut<u16x8>>::Output

fn _max(self, rhs: u16x8) -> <isize as NormalOut<u16x8>>::Output

fn _min(self, rhs: u16x8) -> <isize as NormalOut<u16x8>>::Output

impl NormalOut<u16x8> for u8

type Output = <u8x16 as NormalOutPromote<u16x8>>::Output

fn _mul_add(self, a: u16x8, b: u16x8) -> <u8 as NormalOut<u16x8>>::Output

fn _add(self, rhs: u16x8) -> <u8 as NormalOut<u16x8>>::Output

fn _sub(self, rhs: u16x8) -> <u8 as NormalOut<u16x8>>::Output

fn _mul(self, rhs: u16x8) -> <u8 as NormalOut<u16x8>>::Output

fn _pow(self, rhs: u16x8) -> <u8 as NormalOut<u16x8>>::Output

fn _rem(self, rhs: u16x8) -> <u8 as NormalOut<u16x8>>::Output

fn _clamp(self, min: u16x8, max: u16x8) -> <u8 as NormalOut<u16x8>>::Output

fn _max(self, rhs: u16x8) -> <u8 as NormalOut<u16x8>>::Output

fn _min(self, rhs: u16x8) -> <u8 as NormalOut<u16x8>>::Output

impl NormalOut<u16x8> for u16

type Output = <u16x8 as NormalOutPromote>::Output

fn _add(self, rhs: u16x8) -> <u16 as NormalOut<u16x8>>::Output

fn _sub(self, rhs: u16x8) -> <u16 as NormalOut<u16x8>>::Output

fn _mul(self, rhs: u16x8) -> <u16 as NormalOut<u16x8>>::Output

fn _pow(self, rhs: u16x8) -> <u16 as NormalOut<u16x8>>::Output

fn _max(self, rhs: u16x8) -> <u16 as NormalOut<u16x8>>::Output

fn _min(self, rhs: u16x8) -> <u16 as NormalOut<u16x8>>::Output

fn _rem(self, rhs: u16x8) -> <u16 as NormalOut<u16x8>>::Output

fn _clamp(self, min: u16x8, max: u16x8) -> <u16 as NormalOut<u16x8>>::Output

fn _mul_add(self, a: u16x8, b: u16x8) -> <u16 as NormalOut<u16x8>>::Output

impl NormalOut<u16x8> for u32

type Output = <u32x4 as NormalOutPromote<u16x8>>::Output

fn _mul_add(self, a: u16x8, b: u16x8) -> <u32 as NormalOut<u16x8>>::Output

fn _add(self, rhs: u16x8) -> <u32 as NormalOut<u16x8>>::Output

fn _sub(self, rhs: u16x8) -> <u32 as NormalOut<u16x8>>::Output

fn _mul(self, rhs: u16x8) -> <u32 as NormalOut<u16x8>>::Output

fn _pow(self, rhs: u16x8) -> <u32 as NormalOut<u16x8>>::Output

fn _rem(self, rhs: u16x8) -> <u32 as NormalOut<u16x8>>::Output

fn _clamp(self, min: u16x8, max: u16x8) -> <u32 as NormalOut<u16x8>>::Output

fn _max(self, rhs: u16x8) -> <u32 as NormalOut<u16x8>>::Output

fn _min(self, rhs: u16x8) -> <u32 as NormalOut<u16x8>>::Output

impl NormalOut<u16x8> for u64

type Output = <u64x2 as NormalOutPromote<u16x8>>::Output

fn _mul_add(self, a: u16x8, b: u16x8) -> <u64 as NormalOut<u16x8>>::Output

fn _add(self, rhs: u16x8) -> <u64 as NormalOut<u16x8>>::Output

fn _sub(self, rhs: u16x8) -> <u64 as NormalOut<u16x8>>::Output

fn _mul(self, rhs: u16x8) -> <u64 as NormalOut<u16x8>>::Output

fn _pow(self, rhs: u16x8) -> <u64 as NormalOut<u16x8>>::Output

fn _rem(self, rhs: u16x8) -> <u64 as NormalOut<u16x8>>::Output

fn _clamp(self, min: u16x8, max: u16x8) -> <u64 as NormalOut<u16x8>>::Output

fn _max(self, rhs: u16x8) -> <u64 as NormalOut<u16x8>>::Output

fn _min(self, rhs: u16x8) -> <u64 as NormalOut<u16x8>>::Output

impl NormalOut<u16x8> for usize

type Output = <usizex2 as NormalOutPromote<u16x8>>::Output

fn _mul_add(self, a: u16x8, b: u16x8) -> <usize as NormalOut<u16x8>>::Output

fn _add(self, rhs: u16x8) -> <usize as NormalOut<u16x8>>::Output

fn _sub(self, rhs: u16x8) -> <usize as NormalOut<u16x8>>::Output

fn _mul(self, rhs: u16x8) -> <usize as NormalOut<u16x8>>::Output

fn _pow(self, rhs: u16x8) -> <usize as NormalOut<u16x8>>::Output

fn _rem(self, rhs: u16x8) -> <usize as NormalOut<u16x8>>::Output

fn _clamp(self, min: u16x8, max: u16x8) -> <usize as NormalOut<u16x8>>::Output

fn _max(self, rhs: u16x8) -> <usize as NormalOut<u16x8>>::Output

fn _min(self, rhs: u16x8) -> <usize as NormalOut<u16x8>>::Output

impl NormalOut<u16x8> for bf16

type Output = <bf16x8 as NormalOutPromote<u16x8>>::Output

fn _add(self, rhs: u16x8) -> <bf16 as NormalOut<u16x8>>::Output

fn _sub(self, rhs: u16x8) -> <bf16 as NormalOut<u16x8>>::Output

fn _mul(self, rhs: u16x8) -> <bf16 as NormalOut<u16x8>>::Output

fn _pow(self, rhs: u16x8) -> <bf16 as NormalOut<u16x8>>::Output

fn _max(self, rhs: u16x8) -> <bf16 as NormalOut<u16x8>>::Output

fn _min(self, rhs: u16x8) -> <bf16 as NormalOut<u16x8>>::Output

fn _rem(self, rhs: u16x8) -> <bf16 as NormalOut<u16x8>>::Output

fn _clamp(self, min: u16x8, max: u16x8) -> <bf16 as NormalOut<u16x8>>::Output

fn _mul_add(self, a: u16x8, b: u16x8) -> <bf16 as NormalOut<u16x8>>::Output

impl NormalOut<u16x8> for f16

type Output = <f16x8 as NormalOutPromote<u16x8>>::Output

fn _add(self, rhs: u16x8) -> <f16 as NormalOut<u16x8>>::Output

fn _sub(self, rhs: u16x8) -> <f16 as NormalOut<u16x8>>::Output

fn _mul(self, rhs: u16x8) -> <f16 as NormalOut<u16x8>>::Output

fn _pow(self, rhs: u16x8) -> <f16 as NormalOut<u16x8>>::Output

fn _max(self, rhs: u16x8) -> <f16 as NormalOut<u16x8>>::Output

fn _min(self, rhs: u16x8) -> <f16 as NormalOut<u16x8>>::Output

fn _rem(self, rhs: u16x8) -> <f16 as NormalOut<u16x8>>::Output

fn _clamp(self, min: u16x8, max: u16x8) -> <f16 as NormalOut<u16x8>>::Output

fn _mul_add(self, a: u16x8, b: u16x8) -> <f16 as NormalOut<u16x8>>::Output

impl NormalOut<u16x8> for Complex<f32>

type Output = <cplx32x2 as NormalOutPromote<u16x8>>::Output

fn _mul_add( self, a: u16x8, b: u16x8, ) -> <Complex<f32> as NormalOut<u16x8>>::Output

fn _add(self, rhs: u16x8) -> <Complex<f32> as NormalOut<u16x8>>::Output

fn _sub(self, rhs: u16x8) -> <Complex<f32> as NormalOut<u16x8>>::Output

fn _mul(self, rhs: u16x8) -> <Complex<f32> as NormalOut<u16x8>>::Output

fn _pow(self, rhs: u16x8) -> <Complex<f32> as NormalOut<u16x8>>::Output

fn _rem(self, rhs: u16x8) -> <Complex<f32> as NormalOut<u16x8>>::Output

fn _clamp( self, min: u16x8, max: u16x8, ) -> <Complex<f32> as NormalOut<u16x8>>::Output

fn _max(self, rhs: u16x8) -> <Complex<f32> as NormalOut<u16x8>>::Output

fn _min(self, rhs: u16x8) -> <Complex<f32> as NormalOut<u16x8>>::Output

impl NormalOut<u16x8> for Complex<f64>

type Output = <cplx64x1 as NormalOutPromote<u16x8>>::Output

fn _mul_add( self, a: u16x8, b: u16x8, ) -> <Complex<f64> as NormalOut<u16x8>>::Output

fn _add(self, rhs: u16x8) -> <Complex<f64> as NormalOut<u16x8>>::Output

fn _sub(self, rhs: u16x8) -> <Complex<f64> as NormalOut<u16x8>>::Output

fn _mul(self, rhs: u16x8) -> <Complex<f64> as NormalOut<u16x8>>::Output

fn _pow(self, rhs: u16x8) -> <Complex<f64> as NormalOut<u16x8>>::Output

fn _rem(self, rhs: u16x8) -> <Complex<f64> as NormalOut<u16x8>>::Output

fn _clamp( self, min: u16x8, max: u16x8, ) -> <Complex<f64> as NormalOut<u16x8>>::Output

fn _max(self, rhs: u16x8) -> <Complex<f64> as NormalOut<u16x8>>::Output

fn _min(self, rhs: u16x8) -> <Complex<f64> as NormalOut<u16x8>>::Output

impl NormalOut<u32x4> for bool

type Output = <boolx16 as NormalOutPromote<u32x4>>::Output

fn _mul_add(self, a: u32x4, b: u32x4) -> <bool as NormalOut<u32x4>>::Output

fn _add(self, rhs: u32x4) -> <bool as NormalOut<u32x4>>::Output

fn _sub(self, rhs: u32x4) -> <bool as NormalOut<u32x4>>::Output

fn _mul(self, rhs: u32x4) -> <bool as NormalOut<u32x4>>::Output

fn _pow(self, rhs: u32x4) -> <bool as NormalOut<u32x4>>::Output

fn _rem(self, rhs: u32x4) -> <bool as NormalOut<u32x4>>::Output

fn _clamp(self, min: u32x4, max: u32x4) -> <bool as NormalOut<u32x4>>::Output

fn _max(self, rhs: u32x4) -> <bool as NormalOut<u32x4>>::Output

fn _min(self, rhs: u32x4) -> <bool as NormalOut<u32x4>>::Output

impl NormalOut<u32x4> for f32

type Output = <f32x4 as NormalOutPromote<u32x4>>::Output

fn _add(self, rhs: u32x4) -> <f32 as NormalOut<u32x4>>::Output

fn _sub(self, rhs: u32x4) -> <f32 as NormalOut<u32x4>>::Output

fn _mul(self, rhs: u32x4) -> <f32 as NormalOut<u32x4>>::Output

fn _pow(self, rhs: u32x4) -> <f32 as NormalOut<u32x4>>::Output

fn _max(self, rhs: u32x4) -> <f32 as NormalOut<u32x4>>::Output

fn _min(self, rhs: u32x4) -> <f32 as NormalOut<u32x4>>::Output

fn _rem(self, rhs: u32x4) -> <f32 as NormalOut<u32x4>>::Output

fn _clamp(self, min: u32x4, max: u32x4) -> <f32 as NormalOut<u32x4>>::Output

fn _mul_add(self, a: u32x4, b: u32x4) -> <f32 as NormalOut<u32x4>>::Output

impl NormalOut<u32x4> for f64

type Output = <f64x2 as NormalOutPromote<u32x4>>::Output

fn _mul_add(self, a: u32x4, b: u32x4) -> <f64 as NormalOut<u32x4>>::Output

fn _add(self, rhs: u32x4) -> <f64 as NormalOut<u32x4>>::Output

fn _sub(self, rhs: u32x4) -> <f64 as NormalOut<u32x4>>::Output

fn _mul(self, rhs: u32x4) -> <f64 as NormalOut<u32x4>>::Output

fn _pow(self, rhs: u32x4) -> <f64 as NormalOut<u32x4>>::Output

fn _rem(self, rhs: u32x4) -> <f64 as NormalOut<u32x4>>::Output

fn _clamp(self, min: u32x4, max: u32x4) -> <f64 as NormalOut<u32x4>>::Output

fn _max(self, rhs: u32x4) -> <f64 as NormalOut<u32x4>>::Output

fn _min(self, rhs: u32x4) -> <f64 as NormalOut<u32x4>>::Output

impl NormalOut<u32x4> for i8

type Output = <i8x16 as NormalOutPromote<u32x4>>::Output

fn _mul_add(self, a: u32x4, b: u32x4) -> <i8 as NormalOut<u32x4>>::Output

fn _add(self, rhs: u32x4) -> <i8 as NormalOut<u32x4>>::Output

fn _sub(self, rhs: u32x4) -> <i8 as NormalOut<u32x4>>::Output

fn _mul(self, rhs: u32x4) -> <i8 as NormalOut<u32x4>>::Output

fn _pow(self, rhs: u32x4) -> <i8 as NormalOut<u32x4>>::Output

fn _rem(self, rhs: u32x4) -> <i8 as NormalOut<u32x4>>::Output

fn _clamp(self, min: u32x4, max: u32x4) -> <i8 as NormalOut<u32x4>>::Output

fn _max(self, rhs: u32x4) -> <i8 as NormalOut<u32x4>>::Output

fn _min(self, rhs: u32x4) -> <i8 as NormalOut<u32x4>>::Output

impl NormalOut<u32x4> for i16

type Output = <i16x8 as NormalOutPromote<u32x4>>::Output

fn _mul_add(self, a: u32x4, b: u32x4) -> <i16 as NormalOut<u32x4>>::Output

fn _add(self, rhs: u32x4) -> <i16 as NormalOut<u32x4>>::Output

fn _sub(self, rhs: u32x4) -> <i16 as NormalOut<u32x4>>::Output

fn _mul(self, rhs: u32x4) -> <i16 as NormalOut<u32x4>>::Output

fn _pow(self, rhs: u32x4) -> <i16 as NormalOut<u32x4>>::Output

fn _rem(self, rhs: u32x4) -> <i16 as NormalOut<u32x4>>::Output

fn _clamp(self, min: u32x4, max: u32x4) -> <i16 as NormalOut<u32x4>>::Output

fn _max(self, rhs: u32x4) -> <i16 as NormalOut<u32x4>>::Output

fn _min(self, rhs: u32x4) -> <i16 as NormalOut<u32x4>>::Output

impl NormalOut<u32x4> for i32

type Output = <i32x4 as NormalOutPromote<u32x4>>::Output

fn _add(self, rhs: u32x4) -> <i32 as NormalOut<u32x4>>::Output

fn _sub(self, rhs: u32x4) -> <i32 as NormalOut<u32x4>>::Output

fn _mul(self, rhs: u32x4) -> <i32 as NormalOut<u32x4>>::Output

fn _pow(self, rhs: u32x4) -> <i32 as NormalOut<u32x4>>::Output

fn _max(self, rhs: u32x4) -> <i32 as NormalOut<u32x4>>::Output

fn _min(self, rhs: u32x4) -> <i32 as NormalOut<u32x4>>::Output

fn _rem(self, rhs: u32x4) -> <i32 as NormalOut<u32x4>>::Output

fn _clamp(self, min: u32x4, max: u32x4) -> <i32 as NormalOut<u32x4>>::Output

fn _mul_add(self, a: u32x4, b: u32x4) -> <i32 as NormalOut<u32x4>>::Output

impl NormalOut<u32x4> for i64

type Output = <i64x2 as NormalOutPromote<u32x4>>::Output

fn _mul_add(self, a: u32x4, b: u32x4) -> <i64 as NormalOut<u32x4>>::Output

fn _add(self, rhs: u32x4) -> <i64 as NormalOut<u32x4>>::Output

fn _sub(self, rhs: u32x4) -> <i64 as NormalOut<u32x4>>::Output

fn _mul(self, rhs: u32x4) -> <i64 as NormalOut<u32x4>>::Output

fn _pow(self, rhs: u32x4) -> <i64 as NormalOut<u32x4>>::Output

fn _rem(self, rhs: u32x4) -> <i64 as NormalOut<u32x4>>::Output

fn _clamp(self, min: u32x4, max: u32x4) -> <i64 as NormalOut<u32x4>>::Output

fn _max(self, rhs: u32x4) -> <i64 as NormalOut<u32x4>>::Output

fn _min(self, rhs: u32x4) -> <i64 as NormalOut<u32x4>>::Output

impl NormalOut<u32x4> for isize

type Output = <isizex2 as NormalOutPromote<u32x4>>::Output

fn _mul_add(self, a: u32x4, b: u32x4) -> <isize as NormalOut<u32x4>>::Output

fn _add(self, rhs: u32x4) -> <isize as NormalOut<u32x4>>::Output

fn _sub(self, rhs: u32x4) -> <isize as NormalOut<u32x4>>::Output

fn _mul(self, rhs: u32x4) -> <isize as NormalOut<u32x4>>::Output

fn _pow(self, rhs: u32x4) -> <isize as NormalOut<u32x4>>::Output

fn _rem(self, rhs: u32x4) -> <isize as NormalOut<u32x4>>::Output

fn _clamp(self, min: u32x4, max: u32x4) -> <isize as NormalOut<u32x4>>::Output

fn _max(self, rhs: u32x4) -> <isize as NormalOut<u32x4>>::Output

fn _min(self, rhs: u32x4) -> <isize as NormalOut<u32x4>>::Output

impl NormalOut<u32x4> for u8

type Output = <u8x16 as NormalOutPromote<u32x4>>::Output

fn _mul_add(self, a: u32x4, b: u32x4) -> <u8 as NormalOut<u32x4>>::Output

fn _add(self, rhs: u32x4) -> <u8 as NormalOut<u32x4>>::Output

fn _sub(self, rhs: u32x4) -> <u8 as NormalOut<u32x4>>::Output

fn _mul(self, rhs: u32x4) -> <u8 as NormalOut<u32x4>>::Output

fn _pow(self, rhs: u32x4) -> <u8 as NormalOut<u32x4>>::Output

fn _rem(self, rhs: u32x4) -> <u8 as NormalOut<u32x4>>::Output

fn _clamp(self, min: u32x4, max: u32x4) -> <u8 as NormalOut<u32x4>>::Output

fn _max(self, rhs: u32x4) -> <u8 as NormalOut<u32x4>>::Output

fn _min(self, rhs: u32x4) -> <u8 as NormalOut<u32x4>>::Output

impl NormalOut<u32x4> for u16

type Output = <u16x8 as NormalOutPromote<u32x4>>::Output

fn _mul_add(self, a: u32x4, b: u32x4) -> <u16 as NormalOut<u32x4>>::Output

fn _add(self, rhs: u32x4) -> <u16 as NormalOut<u32x4>>::Output

fn _sub(self, rhs: u32x4) -> <u16 as NormalOut<u32x4>>::Output

fn _mul(self, rhs: u32x4) -> <u16 as NormalOut<u32x4>>::Output

fn _pow(self, rhs: u32x4) -> <u16 as NormalOut<u32x4>>::Output

fn _rem(self, rhs: u32x4) -> <u16 as NormalOut<u32x4>>::Output

fn _clamp(self, min: u32x4, max: u32x4) -> <u16 as NormalOut<u32x4>>::Output

fn _max(self, rhs: u32x4) -> <u16 as NormalOut<u32x4>>::Output

fn _min(self, rhs: u32x4) -> <u16 as NormalOut<u32x4>>::Output

impl NormalOut<u32x4> for u32

type Output = <u32x4 as NormalOutPromote>::Output

fn _add(self, rhs: u32x4) -> <u32 as NormalOut<u32x4>>::Output

fn _sub(self, rhs: u32x4) -> <u32 as NormalOut<u32x4>>::Output

fn _mul(self, rhs: u32x4) -> <u32 as NormalOut<u32x4>>::Output

fn _pow(self, rhs: u32x4) -> <u32 as NormalOut<u32x4>>::Output

fn _max(self, rhs: u32x4) -> <u32 as NormalOut<u32x4>>::Output

fn _min(self, rhs: u32x4) -> <u32 as NormalOut<u32x4>>::Output

fn _rem(self, rhs: u32x4) -> <u32 as NormalOut<u32x4>>::Output

fn _clamp(self, min: u32x4, max: u32x4) -> <u32 as NormalOut<u32x4>>::Output

fn _mul_add(self, a: u32x4, b: u32x4) -> <u32 as NormalOut<u32x4>>::Output

impl NormalOut<u32x4> for u64

type Output = <u64x2 as NormalOutPromote<u32x4>>::Output

fn _mul_add(self, a: u32x4, b: u32x4) -> <u64 as NormalOut<u32x4>>::Output

fn _add(self, rhs: u32x4) -> <u64 as NormalOut<u32x4>>::Output

fn _sub(self, rhs: u32x4) -> <u64 as NormalOut<u32x4>>::Output

fn _mul(self, rhs: u32x4) -> <u64 as NormalOut<u32x4>>::Output

fn _pow(self, rhs: u32x4) -> <u64 as NormalOut<u32x4>>::Output

fn _rem(self, rhs: u32x4) -> <u64 as NormalOut<u32x4>>::Output

fn _clamp(self, min: u32x4, max: u32x4) -> <u64 as NormalOut<u32x4>>::Output

fn _max(self, rhs: u32x4) -> <u64 as NormalOut<u32x4>>::Output

fn _min(self, rhs: u32x4) -> <u64 as NormalOut<u32x4>>::Output

impl NormalOut<u32x4> for usize

type Output = <usizex2 as NormalOutPromote<u32x4>>::Output

fn _mul_add(self, a: u32x4, b: u32x4) -> <usize as NormalOut<u32x4>>::Output

fn _add(self, rhs: u32x4) -> <usize as NormalOut<u32x4>>::Output

fn _sub(self, rhs: u32x4) -> <usize as NormalOut<u32x4>>::Output

fn _mul(self, rhs: u32x4) -> <usize as NormalOut<u32x4>>::Output

fn _pow(self, rhs: u32x4) -> <usize as NormalOut<u32x4>>::Output

fn _rem(self, rhs: u32x4) -> <usize as NormalOut<u32x4>>::Output

fn _clamp(self, min: u32x4, max: u32x4) -> <usize as NormalOut<u32x4>>::Output

fn _max(self, rhs: u32x4) -> <usize as NormalOut<u32x4>>::Output

fn _min(self, rhs: u32x4) -> <usize as NormalOut<u32x4>>::Output

impl NormalOut<u32x4> for bf16

type Output = <bf16x8 as NormalOutPromote<u32x4>>::Output

fn _mul_add(self, a: u32x4, b: u32x4) -> <bf16 as NormalOut<u32x4>>::Output

fn _add(self, rhs: u32x4) -> <bf16 as NormalOut<u32x4>>::Output

fn _sub(self, rhs: u32x4) -> <bf16 as NormalOut<u32x4>>::Output

fn _mul(self, rhs: u32x4) -> <bf16 as NormalOut<u32x4>>::Output

fn _pow(self, rhs: u32x4) -> <bf16 as NormalOut<u32x4>>::Output

fn _rem(self, rhs: u32x4) -> <bf16 as NormalOut<u32x4>>::Output

fn _clamp(self, min: u32x4, max: u32x4) -> <bf16 as NormalOut<u32x4>>::Output

fn _max(self, rhs: u32x4) -> <bf16 as NormalOut<u32x4>>::Output

fn _min(self, rhs: u32x4) -> <bf16 as NormalOut<u32x4>>::Output

impl NormalOut<u32x4> for f16

type Output = <f16x8 as NormalOutPromote<u32x4>>::Output

fn _mul_add(self, a: u32x4, b: u32x4) -> <f16 as NormalOut<u32x4>>::Output

fn _add(self, rhs: u32x4) -> <f16 as NormalOut<u32x4>>::Output

fn _sub(self, rhs: u32x4) -> <f16 as NormalOut<u32x4>>::Output

fn _mul(self, rhs: u32x4) -> <f16 as NormalOut<u32x4>>::Output

fn _pow(self, rhs: u32x4) -> <f16 as NormalOut<u32x4>>::Output

fn _rem(self, rhs: u32x4) -> <f16 as NormalOut<u32x4>>::Output

fn _clamp(self, min: u32x4, max: u32x4) -> <f16 as NormalOut<u32x4>>::Output

fn _max(self, rhs: u32x4) -> <f16 as NormalOut<u32x4>>::Output

fn _min(self, rhs: u32x4) -> <f16 as NormalOut<u32x4>>::Output

impl NormalOut<u32x4> for Complex<f32>

type Output = <cplx32x2 as NormalOutPromote<u32x4>>::Output

fn _mul_add( self, a: u32x4, b: u32x4, ) -> <Complex<f32> as NormalOut<u32x4>>::Output

fn _add(self, rhs: u32x4) -> <Complex<f32> as NormalOut<u32x4>>::Output

fn _sub(self, rhs: u32x4) -> <Complex<f32> as NormalOut<u32x4>>::Output

fn _mul(self, rhs: u32x4) -> <Complex<f32> as NormalOut<u32x4>>::Output

fn _pow(self, rhs: u32x4) -> <Complex<f32> as NormalOut<u32x4>>::Output

fn _rem(self, rhs: u32x4) -> <Complex<f32> as NormalOut<u32x4>>::Output

fn _clamp( self, min: u32x4, max: u32x4, ) -> <Complex<f32> as NormalOut<u32x4>>::Output

fn _max(self, rhs: u32x4) -> <Complex<f32> as NormalOut<u32x4>>::Output

fn _min(self, rhs: u32x4) -> <Complex<f32> as NormalOut<u32x4>>::Output

impl NormalOut<u32x4> for Complex<f64>

type Output = <cplx64x1 as NormalOutPromote<u32x4>>::Output

fn _mul_add( self, a: u32x4, b: u32x4, ) -> <Complex<f64> as NormalOut<u32x4>>::Output

fn _add(self, rhs: u32x4) -> <Complex<f64> as NormalOut<u32x4>>::Output

fn _sub(self, rhs: u32x4) -> <Complex<f64> as NormalOut<u32x4>>::Output

fn _mul(self, rhs: u32x4) -> <Complex<f64> as NormalOut<u32x4>>::Output

fn _pow(self, rhs: u32x4) -> <Complex<f64> as NormalOut<u32x4>>::Output

fn _rem(self, rhs: u32x4) -> <Complex<f64> as NormalOut<u32x4>>::Output

fn _clamp( self, min: u32x4, max: u32x4, ) -> <Complex<f64> as NormalOut<u32x4>>::Output

fn _max(self, rhs: u32x4) -> <Complex<f64> as NormalOut<u32x4>>::Output

fn _min(self, rhs: u32x4) -> <Complex<f64> as NormalOut<u32x4>>::Output

impl NormalOut<u64x2> for bool

type Output = <boolx16 as NormalOutPromote<u64x2>>::Output

fn _mul_add(self, a: u64x2, b: u64x2) -> <bool as NormalOut<u64x2>>::Output

fn _add(self, rhs: u64x2) -> <bool as NormalOut<u64x2>>::Output

fn _sub(self, rhs: u64x2) -> <bool as NormalOut<u64x2>>::Output

fn _mul(self, rhs: u64x2) -> <bool as NormalOut<u64x2>>::Output

fn _pow(self, rhs: u64x2) -> <bool as NormalOut<u64x2>>::Output

fn _rem(self, rhs: u64x2) -> <bool as NormalOut<u64x2>>::Output

fn _clamp(self, min: u64x2, max: u64x2) -> <bool as NormalOut<u64x2>>::Output

fn _max(self, rhs: u64x2) -> <bool as NormalOut<u64x2>>::Output

fn _min(self, rhs: u64x2) -> <bool as NormalOut<u64x2>>::Output

impl NormalOut<u64x2> for f32

type Output = <f32x4 as NormalOutPromote<u64x2>>::Output

fn _mul_add(self, a: u64x2, b: u64x2) -> <f32 as NormalOut<u64x2>>::Output

fn _add(self, rhs: u64x2) -> <f32 as NormalOut<u64x2>>::Output

fn _sub(self, rhs: u64x2) -> <f32 as NormalOut<u64x2>>::Output

fn _mul(self, rhs: u64x2) -> <f32 as NormalOut<u64x2>>::Output

fn _pow(self, rhs: u64x2) -> <f32 as NormalOut<u64x2>>::Output

fn _rem(self, rhs: u64x2) -> <f32 as NormalOut<u64x2>>::Output

fn _clamp(self, min: u64x2, max: u64x2) -> <f32 as NormalOut<u64x2>>::Output

fn _max(self, rhs: u64x2) -> <f32 as NormalOut<u64x2>>::Output

fn _min(self, rhs: u64x2) -> <f32 as NormalOut<u64x2>>::Output

impl NormalOut<u64x2> for f64

type Output = <f64x2 as NormalOutPromote<u64x2>>::Output

fn _add(self, rhs: u64x2) -> <f64 as NormalOut<u64x2>>::Output

fn _sub(self, rhs: u64x2) -> <f64 as NormalOut<u64x2>>::Output

fn _mul(self, rhs: u64x2) -> <f64 as NormalOut<u64x2>>::Output

fn _pow(self, rhs: u64x2) -> <f64 as NormalOut<u64x2>>::Output

fn _max(self, rhs: u64x2) -> <f64 as NormalOut<u64x2>>::Output

fn _min(self, rhs: u64x2) -> <f64 as NormalOut<u64x2>>::Output

fn _rem(self, rhs: u64x2) -> <f64 as NormalOut<u64x2>>::Output

fn _clamp(self, min: u64x2, max: u64x2) -> <f64 as NormalOut<u64x2>>::Output

fn _mul_add(self, a: u64x2, b: u64x2) -> <f64 as NormalOut<u64x2>>::Output

impl NormalOut<u64x2> for i8

type Output = <i8x16 as NormalOutPromote<u64x2>>::Output

fn _mul_add(self, a: u64x2, b: u64x2) -> <i8 as NormalOut<u64x2>>::Output

fn _add(self, rhs: u64x2) -> <i8 as NormalOut<u64x2>>::Output

fn _sub(self, rhs: u64x2) -> <i8 as NormalOut<u64x2>>::Output

fn _mul(self, rhs: u64x2) -> <i8 as NormalOut<u64x2>>::Output

fn _pow(self, rhs: u64x2) -> <i8 as NormalOut<u64x2>>::Output

fn _rem(self, rhs: u64x2) -> <i8 as NormalOut<u64x2>>::Output

fn _clamp(self, min: u64x2, max: u64x2) -> <i8 as NormalOut<u64x2>>::Output

fn _max(self, rhs: u64x2) -> <i8 as NormalOut<u64x2>>::Output

fn _min(self, rhs: u64x2) -> <i8 as NormalOut<u64x2>>::Output

impl NormalOut<u64x2> for i16

type Output = <i16x8 as NormalOutPromote<u64x2>>::Output

fn _mul_add(self, a: u64x2, b: u64x2) -> <i16 as NormalOut<u64x2>>::Output

fn _add(self, rhs: u64x2) -> <i16 as NormalOut<u64x2>>::Output

fn _sub(self, rhs: u64x2) -> <i16 as NormalOut<u64x2>>::Output

fn _mul(self, rhs: u64x2) -> <i16 as NormalOut<u64x2>>::Output

fn _pow(self, rhs: u64x2) -> <i16 as NormalOut<u64x2>>::Output

fn _rem(self, rhs: u64x2) -> <i16 as NormalOut<u64x2>>::Output

fn _clamp(self, min: u64x2, max: u64x2) -> <i16 as NormalOut<u64x2>>::Output

fn _max(self, rhs: u64x2) -> <i16 as NormalOut<u64x2>>::Output

fn _min(self, rhs: u64x2) -> <i16 as NormalOut<u64x2>>::Output

impl NormalOut<u64x2> for i32

type Output = <i32x4 as NormalOutPromote<u64x2>>::Output

fn _mul_add(self, a: u64x2, b: u64x2) -> <i32 as NormalOut<u64x2>>::Output

fn _add(self, rhs: u64x2) -> <i32 as NormalOut<u64x2>>::Output

fn _sub(self, rhs: u64x2) -> <i32 as NormalOut<u64x2>>::Output

fn _mul(self, rhs: u64x2) -> <i32 as NormalOut<u64x2>>::Output

fn _pow(self, rhs: u64x2) -> <i32 as NormalOut<u64x2>>::Output

fn _rem(self, rhs: u64x2) -> <i32 as NormalOut<u64x2>>::Output

fn _clamp(self, min: u64x2, max: u64x2) -> <i32 as NormalOut<u64x2>>::Output

fn _max(self, rhs: u64x2) -> <i32 as NormalOut<u64x2>>::Output

fn _min(self, rhs: u64x2) -> <i32 as NormalOut<u64x2>>::Output

impl NormalOut<u64x2> for i64

type Output = <i64x2 as NormalOutPromote<u64x2>>::Output

fn _add(self, rhs: u64x2) -> <i64 as NormalOut<u64x2>>::Output

fn _sub(self, rhs: u64x2) -> <i64 as NormalOut<u64x2>>::Output

fn _mul(self, rhs: u64x2) -> <i64 as NormalOut<u64x2>>::Output

fn _pow(self, rhs: u64x2) -> <i64 as NormalOut<u64x2>>::Output

fn _max(self, rhs: u64x2) -> <i64 as NormalOut<u64x2>>::Output

fn _min(self, rhs: u64x2) -> <i64 as NormalOut<u64x2>>::Output

fn _rem(self, rhs: u64x2) -> <i64 as NormalOut<u64x2>>::Output

fn _clamp(self, min: u64x2, max: u64x2) -> <i64 as NormalOut<u64x2>>::Output

fn _mul_add(self, a: u64x2, b: u64x2) -> <i64 as NormalOut<u64x2>>::Output

impl NormalOut<u64x2> for isize

type Output = <isizex2 as NormalOutPromote<u64x2>>::Output

fn _add(self, rhs: u64x2) -> <isize as NormalOut<u64x2>>::Output

fn _sub(self, rhs: u64x2) -> <isize as NormalOut<u64x2>>::Output

fn _mul(self, rhs: u64x2) -> <isize as NormalOut<u64x2>>::Output

fn _pow(self, rhs: u64x2) -> <isize as NormalOut<u64x2>>::Output

fn _max(self, rhs: u64x2) -> <isize as NormalOut<u64x2>>::Output

fn _min(self, rhs: u64x2) -> <isize as NormalOut<u64x2>>::Output

fn _rem(self, rhs: u64x2) -> <isize as NormalOut<u64x2>>::Output

fn _clamp(self, min: u64x2, max: u64x2) -> <isize as NormalOut<u64x2>>::Output

fn _mul_add(self, a: u64x2, b: u64x2) -> <isize as NormalOut<u64x2>>::Output

impl NormalOut<u64x2> for u8

type Output = <u8x16 as NormalOutPromote<u64x2>>::Output

fn _mul_add(self, a: u64x2, b: u64x2) -> <u8 as NormalOut<u64x2>>::Output

fn _add(self, rhs: u64x2) -> <u8 as NormalOut<u64x2>>::Output

fn _sub(self, rhs: u64x2) -> <u8 as NormalOut<u64x2>>::Output

fn _mul(self, rhs: u64x2) -> <u8 as NormalOut<u64x2>>::Output

fn _pow(self, rhs: u64x2) -> <u8 as NormalOut<u64x2>>::Output

fn _rem(self, rhs: u64x2) -> <u8 as NormalOut<u64x2>>::Output

fn _clamp(self, min: u64x2, max: u64x2) -> <u8 as NormalOut<u64x2>>::Output

fn _max(self, rhs: u64x2) -> <u8 as NormalOut<u64x2>>::Output

fn _min(self, rhs: u64x2) -> <u8 as NormalOut<u64x2>>::Output

impl NormalOut<u64x2> for u16

type Output = <u16x8 as NormalOutPromote<u64x2>>::Output

fn _mul_add(self, a: u64x2, b: u64x2) -> <u16 as NormalOut<u64x2>>::Output

fn _add(self, rhs: u64x2) -> <u16 as NormalOut<u64x2>>::Output

fn _sub(self, rhs: u64x2) -> <u16 as NormalOut<u64x2>>::Output

fn _mul(self, rhs: u64x2) -> <u16 as NormalOut<u64x2>>::Output

fn _pow(self, rhs: u64x2) -> <u16 as NormalOut<u64x2>>::Output

fn _rem(self, rhs: u64x2) -> <u16 as NormalOut<u64x2>>::Output

fn _clamp(self, min: u64x2, max: u64x2) -> <u16 as NormalOut<u64x2>>::Output

fn _max(self, rhs: u64x2) -> <u16 as NormalOut<u64x2>>::Output

fn _min(self, rhs: u64x2) -> <u16 as NormalOut<u64x2>>::Output

impl NormalOut<u64x2> for u32

type Output = <u32x4 as NormalOutPromote<u64x2>>::Output

fn _mul_add(self, a: u64x2, b: u64x2) -> <u32 as NormalOut<u64x2>>::Output

fn _add(self, rhs: u64x2) -> <u32 as NormalOut<u64x2>>::Output

fn _sub(self, rhs: u64x2) -> <u32 as NormalOut<u64x2>>::Output

fn _mul(self, rhs: u64x2) -> <u32 as NormalOut<u64x2>>::Output

fn _pow(self, rhs: u64x2) -> <u32 as NormalOut<u64x2>>::Output

fn _rem(self, rhs: u64x2) -> <u32 as NormalOut<u64x2>>::Output

fn _clamp(self, min: u64x2, max: u64x2) -> <u32 as NormalOut<u64x2>>::Output

fn _max(self, rhs: u64x2) -> <u32 as NormalOut<u64x2>>::Output

fn _min(self, rhs: u64x2) -> <u32 as NormalOut<u64x2>>::Output

impl NormalOut<u64x2> for u64

type Output = <u64x2 as NormalOutPromote>::Output

fn _add(self, rhs: u64x2) -> <u64 as NormalOut<u64x2>>::Output

fn _sub(self, rhs: u64x2) -> <u64 as NormalOut<u64x2>>::Output

fn _mul(self, rhs: u64x2) -> <u64 as NormalOut<u64x2>>::Output

fn _pow(self, rhs: u64x2) -> <u64 as NormalOut<u64x2>>::Output

fn _max(self, rhs: u64x2) -> <u64 as NormalOut<u64x2>>::Output

fn _min(self, rhs: u64x2) -> <u64 as NormalOut<u64x2>>::Output

fn _rem(self, rhs: u64x2) -> <u64 as NormalOut<u64x2>>::Output

fn _clamp(self, min: u64x2, max: u64x2) -> <u64 as NormalOut<u64x2>>::Output

fn _mul_add(self, a: u64x2, b: u64x2) -> <u64 as NormalOut<u64x2>>::Output

impl NormalOut<u64x2> for usize

type Output = <usizex2 as NormalOutPromote<u64x2>>::Output

fn _add(self, rhs: u64x2) -> <usize as NormalOut<u64x2>>::Output

fn _sub(self, rhs: u64x2) -> <usize as NormalOut<u64x2>>::Output

fn _mul(self, rhs: u64x2) -> <usize as NormalOut<u64x2>>::Output

fn _pow(self, rhs: u64x2) -> <usize as NormalOut<u64x2>>::Output

fn _max(self, rhs: u64x2) -> <usize as NormalOut<u64x2>>::Output

fn _min(self, rhs: u64x2) -> <usize as NormalOut<u64x2>>::Output

fn _rem(self, rhs: u64x2) -> <usize as NormalOut<u64x2>>::Output

fn _clamp(self, min: u64x2, max: u64x2) -> <usize as NormalOut<u64x2>>::Output

fn _mul_add(self, a: u64x2, b: u64x2) -> <usize as NormalOut<u64x2>>::Output

impl NormalOut<u64x2> for bf16

type Output = <bf16x8 as NormalOutPromote<u64x2>>::Output

fn _mul_add(self, a: u64x2, b: u64x2) -> <bf16 as NormalOut<u64x2>>::Output

fn _add(self, rhs: u64x2) -> <bf16 as NormalOut<u64x2>>::Output

fn _sub(self, rhs: u64x2) -> <bf16 as NormalOut<u64x2>>::Output

fn _mul(self, rhs: u64x2) -> <bf16 as NormalOut<u64x2>>::Output

fn _pow(self, rhs: u64x2) -> <bf16 as NormalOut<u64x2>>::Output

fn _rem(self, rhs: u64x2) -> <bf16 as NormalOut<u64x2>>::Output

fn _clamp(self, min: u64x2, max: u64x2) -> <bf16 as NormalOut<u64x2>>::Output

fn _max(self, rhs: u64x2) -> <bf16 as NormalOut<u64x2>>::Output

fn _min(self, rhs: u64x2) -> <bf16 as NormalOut<u64x2>>::Output

impl NormalOut<u64x2> for f16

type Output = <f16x8 as NormalOutPromote<u64x2>>::Output

fn _mul_add(self, a: u64x2, b: u64x2) -> <f16 as NormalOut<u64x2>>::Output

fn _add(self, rhs: u64x2) -> <f16 as NormalOut<u64x2>>::Output

fn _sub(self, rhs: u64x2) -> <f16 as NormalOut<u64x2>>::Output

fn _mul(self, rhs: u64x2) -> <f16 as NormalOut<u64x2>>::Output

fn _pow(self, rhs: u64x2) -> <f16 as NormalOut<u64x2>>::Output

fn _rem(self, rhs: u64x2) -> <f16 as NormalOut<u64x2>>::Output

fn _clamp(self, min: u64x2, max: u64x2) -> <f16 as NormalOut<u64x2>>::Output

fn _max(self, rhs: u64x2) -> <f16 as NormalOut<u64x2>>::Output

fn _min(self, rhs: u64x2) -> <f16 as NormalOut<u64x2>>::Output

impl NormalOut<u64x2> for Complex<f32>

type Output = <cplx32x2 as NormalOutPromote<u64x2>>::Output

fn _add(self, rhs: u64x2) -> <Complex<f32> as NormalOut<u64x2>>::Output

fn _sub(self, rhs: u64x2) -> <Complex<f32> as NormalOut<u64x2>>::Output

fn _mul(self, rhs: u64x2) -> <Complex<f32> as NormalOut<u64x2>>::Output

fn _pow(self, rhs: u64x2) -> <Complex<f32> as NormalOut<u64x2>>::Output

fn _max(self, rhs: u64x2) -> <Complex<f32> as NormalOut<u64x2>>::Output

fn _min(self, rhs: u64x2) -> <Complex<f32> as NormalOut<u64x2>>::Output

fn _rem(self, rhs: u64x2) -> <Complex<f32> as NormalOut<u64x2>>::Output

fn _clamp( self, min: u64x2, max: u64x2, ) -> <Complex<f32> as NormalOut<u64x2>>::Output

fn _mul_add( self, a: u64x2, b: u64x2, ) -> <Complex<f32> as NormalOut<u64x2>>::Output

impl NormalOut<u64x2> for Complex<f64>

type Output = <cplx64x1 as NormalOutPromote<u64x2>>::Output

fn _mul_add( self, a: u64x2, b: u64x2, ) -> <Complex<f64> as NormalOut<u64x2>>::Output

fn _add(self, rhs: u64x2) -> <Complex<f64> as NormalOut<u64x2>>::Output

fn _sub(self, rhs: u64x2) -> <Complex<f64> as NormalOut<u64x2>>::Output

fn _mul(self, rhs: u64x2) -> <Complex<f64> as NormalOut<u64x2>>::Output

fn _pow(self, rhs: u64x2) -> <Complex<f64> as NormalOut<u64x2>>::Output

fn _rem(self, rhs: u64x2) -> <Complex<f64> as NormalOut<u64x2>>::Output

fn _clamp( self, min: u64x2, max: u64x2, ) -> <Complex<f64> as NormalOut<u64x2>>::Output

fn _max(self, rhs: u64x2) -> <Complex<f64> as NormalOut<u64x2>>::Output

fn _min(self, rhs: u64x2) -> <Complex<f64> as NormalOut<u64x2>>::Output

impl NormalOut<usizex2> for bool

type Output = <boolx16 as NormalOutPromote<usizex2>>::Output

fn _mul_add( self, a: usizex2, b: usizex2, ) -> <bool as NormalOut<usizex2>>::Output

fn _add(self, rhs: usizex2) -> <bool as NormalOut<usizex2>>::Output

fn _sub(self, rhs: usizex2) -> <bool as NormalOut<usizex2>>::Output

fn _mul(self, rhs: usizex2) -> <bool as NormalOut<usizex2>>::Output

fn _pow(self, rhs: usizex2) -> <bool as NormalOut<usizex2>>::Output

fn _rem(self, rhs: usizex2) -> <bool as NormalOut<usizex2>>::Output

fn _clamp( self, min: usizex2, max: usizex2, ) -> <bool as NormalOut<usizex2>>::Output

fn _max(self, rhs: usizex2) -> <bool as NormalOut<usizex2>>::Output

fn _min(self, rhs: usizex2) -> <bool as NormalOut<usizex2>>::Output

impl NormalOut<usizex2> for f32

type Output = <f32x4 as NormalOutPromote<usizex2>>::Output

fn _mul_add(self, a: usizex2, b: usizex2) -> <f32 as NormalOut<usizex2>>::Output

fn _add(self, rhs: usizex2) -> <f32 as NormalOut<usizex2>>::Output

fn _sub(self, rhs: usizex2) -> <f32 as NormalOut<usizex2>>::Output

fn _mul(self, rhs: usizex2) -> <f32 as NormalOut<usizex2>>::Output

fn _pow(self, rhs: usizex2) -> <f32 as NormalOut<usizex2>>::Output

fn _rem(self, rhs: usizex2) -> <f32 as NormalOut<usizex2>>::Output

fn _clamp( self, min: usizex2, max: usizex2, ) -> <f32 as NormalOut<usizex2>>::Output

fn _max(self, rhs: usizex2) -> <f32 as NormalOut<usizex2>>::Output

fn _min(self, rhs: usizex2) -> <f32 as NormalOut<usizex2>>::Output

impl NormalOut<usizex2> for f64

type Output = <f64x2 as NormalOutPromote<usizex2>>::Output

fn _add(self, rhs: usizex2) -> <f64 as NormalOut<usizex2>>::Output

fn _sub(self, rhs: usizex2) -> <f64 as NormalOut<usizex2>>::Output

fn _mul(self, rhs: usizex2) -> <f64 as NormalOut<usizex2>>::Output

fn _pow(self, rhs: usizex2) -> <f64 as NormalOut<usizex2>>::Output

fn _max(self, rhs: usizex2) -> <f64 as NormalOut<usizex2>>::Output

fn _min(self, rhs: usizex2) -> <f64 as NormalOut<usizex2>>::Output

fn _rem(self, rhs: usizex2) -> <f64 as NormalOut<usizex2>>::Output

fn _clamp( self, min: usizex2, max: usizex2, ) -> <f64 as NormalOut<usizex2>>::Output

fn _mul_add(self, a: usizex2, b: usizex2) -> <f64 as NormalOut<usizex2>>::Output

impl NormalOut<usizex2> for i8

type Output = <i8x16 as NormalOutPromote<usizex2>>::Output

fn _mul_add(self, a: usizex2, b: usizex2) -> <i8 as NormalOut<usizex2>>::Output

fn _add(self, rhs: usizex2) -> <i8 as NormalOut<usizex2>>::Output

fn _sub(self, rhs: usizex2) -> <i8 as NormalOut<usizex2>>::Output

fn _mul(self, rhs: usizex2) -> <i8 as NormalOut<usizex2>>::Output

fn _pow(self, rhs: usizex2) -> <i8 as NormalOut<usizex2>>::Output

fn _rem(self, rhs: usizex2) -> <i8 as NormalOut<usizex2>>::Output

fn _clamp( self, min: usizex2, max: usizex2, ) -> <i8 as NormalOut<usizex2>>::Output

fn _max(self, rhs: usizex2) -> <i8 as NormalOut<usizex2>>::Output

fn _min(self, rhs: usizex2) -> <i8 as NormalOut<usizex2>>::Output

impl NormalOut<usizex2> for i16

type Output = <i16x8 as NormalOutPromote<usizex2>>::Output

fn _mul_add(self, a: usizex2, b: usizex2) -> <i16 as NormalOut<usizex2>>::Output

fn _add(self, rhs: usizex2) -> <i16 as NormalOut<usizex2>>::Output

fn _sub(self, rhs: usizex2) -> <i16 as NormalOut<usizex2>>::Output

fn _mul(self, rhs: usizex2) -> <i16 as NormalOut<usizex2>>::Output

fn _pow(self, rhs: usizex2) -> <i16 as NormalOut<usizex2>>::Output

fn _rem(self, rhs: usizex2) -> <i16 as NormalOut<usizex2>>::Output

fn _clamp( self, min: usizex2, max: usizex2, ) -> <i16 as NormalOut<usizex2>>::Output

fn _max(self, rhs: usizex2) -> <i16 as NormalOut<usizex2>>::Output

fn _min(self, rhs: usizex2) -> <i16 as NormalOut<usizex2>>::Output

impl NormalOut<usizex2> for i32

type Output = <i32x4 as NormalOutPromote<usizex2>>::Output

fn _mul_add(self, a: usizex2, b: usizex2) -> <i32 as NormalOut<usizex2>>::Output

fn _add(self, rhs: usizex2) -> <i32 as NormalOut<usizex2>>::Output

fn _sub(self, rhs: usizex2) -> <i32 as NormalOut<usizex2>>::Output

fn _mul(self, rhs: usizex2) -> <i32 as NormalOut<usizex2>>::Output

fn _pow(self, rhs: usizex2) -> <i32 as NormalOut<usizex2>>::Output

fn _rem(self, rhs: usizex2) -> <i32 as NormalOut<usizex2>>::Output

fn _clamp( self, min: usizex2, max: usizex2, ) -> <i32 as NormalOut<usizex2>>::Output

fn _max(self, rhs: usizex2) -> <i32 as NormalOut<usizex2>>::Output

fn _min(self, rhs: usizex2) -> <i32 as NormalOut<usizex2>>::Output

impl NormalOut<usizex2> for i64

type Output = <i64x2 as NormalOutPromote<usizex2>>::Output

fn _add(self, rhs: usizex2) -> <i64 as NormalOut<usizex2>>::Output

fn _sub(self, rhs: usizex2) -> <i64 as NormalOut<usizex2>>::Output

fn _mul(self, rhs: usizex2) -> <i64 as NormalOut<usizex2>>::Output

fn _pow(self, rhs: usizex2) -> <i64 as NormalOut<usizex2>>::Output

fn _max(self, rhs: usizex2) -> <i64 as NormalOut<usizex2>>::Output

fn _min(self, rhs: usizex2) -> <i64 as NormalOut<usizex2>>::Output

fn _rem(self, rhs: usizex2) -> <i64 as NormalOut<usizex2>>::Output

fn _clamp( self, min: usizex2, max: usizex2, ) -> <i64 as NormalOut<usizex2>>::Output

fn _mul_add(self, a: usizex2, b: usizex2) -> <i64 as NormalOut<usizex2>>::Output

impl NormalOut<usizex2> for isize

type Output = <isizex2 as NormalOutPromote<usizex2>>::Output

fn _add(self, rhs: usizex2) -> <isize as NormalOut<usizex2>>::Output

fn _sub(self, rhs: usizex2) -> <isize as NormalOut<usizex2>>::Output

fn _mul(self, rhs: usizex2) -> <isize as NormalOut<usizex2>>::Output

fn _pow(self, rhs: usizex2) -> <isize as NormalOut<usizex2>>::Output

fn _max(self, rhs: usizex2) -> <isize as NormalOut<usizex2>>::Output

fn _min(self, rhs: usizex2) -> <isize as NormalOut<usizex2>>::Output

fn _rem(self, rhs: usizex2) -> <isize as NormalOut<usizex2>>::Output

fn _clamp( self, min: usizex2, max: usizex2, ) -> <isize as NormalOut<usizex2>>::Output

fn _mul_add( self, a: usizex2, b: usizex2, ) -> <isize as NormalOut<usizex2>>::Output

impl NormalOut<usizex2> for u8

type Output = <u8x16 as NormalOutPromote<usizex2>>::Output

fn _mul_add(self, a: usizex2, b: usizex2) -> <u8 as NormalOut<usizex2>>::Output

fn _add(self, rhs: usizex2) -> <u8 as NormalOut<usizex2>>::Output

fn _sub(self, rhs: usizex2) -> <u8 as NormalOut<usizex2>>::Output

fn _mul(self, rhs: usizex2) -> <u8 as NormalOut<usizex2>>::Output

fn _pow(self, rhs: usizex2) -> <u8 as NormalOut<usizex2>>::Output

fn _rem(self, rhs: usizex2) -> <u8 as NormalOut<usizex2>>::Output

fn _clamp( self, min: usizex2, max: usizex2, ) -> <u8 as NormalOut<usizex2>>::Output

fn _max(self, rhs: usizex2) -> <u8 as NormalOut<usizex2>>::Output

fn _min(self, rhs: usizex2) -> <u8 as NormalOut<usizex2>>::Output

impl NormalOut<usizex2> for u16

type Output = <u16x8 as NormalOutPromote<usizex2>>::Output

fn _mul_add(self, a: usizex2, b: usizex2) -> <u16 as NormalOut<usizex2>>::Output

fn _add(self, rhs: usizex2) -> <u16 as NormalOut<usizex2>>::Output

fn _sub(self, rhs: usizex2) -> <u16 as NormalOut<usizex2>>::Output

fn _mul(self, rhs: usizex2) -> <u16 as NormalOut<usizex2>>::Output

fn _pow(self, rhs: usizex2) -> <u16 as NormalOut<usizex2>>::Output

fn _rem(self, rhs: usizex2) -> <u16 as NormalOut<usizex2>>::Output

fn _clamp( self, min: usizex2, max: usizex2, ) -> <u16 as NormalOut<usizex2>>::Output

fn _max(self, rhs: usizex2) -> <u16 as NormalOut<usizex2>>::Output

fn _min(self, rhs: usizex2) -> <u16 as NormalOut<usizex2>>::Output

impl NormalOut<usizex2> for u32

type Output = <u32x4 as NormalOutPromote<usizex2>>::Output

fn _mul_add(self, a: usizex2, b: usizex2) -> <u32 as NormalOut<usizex2>>::Output

fn _add(self, rhs: usizex2) -> <u32 as NormalOut<usizex2>>::Output

fn _sub(self, rhs: usizex2) -> <u32 as NormalOut<usizex2>>::Output

fn _mul(self, rhs: usizex2) -> <u32 as NormalOut<usizex2>>::Output

fn _pow(self, rhs: usizex2) -> <u32 as NormalOut<usizex2>>::Output

fn _rem(self, rhs: usizex2) -> <u32 as NormalOut<usizex2>>::Output

fn _clamp( self, min: usizex2, max: usizex2, ) -> <u32 as NormalOut<usizex2>>::Output

fn _max(self, rhs: usizex2) -> <u32 as NormalOut<usizex2>>::Output

fn _min(self, rhs: usizex2) -> <u32 as NormalOut<usizex2>>::Output

impl NormalOut<usizex2> for u64

type Output = <u64x2 as NormalOutPromote<usizex2>>::Output

fn _add(self, rhs: usizex2) -> <u64 as NormalOut<usizex2>>::Output

fn _sub(self, rhs: usizex2) -> <u64 as NormalOut<usizex2>>::Output

fn _mul(self, rhs: usizex2) -> <u64 as NormalOut<usizex2>>::Output

fn _pow(self, rhs: usizex2) -> <u64 as NormalOut<usizex2>>::Output

fn _max(self, rhs: usizex2) -> <u64 as NormalOut<usizex2>>::Output

fn _min(self, rhs: usizex2) -> <u64 as NormalOut<usizex2>>::Output

fn _rem(self, rhs: usizex2) -> <u64 as NormalOut<usizex2>>::Output

fn _clamp( self, min: usizex2, max: usizex2, ) -> <u64 as NormalOut<usizex2>>::Output

fn _mul_add(self, a: usizex2, b: usizex2) -> <u64 as NormalOut<usizex2>>::Output

impl NormalOut<usizex2> for usize

type Output = <usizex2 as NormalOutPromote>::Output

fn _add(self, rhs: usizex2) -> <usize as NormalOut<usizex2>>::Output

fn _sub(self, rhs: usizex2) -> <usize as NormalOut<usizex2>>::Output

fn _mul(self, rhs: usizex2) -> <usize as NormalOut<usizex2>>::Output

fn _pow(self, rhs: usizex2) -> <usize as NormalOut<usizex2>>::Output

fn _max(self, rhs: usizex2) -> <usize as NormalOut<usizex2>>::Output

fn _min(self, rhs: usizex2) -> <usize as NormalOut<usizex2>>::Output

fn _rem(self, rhs: usizex2) -> <usize as NormalOut<usizex2>>::Output

fn _clamp( self, min: usizex2, max: usizex2, ) -> <usize as NormalOut<usizex2>>::Output

fn _mul_add( self, a: usizex2, b: usizex2, ) -> <usize as NormalOut<usizex2>>::Output

impl NormalOut<usizex2> for bf16

type Output = <bf16x8 as NormalOutPromote<usizex2>>::Output

fn _mul_add( self, a: usizex2, b: usizex2, ) -> <bf16 as NormalOut<usizex2>>::Output

fn _add(self, rhs: usizex2) -> <bf16 as NormalOut<usizex2>>::Output

fn _sub(self, rhs: usizex2) -> <bf16 as NormalOut<usizex2>>::Output

fn _mul(self, rhs: usizex2) -> <bf16 as NormalOut<usizex2>>::Output

fn _pow(self, rhs: usizex2) -> <bf16 as NormalOut<usizex2>>::Output

fn _rem(self, rhs: usizex2) -> <bf16 as NormalOut<usizex2>>::Output

fn _clamp( self, min: usizex2, max: usizex2, ) -> <bf16 as NormalOut<usizex2>>::Output

fn _max(self, rhs: usizex2) -> <bf16 as NormalOut<usizex2>>::Output

fn _min(self, rhs: usizex2) -> <bf16 as NormalOut<usizex2>>::Output

impl NormalOut<usizex2> for f16

type Output = <f16x8 as NormalOutPromote<usizex2>>::Output

fn _mul_add(self, a: usizex2, b: usizex2) -> <f16 as NormalOut<usizex2>>::Output

fn _add(self, rhs: usizex2) -> <f16 as NormalOut<usizex2>>::Output

fn _sub(self, rhs: usizex2) -> <f16 as NormalOut<usizex2>>::Output

fn _mul(self, rhs: usizex2) -> <f16 as NormalOut<usizex2>>::Output

fn _pow(self, rhs: usizex2) -> <f16 as NormalOut<usizex2>>::Output

fn _rem(self, rhs: usizex2) -> <f16 as NormalOut<usizex2>>::Output

fn _clamp( self, min: usizex2, max: usizex2, ) -> <f16 as NormalOut<usizex2>>::Output

fn _max(self, rhs: usizex2) -> <f16 as NormalOut<usizex2>>::Output

fn _min(self, rhs: usizex2) -> <f16 as NormalOut<usizex2>>::Output

impl NormalOut<usizex2> for Complex<f32>

type Output = <cplx32x2 as NormalOutPromote<usizex2>>::Output

fn _add(self, rhs: usizex2) -> <Complex<f32> as NormalOut<usizex2>>::Output

fn _sub(self, rhs: usizex2) -> <Complex<f32> as NormalOut<usizex2>>::Output

fn _mul(self, rhs: usizex2) -> <Complex<f32> as NormalOut<usizex2>>::Output

fn _pow(self, rhs: usizex2) -> <Complex<f32> as NormalOut<usizex2>>::Output

fn _max(self, rhs: usizex2) -> <Complex<f32> as NormalOut<usizex2>>::Output

fn _min(self, rhs: usizex2) -> <Complex<f32> as NormalOut<usizex2>>::Output

fn _rem(self, rhs: usizex2) -> <Complex<f32> as NormalOut<usizex2>>::Output

fn _clamp( self, min: usizex2, max: usizex2, ) -> <Complex<f32> as NormalOut<usizex2>>::Output

fn _mul_add( self, a: usizex2, b: usizex2, ) -> <Complex<f32> as NormalOut<usizex2>>::Output

impl NormalOut<usizex2> for Complex<f64>

type Output = <cplx64x1 as NormalOutPromote<usizex2>>::Output

fn _mul_add( self, a: usizex2, b: usizex2, ) -> <Complex<f64> as NormalOut<usizex2>>::Output

fn _add(self, rhs: usizex2) -> <Complex<f64> as NormalOut<usizex2>>::Output

fn _sub(self, rhs: usizex2) -> <Complex<f64> as NormalOut<usizex2>>::Output

fn _mul(self, rhs: usizex2) -> <Complex<f64> as NormalOut<usizex2>>::Output

fn _pow(self, rhs: usizex2) -> <Complex<f64> as NormalOut<usizex2>>::Output

fn _rem(self, rhs: usizex2) -> <Complex<f64> as NormalOut<usizex2>>::Output

fn _clamp( self, min: usizex2, max: usizex2, ) -> <Complex<f64> as NormalOut<usizex2>>::Output

fn _max(self, rhs: usizex2) -> <Complex<f64> as NormalOut<usizex2>>::Output

fn _min(self, rhs: usizex2) -> <Complex<f64> as NormalOut<usizex2>>::Output

impl NormalOut<bf16> for bool

type Output = <bool as NormalOutPromote<bf16>>::Output

fn _pow(self, rhs: bf16) -> <bool as NormalOut<bf16>>::Output

fn _clamp(self, min: bf16, max: bf16) -> <bool as NormalOut<bf16>>::Output

fn _mul_add(self, a: bf16, b: bf16) -> <bool as NormalOut<bf16>>::Output

fn _add(self, rhs: bf16) -> <bool as NormalOut<bf16>>::Output

fn _sub(self, rhs: bf16) -> <bool as NormalOut<bf16>>::Output

fn _mul(self, rhs: bf16) -> <bool as NormalOut<bf16>>::Output

fn _rem(self, rhs: bf16) -> <bool as NormalOut<bf16>>::Output

fn _max(self, rhs: bf16) -> <bool as NormalOut<bf16>>::Output

fn _min(self, rhs: bf16) -> <bool as NormalOut<bf16>>::Output

impl NormalOut<bf16> for f32

type Output = <f32 as NormalOutPromote<bf16>>::Output

fn _pow(self, rhs: bf16) -> <f32 as NormalOut<bf16>>::Output

fn _clamp(self, min: bf16, max: bf16) -> <f32 as NormalOut<bf16>>::Output

fn _mul_add(self, a: bf16, b: bf16) -> <f32 as NormalOut<bf16>>::Output

fn _add(self, rhs: bf16) -> <f32 as NormalOut<bf16>>::Output

fn _sub(self, rhs: bf16) -> <f32 as NormalOut<bf16>>::Output

fn _mul(self, rhs: bf16) -> <f32 as NormalOut<bf16>>::Output

fn _rem(self, rhs: bf16) -> <f32 as NormalOut<bf16>>::Output

fn _max(self, rhs: bf16) -> <f32 as NormalOut<bf16>>::Output

fn _min(self, rhs: bf16) -> <f32 as NormalOut<bf16>>::Output

impl NormalOut<bf16> for f64

type Output = <f64 as NormalOutPromote<bf16>>::Output

fn _pow(self, rhs: bf16) -> <f64 as NormalOut<bf16>>::Output

fn _clamp(self, min: bf16, max: bf16) -> <f64 as NormalOut<bf16>>::Output

fn _mul_add(self, a: bf16, b: bf16) -> <f64 as NormalOut<bf16>>::Output

fn _add(self, rhs: bf16) -> <f64 as NormalOut<bf16>>::Output

fn _sub(self, rhs: bf16) -> <f64 as NormalOut<bf16>>::Output

fn _mul(self, rhs: bf16) -> <f64 as NormalOut<bf16>>::Output

fn _rem(self, rhs: bf16) -> <f64 as NormalOut<bf16>>::Output

fn _max(self, rhs: bf16) -> <f64 as NormalOut<bf16>>::Output

fn _min(self, rhs: bf16) -> <f64 as NormalOut<bf16>>::Output

impl NormalOut<bf16> for i8

type Output = <i8 as NormalOutPromote<bf16>>::Output

fn _pow(self, rhs: bf16) -> <i8 as NormalOut<bf16>>::Output

fn _clamp(self, min: bf16, max: bf16) -> <i8 as NormalOut<bf16>>::Output

fn _mul_add(self, a: bf16, b: bf16) -> <i8 as NormalOut<bf16>>::Output

fn _add(self, rhs: bf16) -> <i8 as NormalOut<bf16>>::Output

fn _sub(self, rhs: bf16) -> <i8 as NormalOut<bf16>>::Output

fn _mul(self, rhs: bf16) -> <i8 as NormalOut<bf16>>::Output

fn _rem(self, rhs: bf16) -> <i8 as NormalOut<bf16>>::Output

fn _max(self, rhs: bf16) -> <i8 as NormalOut<bf16>>::Output

fn _min(self, rhs: bf16) -> <i8 as NormalOut<bf16>>::Output

impl NormalOut<bf16> for i16

type Output = <i16 as NormalOutPromote<bf16>>::Output

fn _pow(self, rhs: bf16) -> <i16 as NormalOut<bf16>>::Output

fn _clamp(self, min: bf16, max: bf16) -> <i16 as NormalOut<bf16>>::Output

fn _mul_add(self, a: bf16, b: bf16) -> <i16 as NormalOut<bf16>>::Output

fn _add(self, rhs: bf16) -> <i16 as NormalOut<bf16>>::Output

fn _sub(self, rhs: bf16) -> <i16 as NormalOut<bf16>>::Output

fn _mul(self, rhs: bf16) -> <i16 as NormalOut<bf16>>::Output

fn _rem(self, rhs: bf16) -> <i16 as NormalOut<bf16>>::Output

fn _max(self, rhs: bf16) -> <i16 as NormalOut<bf16>>::Output

fn _min(self, rhs: bf16) -> <i16 as NormalOut<bf16>>::Output

impl NormalOut<bf16> for i32

type Output = <i32 as NormalOutPromote<bf16>>::Output

fn _pow(self, rhs: bf16) -> <i32 as NormalOut<bf16>>::Output

fn _clamp(self, min: bf16, max: bf16) -> <i32 as NormalOut<bf16>>::Output

fn _mul_add(self, a: bf16, b: bf16) -> <i32 as NormalOut<bf16>>::Output

fn _add(self, rhs: bf16) -> <i32 as NormalOut<bf16>>::Output

fn _sub(self, rhs: bf16) -> <i32 as NormalOut<bf16>>::Output

fn _mul(self, rhs: bf16) -> <i32 as NormalOut<bf16>>::Output

fn _rem(self, rhs: bf16) -> <i32 as NormalOut<bf16>>::Output

fn _max(self, rhs: bf16) -> <i32 as NormalOut<bf16>>::Output

fn _min(self, rhs: bf16) -> <i32 as NormalOut<bf16>>::Output

impl NormalOut<bf16> for i64

type Output = <i64 as NormalOutPromote<bf16>>::Output

fn _pow(self, rhs: bf16) -> <i64 as NormalOut<bf16>>::Output

fn _clamp(self, min: bf16, max: bf16) -> <i64 as NormalOut<bf16>>::Output

fn _mul_add(self, a: bf16, b: bf16) -> <i64 as NormalOut<bf16>>::Output

fn _add(self, rhs: bf16) -> <i64 as NormalOut<bf16>>::Output

fn _sub(self, rhs: bf16) -> <i64 as NormalOut<bf16>>::Output

fn _mul(self, rhs: bf16) -> <i64 as NormalOut<bf16>>::Output

fn _rem(self, rhs: bf16) -> <i64 as NormalOut<bf16>>::Output

fn _max(self, rhs: bf16) -> <i64 as NormalOut<bf16>>::Output

fn _min(self, rhs: bf16) -> <i64 as NormalOut<bf16>>::Output

impl NormalOut<bf16> for isize

type Output = <isize as NormalOutPromote<bf16>>::Output

fn _pow(self, rhs: bf16) -> <isize as NormalOut<bf16>>::Output

fn _clamp(self, min: bf16, max: bf16) -> <isize as NormalOut<bf16>>::Output

fn _mul_add(self, a: bf16, b: bf16) -> <isize as NormalOut<bf16>>::Output

fn _add(self, rhs: bf16) -> <isize as NormalOut<bf16>>::Output

fn _sub(self, rhs: bf16) -> <isize as NormalOut<bf16>>::Output

fn _mul(self, rhs: bf16) -> <isize as NormalOut<bf16>>::Output

fn _rem(self, rhs: bf16) -> <isize as NormalOut<bf16>>::Output

fn _max(self, rhs: bf16) -> <isize as NormalOut<bf16>>::Output

fn _min(self, rhs: bf16) -> <isize as NormalOut<bf16>>::Output

impl NormalOut<bf16> for u8

type Output = <u8 as NormalOutPromote<bf16>>::Output

fn _pow(self, rhs: bf16) -> <u8 as NormalOut<bf16>>::Output

fn _clamp(self, min: bf16, max: bf16) -> <u8 as NormalOut<bf16>>::Output

fn _mul_add(self, a: bf16, b: bf16) -> <u8 as NormalOut<bf16>>::Output

fn _add(self, rhs: bf16) -> <u8 as NormalOut<bf16>>::Output

fn _sub(self, rhs: bf16) -> <u8 as NormalOut<bf16>>::Output

fn _mul(self, rhs: bf16) -> <u8 as NormalOut<bf16>>::Output

fn _rem(self, rhs: bf16) -> <u8 as NormalOut<bf16>>::Output

fn _max(self, rhs: bf16) -> <u8 as NormalOut<bf16>>::Output

fn _min(self, rhs: bf16) -> <u8 as NormalOut<bf16>>::Output

impl NormalOut<bf16> for u16

type Output = <u16 as NormalOutPromote<bf16>>::Output

fn _pow(self, rhs: bf16) -> <u16 as NormalOut<bf16>>::Output

fn _clamp(self, min: bf16, max: bf16) -> <u16 as NormalOut<bf16>>::Output

fn _mul_add(self, a: bf16, b: bf16) -> <u16 as NormalOut<bf16>>::Output

fn _add(self, rhs: bf16) -> <u16 as NormalOut<bf16>>::Output

fn _sub(self, rhs: bf16) -> <u16 as NormalOut<bf16>>::Output

fn _mul(self, rhs: bf16) -> <u16 as NormalOut<bf16>>::Output

fn _rem(self, rhs: bf16) -> <u16 as NormalOut<bf16>>::Output

fn _max(self, rhs: bf16) -> <u16 as NormalOut<bf16>>::Output

fn _min(self, rhs: bf16) -> <u16 as NormalOut<bf16>>::Output

impl NormalOut<bf16> for u32

type Output = <u32 as NormalOutPromote<bf16>>::Output

fn _pow(self, rhs: bf16) -> <u32 as NormalOut<bf16>>::Output

fn _clamp(self, min: bf16, max: bf16) -> <u32 as NormalOut<bf16>>::Output

fn _mul_add(self, a: bf16, b: bf16) -> <u32 as NormalOut<bf16>>::Output

fn _add(self, rhs: bf16) -> <u32 as NormalOut<bf16>>::Output

fn _sub(self, rhs: bf16) -> <u32 as NormalOut<bf16>>::Output

fn _mul(self, rhs: bf16) -> <u32 as NormalOut<bf16>>::Output

fn _rem(self, rhs: bf16) -> <u32 as NormalOut<bf16>>::Output

fn _max(self, rhs: bf16) -> <u32 as NormalOut<bf16>>::Output

fn _min(self, rhs: bf16) -> <u32 as NormalOut<bf16>>::Output

impl NormalOut<bf16> for u64

type Output = <u64 as NormalOutPromote<bf16>>::Output

fn _pow(self, rhs: bf16) -> <u64 as NormalOut<bf16>>::Output

fn _clamp(self, min: bf16, max: bf16) -> <u64 as NormalOut<bf16>>::Output

fn _mul_add(self, a: bf16, b: bf16) -> <u64 as NormalOut<bf16>>::Output

fn _add(self, rhs: bf16) -> <u64 as NormalOut<bf16>>::Output

fn _sub(self, rhs: bf16) -> <u64 as NormalOut<bf16>>::Output

fn _mul(self, rhs: bf16) -> <u64 as NormalOut<bf16>>::Output

fn _rem(self, rhs: bf16) -> <u64 as NormalOut<bf16>>::Output

fn _max(self, rhs: bf16) -> <u64 as NormalOut<bf16>>::Output

fn _min(self, rhs: bf16) -> <u64 as NormalOut<bf16>>::Output

impl NormalOut<bf16> for usize

type Output = <usize as NormalOutPromote<bf16>>::Output

fn _pow(self, rhs: bf16) -> <usize as NormalOut<bf16>>::Output

fn _clamp(self, min: bf16, max: bf16) -> <usize as NormalOut<bf16>>::Output

fn _mul_add(self, a: bf16, b: bf16) -> <usize as NormalOut<bf16>>::Output

fn _add(self, rhs: bf16) -> <usize as NormalOut<bf16>>::Output

fn _sub(self, rhs: bf16) -> <usize as NormalOut<bf16>>::Output

fn _mul(self, rhs: bf16) -> <usize as NormalOut<bf16>>::Output

fn _rem(self, rhs: bf16) -> <usize as NormalOut<bf16>>::Output

fn _max(self, rhs: bf16) -> <usize as NormalOut<bf16>>::Output

fn _min(self, rhs: bf16) -> <usize as NormalOut<bf16>>::Output

impl NormalOut<bf16> for f16

type Output = <f16 as NormalOutPromote<bf16>>::Output

fn _pow(self, rhs: bf16) -> <f16 as NormalOut<bf16>>::Output

fn _clamp(self, min: bf16, max: bf16) -> <f16 as NormalOut<bf16>>::Output

fn _mul_add(self, a: bf16, b: bf16) -> <f16 as NormalOut<bf16>>::Output

fn _add(self, rhs: bf16) -> <f16 as NormalOut<bf16>>::Output

fn _sub(self, rhs: bf16) -> <f16 as NormalOut<bf16>>::Output

fn _mul(self, rhs: bf16) -> <f16 as NormalOut<bf16>>::Output

fn _rem(self, rhs: bf16) -> <f16 as NormalOut<bf16>>::Output

fn _max(self, rhs: bf16) -> <f16 as NormalOut<bf16>>::Output

fn _min(self, rhs: bf16) -> <f16 as NormalOut<bf16>>::Output

impl NormalOut<bf16> for Complex<f32>

type Output = <Complex<f32> as NormalOutPromote<bf16>>::Output

fn _pow(self, rhs: bf16) -> <Complex<f32> as NormalOut<bf16>>::Output

fn _clamp( self, min: bf16, max: bf16, ) -> <Complex<f32> as NormalOut<bf16>>::Output

fn _mul_add(self, a: bf16, b: bf16) -> <Complex<f32> as NormalOut<bf16>>::Output

fn _add(self, rhs: bf16) -> <Complex<f32> as NormalOut<bf16>>::Output

fn _sub(self, rhs: bf16) -> <Complex<f32> as NormalOut<bf16>>::Output

fn _mul(self, rhs: bf16) -> <Complex<f32> as NormalOut<bf16>>::Output

fn _rem(self, rhs: bf16) -> <Complex<f32> as NormalOut<bf16>>::Output

fn _max(self, rhs: bf16) -> <Complex<f32> as NormalOut<bf16>>::Output

fn _min(self, rhs: bf16) -> <Complex<f32> as NormalOut<bf16>>::Output

impl NormalOut<bf16> for Complex<f64>

type Output = <Complex<f64> as NormalOutPromote<bf16>>::Output

fn _pow(self, rhs: bf16) -> <Complex<f64> as NormalOut<bf16>>::Output

fn _clamp( self, min: bf16, max: bf16, ) -> <Complex<f64> as NormalOut<bf16>>::Output

fn _mul_add(self, a: bf16, b: bf16) -> <Complex<f64> as NormalOut<bf16>>::Output

fn _add(self, rhs: bf16) -> <Complex<f64> as NormalOut<bf16>>::Output

fn _sub(self, rhs: bf16) -> <Complex<f64> as NormalOut<bf16>>::Output

fn _mul(self, rhs: bf16) -> <Complex<f64> as NormalOut<bf16>>::Output

fn _rem(self, rhs: bf16) -> <Complex<f64> as NormalOut<bf16>>::Output

fn _max(self, rhs: bf16) -> <Complex<f64> as NormalOut<bf16>>::Output

fn _min(self, rhs: bf16) -> <Complex<f64> as NormalOut<bf16>>::Output

impl NormalOut<f16> for bool

type Output = <bool as NormalOutPromote<f16>>::Output

fn _pow(self, rhs: f16) -> <bool as NormalOut<f16>>::Output

fn _clamp(self, min: f16, max: f16) -> <bool as NormalOut<f16>>::Output

fn _mul_add(self, a: f16, b: f16) -> <bool as NormalOut<f16>>::Output

fn _add(self, rhs: f16) -> <bool as NormalOut<f16>>::Output

fn _sub(self, rhs: f16) -> <bool as NormalOut<f16>>::Output

fn _mul(self, rhs: f16) -> <bool as NormalOut<f16>>::Output

fn _rem(self, rhs: f16) -> <bool as NormalOut<f16>>::Output

fn _max(self, rhs: f16) -> <bool as NormalOut<f16>>::Output

fn _min(self, rhs: f16) -> <bool as NormalOut<f16>>::Output

impl NormalOut<f16> for f32

type Output = <f32 as NormalOutPromote<f16>>::Output

fn _pow(self, rhs: f16) -> <f32 as NormalOut<f16>>::Output

fn _clamp(self, min: f16, max: f16) -> <f32 as NormalOut<f16>>::Output

fn _mul_add(self, a: f16, b: f16) -> <f32 as NormalOut<f16>>::Output

fn _add(self, rhs: f16) -> <f32 as NormalOut<f16>>::Output

fn _sub(self, rhs: f16) -> <f32 as NormalOut<f16>>::Output

fn _mul(self, rhs: f16) -> <f32 as NormalOut<f16>>::Output

fn _rem(self, rhs: f16) -> <f32 as NormalOut<f16>>::Output

fn _max(self, rhs: f16) -> <f32 as NormalOut<f16>>::Output

fn _min(self, rhs: f16) -> <f32 as NormalOut<f16>>::Output

impl NormalOut<f16> for f64

type Output = <f64 as NormalOutPromote<f16>>::Output

fn _pow(self, rhs: f16) -> <f64 as NormalOut<f16>>::Output

fn _clamp(self, min: f16, max: f16) -> <f64 as NormalOut<f16>>::Output

fn _mul_add(self, a: f16, b: f16) -> <f64 as NormalOut<f16>>::Output

fn _add(self, rhs: f16) -> <f64 as NormalOut<f16>>::Output

fn _sub(self, rhs: f16) -> <f64 as NormalOut<f16>>::Output

fn _mul(self, rhs: f16) -> <f64 as NormalOut<f16>>::Output

fn _rem(self, rhs: f16) -> <f64 as NormalOut<f16>>::Output

fn _max(self, rhs: f16) -> <f64 as NormalOut<f16>>::Output

fn _min(self, rhs: f16) -> <f64 as NormalOut<f16>>::Output

impl NormalOut<f16> for i8

type Output = <i8 as NormalOutPromote<f16>>::Output

fn _pow(self, rhs: f16) -> <i8 as NormalOut<f16>>::Output

fn _clamp(self, min: f16, max: f16) -> <i8 as NormalOut<f16>>::Output

fn _mul_add(self, a: f16, b: f16) -> <i8 as NormalOut<f16>>::Output

fn _add(self, rhs: f16) -> <i8 as NormalOut<f16>>::Output

fn _sub(self, rhs: f16) -> <i8 as NormalOut<f16>>::Output

fn _mul(self, rhs: f16) -> <i8 as NormalOut<f16>>::Output

fn _rem(self, rhs: f16) -> <i8 as NormalOut<f16>>::Output

fn _max(self, rhs: f16) -> <i8 as NormalOut<f16>>::Output

fn _min(self, rhs: f16) -> <i8 as NormalOut<f16>>::Output

impl NormalOut<f16> for i16

type Output = <i16 as NormalOutPromote<f16>>::Output

fn _pow(self, rhs: f16) -> <i16 as NormalOut<f16>>::Output

fn _clamp(self, min: f16, max: f16) -> <i16 as NormalOut<f16>>::Output

fn _mul_add(self, a: f16, b: f16) -> <i16 as NormalOut<f16>>::Output

fn _add(self, rhs: f16) -> <i16 as NormalOut<f16>>::Output

fn _sub(self, rhs: f16) -> <i16 as NormalOut<f16>>::Output

fn _mul(self, rhs: f16) -> <i16 as NormalOut<f16>>::Output

fn _rem(self, rhs: f16) -> <i16 as NormalOut<f16>>::Output

fn _max(self, rhs: f16) -> <i16 as NormalOut<f16>>::Output

fn _min(self, rhs: f16) -> <i16 as NormalOut<f16>>::Output

impl NormalOut<f16> for i32

type Output = <i32 as NormalOutPromote<f16>>::Output

fn _pow(self, rhs: f16) -> <i32 as NormalOut<f16>>::Output

fn _clamp(self, min: f16, max: f16) -> <i32 as NormalOut<f16>>::Output

fn _mul_add(self, a: f16, b: f16) -> <i32 as NormalOut<f16>>::Output

fn _add(self, rhs: f16) -> <i32 as NormalOut<f16>>::Output

fn _sub(self, rhs: f16) -> <i32 as NormalOut<f16>>::Output

fn _mul(self, rhs: f16) -> <i32 as NormalOut<f16>>::Output

fn _rem(self, rhs: f16) -> <i32 as NormalOut<f16>>::Output

fn _max(self, rhs: f16) -> <i32 as NormalOut<f16>>::Output

fn _min(self, rhs: f16) -> <i32 as NormalOut<f16>>::Output

impl NormalOut<f16> for i64

type Output = <i64 as NormalOutPromote<f16>>::Output

fn _pow(self, rhs: f16) -> <i64 as NormalOut<f16>>::Output

fn _clamp(self, min: f16, max: f16) -> <i64 as NormalOut<f16>>::Output

fn _mul_add(self, a: f16, b: f16) -> <i64 as NormalOut<f16>>::Output

fn _add(self, rhs: f16) -> <i64 as NormalOut<f16>>::Output

fn _sub(self, rhs: f16) -> <i64 as NormalOut<f16>>::Output

fn _mul(self, rhs: f16) -> <i64 as NormalOut<f16>>::Output

fn _rem(self, rhs: f16) -> <i64 as NormalOut<f16>>::Output

fn _max(self, rhs: f16) -> <i64 as NormalOut<f16>>::Output

fn _min(self, rhs: f16) -> <i64 as NormalOut<f16>>::Output

impl NormalOut<f16> for isize

type Output = <isize as NormalOutPromote<f16>>::Output

fn _pow(self, rhs: f16) -> <isize as NormalOut<f16>>::Output

fn _clamp(self, min: f16, max: f16) -> <isize as NormalOut<f16>>::Output

fn _mul_add(self, a: f16, b: f16) -> <isize as NormalOut<f16>>::Output

fn _add(self, rhs: f16) -> <isize as NormalOut<f16>>::Output

fn _sub(self, rhs: f16) -> <isize as NormalOut<f16>>::Output

fn _mul(self, rhs: f16) -> <isize as NormalOut<f16>>::Output

fn _rem(self, rhs: f16) -> <isize as NormalOut<f16>>::Output

fn _max(self, rhs: f16) -> <isize as NormalOut<f16>>::Output

fn _min(self, rhs: f16) -> <isize as NormalOut<f16>>::Output

impl NormalOut<f16> for u8

type Output = <u8 as NormalOutPromote<f16>>::Output

fn _pow(self, rhs: f16) -> <u8 as NormalOut<f16>>::Output

fn _clamp(self, min: f16, max: f16) -> <u8 as NormalOut<f16>>::Output

fn _mul_add(self, a: f16, b: f16) -> <u8 as NormalOut<f16>>::Output

fn _add(self, rhs: f16) -> <u8 as NormalOut<f16>>::Output

fn _sub(self, rhs: f16) -> <u8 as NormalOut<f16>>::Output

fn _mul(self, rhs: f16) -> <u8 as NormalOut<f16>>::Output

fn _rem(self, rhs: f16) -> <u8 as NormalOut<f16>>::Output

fn _max(self, rhs: f16) -> <u8 as NormalOut<f16>>::Output

fn _min(self, rhs: f16) -> <u8 as NormalOut<f16>>::Output

impl NormalOut<f16> for u16

type Output = <u16 as NormalOutPromote<f16>>::Output

fn _pow(self, rhs: f16) -> <u16 as NormalOut<f16>>::Output

fn _clamp(self, min: f16, max: f16) -> <u16 as NormalOut<f16>>::Output

fn _mul_add(self, a: f16, b: f16) -> <u16 as NormalOut<f16>>::Output

fn _add(self, rhs: f16) -> <u16 as NormalOut<f16>>::Output

fn _sub(self, rhs: f16) -> <u16 as NormalOut<f16>>::Output

fn _mul(self, rhs: f16) -> <u16 as NormalOut<f16>>::Output

fn _rem(self, rhs: f16) -> <u16 as NormalOut<f16>>::Output

fn _max(self, rhs: f16) -> <u16 as NormalOut<f16>>::Output

fn _min(self, rhs: f16) -> <u16 as NormalOut<f16>>::Output

impl NormalOut<f16> for u32

type Output = <u32 as NormalOutPromote<f16>>::Output

fn _pow(self, rhs: f16) -> <u32 as NormalOut<f16>>::Output

fn _clamp(self, min: f16, max: f16) -> <u32 as NormalOut<f16>>::Output

fn _mul_add(self, a: f16, b: f16) -> <u32 as NormalOut<f16>>::Output

fn _add(self, rhs: f16) -> <u32 as NormalOut<f16>>::Output

fn _sub(self, rhs: f16) -> <u32 as NormalOut<f16>>::Output

fn _mul(self, rhs: f16) -> <u32 as NormalOut<f16>>::Output

fn _rem(self, rhs: f16) -> <u32 as NormalOut<f16>>::Output

fn _max(self, rhs: f16) -> <u32 as NormalOut<f16>>::Output

fn _min(self, rhs: f16) -> <u32 as NormalOut<f16>>::Output

impl NormalOut<f16> for u64

type Output = <u64 as NormalOutPromote<f16>>::Output

fn _pow(self, rhs: f16) -> <u64 as NormalOut<f16>>::Output

fn _clamp(self, min: f16, max: f16) -> <u64 as NormalOut<f16>>::Output

fn _mul_add(self, a: f16, b: f16) -> <u64 as NormalOut<f16>>::Output

fn _add(self, rhs: f16) -> <u64 as NormalOut<f16>>::Output

fn _sub(self, rhs: f16) -> <u64 as NormalOut<f16>>::Output

fn _mul(self, rhs: f16) -> <u64 as NormalOut<f16>>::Output

fn _rem(self, rhs: f16) -> <u64 as NormalOut<f16>>::Output

fn _max(self, rhs: f16) -> <u64 as NormalOut<f16>>::Output

fn _min(self, rhs: f16) -> <u64 as NormalOut<f16>>::Output

impl NormalOut<f16> for usize

type Output = <usize as NormalOutPromote<f16>>::Output

fn _pow(self, rhs: f16) -> <usize as NormalOut<f16>>::Output

fn _clamp(self, min: f16, max: f16) -> <usize as NormalOut<f16>>::Output

fn _mul_add(self, a: f16, b: f16) -> <usize as NormalOut<f16>>::Output

fn _add(self, rhs: f16) -> <usize as NormalOut<f16>>::Output

fn _sub(self, rhs: f16) -> <usize as NormalOut<f16>>::Output

fn _mul(self, rhs: f16) -> <usize as NormalOut<f16>>::Output

fn _rem(self, rhs: f16) -> <usize as NormalOut<f16>>::Output

fn _max(self, rhs: f16) -> <usize as NormalOut<f16>>::Output

fn _min(self, rhs: f16) -> <usize as NormalOut<f16>>::Output

impl NormalOut<f16> for bf16

type Output = <bf16 as NormalOutPromote<f16>>::Output

fn _pow(self, rhs: f16) -> <bf16 as NormalOut<f16>>::Output

fn _clamp(self, min: f16, max: f16) -> <bf16 as NormalOut<f16>>::Output

fn _mul_add(self, a: f16, b: f16) -> <bf16 as NormalOut<f16>>::Output

fn _add(self, rhs: f16) -> <bf16 as NormalOut<f16>>::Output

fn _sub(self, rhs: f16) -> <bf16 as NormalOut<f16>>::Output

fn _mul(self, rhs: f16) -> <bf16 as NormalOut<f16>>::Output

fn _rem(self, rhs: f16) -> <bf16 as NormalOut<f16>>::Output

fn _max(self, rhs: f16) -> <bf16 as NormalOut<f16>>::Output

fn _min(self, rhs: f16) -> <bf16 as NormalOut<f16>>::Output

impl NormalOut<f16> for Complex<f32>

type Output = <Complex<f32> as NormalOutPromote<f16>>::Output

fn _pow(self, rhs: f16) -> <Complex<f32> as NormalOut<f16>>::Output

fn _clamp(self, min: f16, max: f16) -> <Complex<f32> as NormalOut<f16>>::Output

fn _mul_add(self, a: f16, b: f16) -> <Complex<f32> as NormalOut<f16>>::Output

fn _add(self, rhs: f16) -> <Complex<f32> as NormalOut<f16>>::Output

fn _sub(self, rhs: f16) -> <Complex<f32> as NormalOut<f16>>::Output

fn _mul(self, rhs: f16) -> <Complex<f32> as NormalOut<f16>>::Output

fn _rem(self, rhs: f16) -> <Complex<f32> as NormalOut<f16>>::Output

fn _max(self, rhs: f16) -> <Complex<f32> as NormalOut<f16>>::Output

fn _min(self, rhs: f16) -> <Complex<f32> as NormalOut<f16>>::Output

impl NormalOut<f16> for Complex<f64>

type Output = <Complex<f64> as NormalOutPromote<f16>>::Output

fn _pow(self, rhs: f16) -> <Complex<f64> as NormalOut<f16>>::Output

fn _clamp(self, min: f16, max: f16) -> <Complex<f64> as NormalOut<f16>>::Output

fn _mul_add(self, a: f16, b: f16) -> <Complex<f64> as NormalOut<f16>>::Output

fn _add(self, rhs: f16) -> <Complex<f64> as NormalOut<f16>>::Output

fn _sub(self, rhs: f16) -> <Complex<f64> as NormalOut<f16>>::Output

fn _mul(self, rhs: f16) -> <Complex<f64> as NormalOut<f16>>::Output

fn _rem(self, rhs: f16) -> <Complex<f64> as NormalOut<f16>>::Output

fn _max(self, rhs: f16) -> <Complex<f64> as NormalOut<f16>>::Output

fn _min(self, rhs: f16) -> <Complex<f64> as NormalOut<f16>>::Output

impl NormalOut<Complex<f32>> for bool

type Output = <bool as NormalOutPromote<Complex<f32>>>::Output

fn _pow(self, rhs: Complex<f32>) -> <bool as NormalOut<Complex<f32>>>::Output

fn _clamp( self, min: Complex<f32>, max: Complex<f32>, ) -> <bool as NormalOut<Complex<f32>>>::Output

fn _mul_add( self, a: Complex<f32>, b: Complex<f32>, ) -> <bool as NormalOut<Complex<f32>>>::Output

fn _add(self, rhs: Complex<f32>) -> <bool as NormalOut<Complex<f32>>>::Output

fn _sub(self, rhs: Complex<f32>) -> <bool as NormalOut<Complex<f32>>>::Output

fn _mul(self, rhs: Complex<f32>) -> <bool as NormalOut<Complex<f32>>>::Output

fn _rem(self, rhs: Complex<f32>) -> <bool as NormalOut<Complex<f32>>>::Output

fn _max(self, rhs: Complex<f32>) -> <bool as NormalOut<Complex<f32>>>::Output

fn _min(self, rhs: Complex<f32>) -> <bool as NormalOut<Complex<f32>>>::Output

impl NormalOut<Complex<f32>> for f32

type Output = <f32 as NormalOutPromote<Complex<f32>>>::Output

fn _pow(self, rhs: Complex<f32>) -> <f32 as NormalOut<Complex<f32>>>::Output

fn _clamp( self, min: Complex<f32>, max: Complex<f32>, ) -> <f32 as NormalOut<Complex<f32>>>::Output

fn _mul_add( self, a: Complex<f32>, b: Complex<f32>, ) -> <f32 as NormalOut<Complex<f32>>>::Output

fn _add(self, rhs: Complex<f32>) -> <f32 as NormalOut<Complex<f32>>>::Output

fn _sub(self, rhs: Complex<f32>) -> <f32 as NormalOut<Complex<f32>>>::Output

fn _mul(self, rhs: Complex<f32>) -> <f32 as NormalOut<Complex<f32>>>::Output

fn _rem(self, rhs: Complex<f32>) -> <f32 as NormalOut<Complex<f32>>>::Output

fn _max(self, rhs: Complex<f32>) -> <f32 as NormalOut<Complex<f32>>>::Output

fn _min(self, rhs: Complex<f32>) -> <f32 as NormalOut<Complex<f32>>>::Output

impl NormalOut<Complex<f32>> for f64

type Output = <f64 as NormalOutPromote<Complex<f32>>>::Output

fn _pow(self, rhs: Complex<f32>) -> <f64 as NormalOut<Complex<f32>>>::Output

fn _clamp( self, min: Complex<f32>, max: Complex<f32>, ) -> <f64 as NormalOut<Complex<f32>>>::Output

fn _mul_add( self, a: Complex<f32>, b: Complex<f32>, ) -> <f64 as NormalOut<Complex<f32>>>::Output

fn _add(self, rhs: Complex<f32>) -> <f64 as NormalOut<Complex<f32>>>::Output

fn _sub(self, rhs: Complex<f32>) -> <f64 as NormalOut<Complex<f32>>>::Output

fn _mul(self, rhs: Complex<f32>) -> <f64 as NormalOut<Complex<f32>>>::Output

fn _rem(self, rhs: Complex<f32>) -> <f64 as NormalOut<Complex<f32>>>::Output

fn _max(self, rhs: Complex<f32>) -> <f64 as NormalOut<Complex<f32>>>::Output

fn _min(self, rhs: Complex<f32>) -> <f64 as NormalOut<Complex<f32>>>::Output

impl NormalOut<Complex<f32>> for i8

type Output = <i8 as NormalOutPromote<Complex<f32>>>::Output

fn _pow(self, rhs: Complex<f32>) -> <i8 as NormalOut<Complex<f32>>>::Output

fn _clamp( self, min: Complex<f32>, max: Complex<f32>, ) -> <i8 as NormalOut<Complex<f32>>>::Output

fn _mul_add( self, a: Complex<f32>, b: Complex<f32>, ) -> <i8 as NormalOut<Complex<f32>>>::Output

fn _add(self, rhs: Complex<f32>) -> <i8 as NormalOut<Complex<f32>>>::Output

fn _sub(self, rhs: Complex<f32>) -> <i8 as NormalOut<Complex<f32>>>::Output

fn _mul(self, rhs: Complex<f32>) -> <i8 as NormalOut<Complex<f32>>>::Output

fn _rem(self, rhs: Complex<f32>) -> <i8 as NormalOut<Complex<f32>>>::Output

fn _max(self, rhs: Complex<f32>) -> <i8 as NormalOut<Complex<f32>>>::Output

fn _min(self, rhs: Complex<f32>) -> <i8 as NormalOut<Complex<f32>>>::Output

impl NormalOut<Complex<f32>> for i16

type Output = <i16 as NormalOutPromote<Complex<f32>>>::Output

fn _pow(self, rhs: Complex<f32>) -> <i16 as NormalOut<Complex<f32>>>::Output

fn _clamp( self, min: Complex<f32>, max: Complex<f32>, ) -> <i16 as NormalOut<Complex<f32>>>::Output

fn _mul_add( self, a: Complex<f32>, b: Complex<f32>, ) -> <i16 as NormalOut<Complex<f32>>>::Output

fn _add(self, rhs: Complex<f32>) -> <i16 as NormalOut<Complex<f32>>>::Output

fn _sub(self, rhs: Complex<f32>) -> <i16 as NormalOut<Complex<f32>>>::Output

fn _mul(self, rhs: Complex<f32>) -> <i16 as NormalOut<Complex<f32>>>::Output

fn _rem(self, rhs: Complex<f32>) -> <i16 as NormalOut<Complex<f32>>>::Output

fn _max(self, rhs: Complex<f32>) -> <i16 as NormalOut<Complex<f32>>>::Output

fn _min(self, rhs: Complex<f32>) -> <i16 as NormalOut<Complex<f32>>>::Output

impl NormalOut<Complex<f32>> for i32

type Output = <i32 as NormalOutPromote<Complex<f32>>>::Output

fn _pow(self, rhs: Complex<f32>) -> <i32 as NormalOut<Complex<f32>>>::Output

fn _clamp( self, min: Complex<f32>, max: Complex<f32>, ) -> <i32 as NormalOut<Complex<f32>>>::Output

fn _mul_add( self, a: Complex<f32>, b: Complex<f32>, ) -> <i32 as NormalOut<Complex<f32>>>::Output

fn _add(self, rhs: Complex<f32>) -> <i32 as NormalOut<Complex<f32>>>::Output

fn _sub(self, rhs: Complex<f32>) -> <i32 as NormalOut<Complex<f32>>>::Output

fn _mul(self, rhs: Complex<f32>) -> <i32 as NormalOut<Complex<f32>>>::Output

fn _rem(self, rhs: Complex<f32>) -> <i32 as NormalOut<Complex<f32>>>::Output

fn _max(self, rhs: Complex<f32>) -> <i32 as NormalOut<Complex<f32>>>::Output

fn _min(self, rhs: Complex<f32>) -> <i32 as NormalOut<Complex<f32>>>::Output

impl NormalOut<Complex<f32>> for i64

type Output = <i64 as NormalOutPromote<Complex<f32>>>::Output

fn _pow(self, rhs: Complex<f32>) -> <i64 as NormalOut<Complex<f32>>>::Output

fn _clamp( self, min: Complex<f32>, max: Complex<f32>, ) -> <i64 as NormalOut<Complex<f32>>>::Output

fn _mul_add( self, a: Complex<f32>, b: Complex<f32>, ) -> <i64 as NormalOut<Complex<f32>>>::Output

fn _add(self, rhs: Complex<f32>) -> <i64 as NormalOut<Complex<f32>>>::Output

fn _sub(self, rhs: Complex<f32>) -> <i64 as NormalOut<Complex<f32>>>::Output

fn _mul(self, rhs: Complex<f32>) -> <i64 as NormalOut<Complex<f32>>>::Output

fn _rem(self, rhs: Complex<f32>) -> <i64 as NormalOut<Complex<f32>>>::Output

fn _max(self, rhs: Complex<f32>) -> <i64 as NormalOut<Complex<f32>>>::Output

fn _min(self, rhs: Complex<f32>) -> <i64 as NormalOut<Complex<f32>>>::Output

impl NormalOut<Complex<f32>> for isize

type Output = <isize as NormalOutPromote<Complex<f32>>>::Output

fn _pow(self, rhs: Complex<f32>) -> <isize as NormalOut<Complex<f32>>>::Output

fn _clamp( self, min: Complex<f32>, max: Complex<f32>, ) -> <isize as NormalOut<Complex<f32>>>::Output

fn _mul_add( self, a: Complex<f32>, b: Complex<f32>, ) -> <isize as NormalOut<Complex<f32>>>::Output

fn _add(self, rhs: Complex<f32>) -> <isize as NormalOut<Complex<f32>>>::Output

fn _sub(self, rhs: Complex<f32>) -> <isize as NormalOut<Complex<f32>>>::Output

fn _mul(self, rhs: Complex<f32>) -> <isize as NormalOut<Complex<f32>>>::Output

fn _rem(self, rhs: Complex<f32>) -> <isize as NormalOut<Complex<f32>>>::Output

fn _max(self, rhs: Complex<f32>) -> <isize as NormalOut<Complex<f32>>>::Output

fn _min(self, rhs: Complex<f32>) -> <isize as NormalOut<Complex<f32>>>::Output

impl NormalOut<Complex<f32>> for u8

type Output = <u8 as NormalOutPromote<Complex<f32>>>::Output

fn _pow(self, rhs: Complex<f32>) -> <u8 as NormalOut<Complex<f32>>>::Output

fn _clamp( self, min: Complex<f32>, max: Complex<f32>, ) -> <u8 as NormalOut<Complex<f32>>>::Output

fn _mul_add( self, a: Complex<f32>, b: Complex<f32>, ) -> <u8 as NormalOut<Complex<f32>>>::Output

fn _add(self, rhs: Complex<f32>) -> <u8 as NormalOut<Complex<f32>>>::Output

fn _sub(self, rhs: Complex<f32>) -> <u8 as NormalOut<Complex<f32>>>::Output

fn _mul(self, rhs: Complex<f32>) -> <u8 as NormalOut<Complex<f32>>>::Output

fn _rem(self, rhs: Complex<f32>) -> <u8 as NormalOut<Complex<f32>>>::Output

fn _max(self, rhs: Complex<f32>) -> <u8 as NormalOut<Complex<f32>>>::Output

fn _min(self, rhs: Complex<f32>) -> <u8 as NormalOut<Complex<f32>>>::Output

impl NormalOut<Complex<f32>> for u16

type Output = <u16 as NormalOutPromote<Complex<f32>>>::Output

fn _pow(self, rhs: Complex<f32>) -> <u16 as NormalOut<Complex<f32>>>::Output

fn _clamp( self, min: Complex<f32>, max: Complex<f32>, ) -> <u16 as NormalOut<Complex<f32>>>::Output

fn _mul_add( self, a: Complex<f32>, b: Complex<f32>, ) -> <u16 as NormalOut<Complex<f32>>>::Output

fn _add(self, rhs: Complex<f32>) -> <u16 as NormalOut<Complex<f32>>>::Output

fn _sub(self, rhs: Complex<f32>) -> <u16 as NormalOut<Complex<f32>>>::Output

fn _mul(self, rhs: Complex<f32>) -> <u16 as NormalOut<Complex<f32>>>::Output

fn _rem(self, rhs: Complex<f32>) -> <u16 as NormalOut<Complex<f32>>>::Output

fn _max(self, rhs: Complex<f32>) -> <u16 as NormalOut<Complex<f32>>>::Output

fn _min(self, rhs: Complex<f32>) -> <u16 as NormalOut<Complex<f32>>>::Output

impl NormalOut<Complex<f32>> for u32

type Output = <u32 as NormalOutPromote<Complex<f32>>>::Output

fn _pow(self, rhs: Complex<f32>) -> <u32 as NormalOut<Complex<f32>>>::Output

fn _clamp( self, min: Complex<f32>, max: Complex<f32>, ) -> <u32 as NormalOut<Complex<f32>>>::Output

fn _mul_add( self, a: Complex<f32>, b: Complex<f32>, ) -> <u32 as NormalOut<Complex<f32>>>::Output

fn _add(self, rhs: Complex<f32>) -> <u32 as NormalOut<Complex<f32>>>::Output

fn _sub(self, rhs: Complex<f32>) -> <u32 as NormalOut<Complex<f32>>>::Output

fn _mul(self, rhs: Complex<f32>) -> <u32 as NormalOut<Complex<f32>>>::Output

fn _rem(self, rhs: Complex<f32>) -> <u32 as NormalOut<Complex<f32>>>::Output

fn _max(self, rhs: Complex<f32>) -> <u32 as NormalOut<Complex<f32>>>::Output

fn _min(self, rhs: Complex<f32>) -> <u32 as NormalOut<Complex<f32>>>::Output

impl NormalOut<Complex<f32>> for u64

type Output = <u64 as NormalOutPromote<Complex<f32>>>::Output

fn _pow(self, rhs: Complex<f32>) -> <u64 as NormalOut<Complex<f32>>>::Output

fn _clamp( self, min: Complex<f32>, max: Complex<f32>, ) -> <u64 as NormalOut<Complex<f32>>>::Output

fn _mul_add( self, a: Complex<f32>, b: Complex<f32>, ) -> <u64 as NormalOut<Complex<f32>>>::Output

fn _add(self, rhs: Complex<f32>) -> <u64 as NormalOut<Complex<f32>>>::Output

fn _sub(self, rhs: Complex<f32>) -> <u64 as NormalOut<Complex<f32>>>::Output

fn _mul(self, rhs: Complex<f32>) -> <u64 as NormalOut<Complex<f32>>>::Output

fn _rem(self, rhs: Complex<f32>) -> <u64 as NormalOut<Complex<f32>>>::Output

fn _max(self, rhs: Complex<f32>) -> <u64 as NormalOut<Complex<f32>>>::Output

fn _min(self, rhs: Complex<f32>) -> <u64 as NormalOut<Complex<f32>>>::Output

impl NormalOut<Complex<f32>> for usize

type Output = <usize as NormalOutPromote<Complex<f32>>>::Output

fn _pow(self, rhs: Complex<f32>) -> <usize as NormalOut<Complex<f32>>>::Output

fn _clamp( self, min: Complex<f32>, max: Complex<f32>, ) -> <usize as NormalOut<Complex<f32>>>::Output

fn _mul_add( self, a: Complex<f32>, b: Complex<f32>, ) -> <usize as NormalOut<Complex<f32>>>::Output

fn _add(self, rhs: Complex<f32>) -> <usize as NormalOut<Complex<f32>>>::Output

fn _sub(self, rhs: Complex<f32>) -> <usize as NormalOut<Complex<f32>>>::Output

fn _mul(self, rhs: Complex<f32>) -> <usize as NormalOut<Complex<f32>>>::Output

fn _rem(self, rhs: Complex<f32>) -> <usize as NormalOut<Complex<f32>>>::Output

fn _max(self, rhs: Complex<f32>) -> <usize as NormalOut<Complex<f32>>>::Output

fn _min(self, rhs: Complex<f32>) -> <usize as NormalOut<Complex<f32>>>::Output

impl NormalOut<Complex<f32>> for bf16

type Output = <bf16 as NormalOutPromote<Complex<f32>>>::Output

fn _pow(self, rhs: Complex<f32>) -> <bf16 as NormalOut<Complex<f32>>>::Output

fn _clamp( self, min: Complex<f32>, max: Complex<f32>, ) -> <bf16 as NormalOut<Complex<f32>>>::Output

fn _mul_add( self, a: Complex<f32>, b: Complex<f32>, ) -> <bf16 as NormalOut<Complex<f32>>>::Output

fn _add(self, rhs: Complex<f32>) -> <bf16 as NormalOut<Complex<f32>>>::Output

fn _sub(self, rhs: Complex<f32>) -> <bf16 as NormalOut<Complex<f32>>>::Output

fn _mul(self, rhs: Complex<f32>) -> <bf16 as NormalOut<Complex<f32>>>::Output

fn _rem(self, rhs: Complex<f32>) -> <bf16 as NormalOut<Complex<f32>>>::Output

fn _max(self, rhs: Complex<f32>) -> <bf16 as NormalOut<Complex<f32>>>::Output

fn _min(self, rhs: Complex<f32>) -> <bf16 as NormalOut<Complex<f32>>>::Output

impl NormalOut<Complex<f32>> for f16

type Output = <f16 as NormalOutPromote<Complex<f32>>>::Output

fn _pow(self, rhs: Complex<f32>) -> <f16 as NormalOut<Complex<f32>>>::Output

fn _clamp( self, min: Complex<f32>, max: Complex<f32>, ) -> <f16 as NormalOut<Complex<f32>>>::Output

fn _mul_add( self, a: Complex<f32>, b: Complex<f32>, ) -> <f16 as NormalOut<Complex<f32>>>::Output

fn _add(self, rhs: Complex<f32>) -> <f16 as NormalOut<Complex<f32>>>::Output

fn _sub(self, rhs: Complex<f32>) -> <f16 as NormalOut<Complex<f32>>>::Output

fn _mul(self, rhs: Complex<f32>) -> <f16 as NormalOut<Complex<f32>>>::Output

fn _rem(self, rhs: Complex<f32>) -> <f16 as NormalOut<Complex<f32>>>::Output

fn _max(self, rhs: Complex<f32>) -> <f16 as NormalOut<Complex<f32>>>::Output

fn _min(self, rhs: Complex<f32>) -> <f16 as NormalOut<Complex<f32>>>::Output

impl NormalOut<Complex<f32>> for Complex<f64>

type Output = <Complex<f64> as NormalOutPromote<Complex<f32>>>::Output

fn _pow( self, rhs: Complex<f32>, ) -> <Complex<f64> as NormalOut<Complex<f32>>>::Output

fn _clamp( self, min: Complex<f32>, max: Complex<f32>, ) -> <Complex<f64> as NormalOut<Complex<f32>>>::Output

fn _mul_add( self, a: Complex<f32>, b: Complex<f32>, ) -> <Complex<f64> as NormalOut<Complex<f32>>>::Output

fn _add( self, rhs: Complex<f32>, ) -> <Complex<f64> as NormalOut<Complex<f32>>>::Output

fn _sub( self, rhs: Complex<f32>, ) -> <Complex<f64> as NormalOut<Complex<f32>>>::Output

fn _mul( self, rhs: Complex<f32>, ) -> <Complex<f64> as NormalOut<Complex<f32>>>::Output

fn _rem( self, rhs: Complex<f32>, ) -> <Complex<f64> as NormalOut<Complex<f32>>>::Output

fn _max( self, rhs: Complex<f32>, ) -> <Complex<f64> as NormalOut<Complex<f32>>>::Output

fn _min( self, rhs: Complex<f32>, ) -> <Complex<f64> as NormalOut<Complex<f32>>>::Output

impl NormalOut<Complex<f64>> for bool

type Output = <bool as NormalOutPromote<Complex<f64>>>::Output

fn _pow(self, rhs: Complex<f64>) -> <bool as NormalOut<Complex<f64>>>::Output

fn _clamp( self, min: Complex<f64>, max: Complex<f64>, ) -> <bool as NormalOut<Complex<f64>>>::Output

fn _mul_add( self, a: Complex<f64>, b: Complex<f64>, ) -> <bool as NormalOut<Complex<f64>>>::Output

fn _add(self, rhs: Complex<f64>) -> <bool as NormalOut<Complex<f64>>>::Output

fn _sub(self, rhs: Complex<f64>) -> <bool as NormalOut<Complex<f64>>>::Output

fn _mul(self, rhs: Complex<f64>) -> <bool as NormalOut<Complex<f64>>>::Output

fn _rem(self, rhs: Complex<f64>) -> <bool as NormalOut<Complex<f64>>>::Output

fn _max(self, rhs: Complex<f64>) -> <bool as NormalOut<Complex<f64>>>::Output

fn _min(self, rhs: Complex<f64>) -> <bool as NormalOut<Complex<f64>>>::Output

impl NormalOut<Complex<f64>> for f32

type Output = <f32 as NormalOutPromote<Complex<f64>>>::Output

fn _pow(self, rhs: Complex<f64>) -> <f32 as NormalOut<Complex<f64>>>::Output

fn _clamp( self, min: Complex<f64>, max: Complex<f64>, ) -> <f32 as NormalOut<Complex<f64>>>::Output

fn _mul_add( self, a: Complex<f64>, b: Complex<f64>, ) -> <f32 as NormalOut<Complex<f64>>>::Output

fn _add(self, rhs: Complex<f64>) -> <f32 as NormalOut<Complex<f64>>>::Output

fn _sub(self, rhs: Complex<f64>) -> <f32 as NormalOut<Complex<f64>>>::Output

fn _mul(self, rhs: Complex<f64>) -> <f32 as NormalOut<Complex<f64>>>::Output

fn _rem(self, rhs: Complex<f64>) -> <f32 as NormalOut<Complex<f64>>>::Output

fn _max(self, rhs: Complex<f64>) -> <f32 as NormalOut<Complex<f64>>>::Output

fn _min(self, rhs: Complex<f64>) -> <f32 as NormalOut<Complex<f64>>>::Output

impl NormalOut<Complex<f64>> for f64

type Output = <f64 as NormalOutPromote<Complex<f64>>>::Output

fn _pow(self, rhs: Complex<f64>) -> <f64 as NormalOut<Complex<f64>>>::Output

fn _clamp( self, min: Complex<f64>, max: Complex<f64>, ) -> <f64 as NormalOut<Complex<f64>>>::Output

fn _mul_add( self, a: Complex<f64>, b: Complex<f64>, ) -> <f64 as NormalOut<Complex<f64>>>::Output

fn _add(self, rhs: Complex<f64>) -> <f64 as NormalOut<Complex<f64>>>::Output

fn _sub(self, rhs: Complex<f64>) -> <f64 as NormalOut<Complex<f64>>>::Output

fn _mul(self, rhs: Complex<f64>) -> <f64 as NormalOut<Complex<f64>>>::Output

fn _rem(self, rhs: Complex<f64>) -> <f64 as NormalOut<Complex<f64>>>::Output

fn _max(self, rhs: Complex<f64>) -> <f64 as NormalOut<Complex<f64>>>::Output

fn _min(self, rhs: Complex<f64>) -> <f64 as NormalOut<Complex<f64>>>::Output

impl NormalOut<Complex<f64>> for i8

type Output = <i8 as NormalOutPromote<Complex<f64>>>::Output

fn _pow(self, rhs: Complex<f64>) -> <i8 as NormalOut<Complex<f64>>>::Output

fn _clamp( self, min: Complex<f64>, max: Complex<f64>, ) -> <i8 as NormalOut<Complex<f64>>>::Output

fn _mul_add( self, a: Complex<f64>, b: Complex<f64>, ) -> <i8 as NormalOut<Complex<f64>>>::Output

fn _add(self, rhs: Complex<f64>) -> <i8 as NormalOut<Complex<f64>>>::Output

fn _sub(self, rhs: Complex<f64>) -> <i8 as NormalOut<Complex<f64>>>::Output

fn _mul(self, rhs: Complex<f64>) -> <i8 as NormalOut<Complex<f64>>>::Output

fn _rem(self, rhs: Complex<f64>) -> <i8 as NormalOut<Complex<f64>>>::Output

fn _max(self, rhs: Complex<f64>) -> <i8 as NormalOut<Complex<f64>>>::Output

fn _min(self, rhs: Complex<f64>) -> <i8 as NormalOut<Complex<f64>>>::Output

impl NormalOut<Complex<f64>> for i16

type Output = <i16 as NormalOutPromote<Complex<f64>>>::Output

fn _pow(self, rhs: Complex<f64>) -> <i16 as NormalOut<Complex<f64>>>::Output

fn _clamp( self, min: Complex<f64>, max: Complex<f64>, ) -> <i16 as NormalOut<Complex<f64>>>::Output

fn _mul_add( self, a: Complex<f64>, b: Complex<f64>, ) -> <i16 as NormalOut<Complex<f64>>>::Output

fn _add(self, rhs: Complex<f64>) -> <i16 as NormalOut<Complex<f64>>>::Output

fn _sub(self, rhs: Complex<f64>) -> <i16 as NormalOut<Complex<f64>>>::Output

fn _mul(self, rhs: Complex<f64>) -> <i16 as NormalOut<Complex<f64>>>::Output

fn _rem(self, rhs: Complex<f64>) -> <i16 as NormalOut<Complex<f64>>>::Output

fn _max(self, rhs: Complex<f64>) -> <i16 as NormalOut<Complex<f64>>>::Output

fn _min(self, rhs: Complex<f64>) -> <i16 as NormalOut<Complex<f64>>>::Output

impl NormalOut<Complex<f64>> for i32

type Output = <i32 as NormalOutPromote<Complex<f64>>>::Output

fn _pow(self, rhs: Complex<f64>) -> <i32 as NormalOut<Complex<f64>>>::Output

fn _clamp( self, min: Complex<f64>, max: Complex<f64>, ) -> <i32 as NormalOut<Complex<f64>>>::Output

fn _mul_add( self, a: Complex<f64>, b: Complex<f64>, ) -> <i32 as NormalOut<Complex<f64>>>::Output

fn _add(self, rhs: Complex<f64>) -> <i32 as NormalOut<Complex<f64>>>::Output

fn _sub(self, rhs: Complex<f64>) -> <i32 as NormalOut<Complex<f64>>>::Output

fn _mul(self, rhs: Complex<f64>) -> <i32 as NormalOut<Complex<f64>>>::Output

fn _rem(self, rhs: Complex<f64>) -> <i32 as NormalOut<Complex<f64>>>::Output

fn _max(self, rhs: Complex<f64>) -> <i32 as NormalOut<Complex<f64>>>::Output

fn _min(self, rhs: Complex<f64>) -> <i32 as NormalOut<Complex<f64>>>::Output

impl NormalOut<Complex<f64>> for i64

type Output = <i64 as NormalOutPromote<Complex<f64>>>::Output

fn _pow(self, rhs: Complex<f64>) -> <i64 as NormalOut<Complex<f64>>>::Output

fn _clamp( self, min: Complex<f64>, max: Complex<f64>, ) -> <i64 as NormalOut<Complex<f64>>>::Output

fn _mul_add( self, a: Complex<f64>, b: Complex<f64>, ) -> <i64 as NormalOut<Complex<f64>>>::Output

fn _add(self, rhs: Complex<f64>) -> <i64 as NormalOut<Complex<f64>>>::Output

fn _sub(self, rhs: Complex<f64>) -> <i64 as NormalOut<Complex<f64>>>::Output

fn _mul(self, rhs: Complex<f64>) -> <i64 as NormalOut<Complex<f64>>>::Output

fn _rem(self, rhs: Complex<f64>) -> <i64 as NormalOut<Complex<f64>>>::Output

fn _max(self, rhs: Complex<f64>) -> <i64 as NormalOut<Complex<f64>>>::Output

fn _min(self, rhs: Complex<f64>) -> <i64 as NormalOut<Complex<f64>>>::Output

impl NormalOut<Complex<f64>> for isize

type Output = <isize as NormalOutPromote<Complex<f64>>>::Output

fn _pow(self, rhs: Complex<f64>) -> <isize as NormalOut<Complex<f64>>>::Output

fn _clamp( self, min: Complex<f64>, max: Complex<f64>, ) -> <isize as NormalOut<Complex<f64>>>::Output

fn _mul_add( self, a: Complex<f64>, b: Complex<f64>, ) -> <isize as NormalOut<Complex<f64>>>::Output

fn _add(self, rhs: Complex<f64>) -> <isize as NormalOut<Complex<f64>>>::Output

fn _sub(self, rhs: Complex<f64>) -> <isize as NormalOut<Complex<f64>>>::Output

fn _mul(self, rhs: Complex<f64>) -> <isize as NormalOut<Complex<f64>>>::Output

fn _rem(self, rhs: Complex<f64>) -> <isize as NormalOut<Complex<f64>>>::Output

fn _max(self, rhs: Complex<f64>) -> <isize as NormalOut<Complex<f64>>>::Output

fn _min(self, rhs: Complex<f64>) -> <isize as NormalOut<Complex<f64>>>::Output

impl NormalOut<Complex<f64>> for u8

type Output = <u8 as NormalOutPromote<Complex<f64>>>::Output

fn _pow(self, rhs: Complex<f64>) -> <u8 as NormalOut<Complex<f64>>>::Output

fn _clamp( self, min: Complex<f64>, max: Complex<f64>, ) -> <u8 as NormalOut<Complex<f64>>>::Output

fn _mul_add( self, a: Complex<f64>, b: Complex<f64>, ) -> <u8 as NormalOut<Complex<f64>>>::Output

fn _add(self, rhs: Complex<f64>) -> <u8 as NormalOut<Complex<f64>>>::Output

fn _sub(self, rhs: Complex<f64>) -> <u8 as NormalOut<Complex<f64>>>::Output

fn _mul(self, rhs: Complex<f64>) -> <u8 as NormalOut<Complex<f64>>>::Output

fn _rem(self, rhs: Complex<f64>) -> <u8 as NormalOut<Complex<f64>>>::Output

fn _max(self, rhs: Complex<f64>) -> <u8 as NormalOut<Complex<f64>>>::Output

fn _min(self, rhs: Complex<f64>) -> <u8 as NormalOut<Complex<f64>>>::Output

impl NormalOut<Complex<f64>> for u16

type Output = <u16 as NormalOutPromote<Complex<f64>>>::Output

fn _pow(self, rhs: Complex<f64>) -> <u16 as NormalOut<Complex<f64>>>::Output

fn _clamp( self, min: Complex<f64>, max: Complex<f64>, ) -> <u16 as NormalOut<Complex<f64>>>::Output

fn _mul_add( self, a: Complex<f64>, b: Complex<f64>, ) -> <u16 as NormalOut<Complex<f64>>>::Output

fn _add(self, rhs: Complex<f64>) -> <u16 as NormalOut<Complex<f64>>>::Output

fn _sub(self, rhs: Complex<f64>) -> <u16 as NormalOut<Complex<f64>>>::Output

fn _mul(self, rhs: Complex<f64>) -> <u16 as NormalOut<Complex<f64>>>::Output

fn _rem(self, rhs: Complex<f64>) -> <u16 as NormalOut<Complex<f64>>>::Output

fn _max(self, rhs: Complex<f64>) -> <u16 as NormalOut<Complex<f64>>>::Output

fn _min(self, rhs: Complex<f64>) -> <u16 as NormalOut<Complex<f64>>>::Output

impl NormalOut<Complex<f64>> for u32

type Output = <u32 as NormalOutPromote<Complex<f64>>>::Output

fn _pow(self, rhs: Complex<f64>) -> <u32 as NormalOut<Complex<f64>>>::Output

fn _clamp( self, min: Complex<f64>, max: Complex<f64>, ) -> <u32 as NormalOut<Complex<f64>>>::Output

fn _mul_add( self, a: Complex<f64>, b: Complex<f64>, ) -> <u32 as NormalOut<Complex<f64>>>::Output

fn _add(self, rhs: Complex<f64>) -> <u32 as NormalOut<Complex<f64>>>::Output

fn _sub(self, rhs: Complex<f64>) -> <u32 as NormalOut<Complex<f64>>>::Output

fn _mul(self, rhs: Complex<f64>) -> <u32 as NormalOut<Complex<f64>>>::Output

fn _rem(self, rhs: Complex<f64>) -> <u32 as NormalOut<Complex<f64>>>::Output

fn _max(self, rhs: Complex<f64>) -> <u32 as NormalOut<Complex<f64>>>::Output

fn _min(self, rhs: Complex<f64>) -> <u32 as NormalOut<Complex<f64>>>::Output

impl NormalOut<Complex<f64>> for u64

type Output = <u64 as NormalOutPromote<Complex<f64>>>::Output

fn _pow(self, rhs: Complex<f64>) -> <u64 as NormalOut<Complex<f64>>>::Output

fn _clamp( self, min: Complex<f64>, max: Complex<f64>, ) -> <u64 as NormalOut<Complex<f64>>>::Output

fn _mul_add( self, a: Complex<f64>, b: Complex<f64>, ) -> <u64 as NormalOut<Complex<f64>>>::Output

fn _add(self, rhs: Complex<f64>) -> <u64 as NormalOut<Complex<f64>>>::Output

fn _sub(self, rhs: Complex<f64>) -> <u64 as NormalOut<Complex<f64>>>::Output

fn _mul(self, rhs: Complex<f64>) -> <u64 as NormalOut<Complex<f64>>>::Output

fn _rem(self, rhs: Complex<f64>) -> <u64 as NormalOut<Complex<f64>>>::Output

fn _max(self, rhs: Complex<f64>) -> <u64 as NormalOut<Complex<f64>>>::Output

fn _min(self, rhs: Complex<f64>) -> <u64 as NormalOut<Complex<f64>>>::Output

impl NormalOut<Complex<f64>> for usize

type Output = <usize as NormalOutPromote<Complex<f64>>>::Output

fn _pow(self, rhs: Complex<f64>) -> <usize as NormalOut<Complex<f64>>>::Output

fn _clamp( self, min: Complex<f64>, max: Complex<f64>, ) -> <usize as NormalOut<Complex<f64>>>::Output

fn _mul_add( self, a: Complex<f64>, b: Complex<f64>, ) -> <usize as NormalOut<Complex<f64>>>::Output

fn _add(self, rhs: Complex<f64>) -> <usize as NormalOut<Complex<f64>>>::Output

fn _sub(self, rhs: Complex<f64>) -> <usize as NormalOut<Complex<f64>>>::Output

fn _mul(self, rhs: Complex<f64>) -> <usize as NormalOut<Complex<f64>>>::Output

fn _rem(self, rhs: Complex<f64>) -> <usize as NormalOut<Complex<f64>>>::Output

fn _max(self, rhs: Complex<f64>) -> <usize as NormalOut<Complex<f64>>>::Output

fn _min(self, rhs: Complex<f64>) -> <usize as NormalOut<Complex<f64>>>::Output

impl NormalOut<Complex<f64>> for bf16

type Output = <bf16 as NormalOutPromote<Complex<f64>>>::Output

fn _pow(self, rhs: Complex<f64>) -> <bf16 as NormalOut<Complex<f64>>>::Output

fn _clamp( self, min: Complex<f64>, max: Complex<f64>, ) -> <bf16 as NormalOut<Complex<f64>>>::Output

fn _mul_add( self, a: Complex<f64>, b: Complex<f64>, ) -> <bf16 as NormalOut<Complex<f64>>>::Output

fn _add(self, rhs: Complex<f64>) -> <bf16 as NormalOut<Complex<f64>>>::Output

fn _sub(self, rhs: Complex<f64>) -> <bf16 as NormalOut<Complex<f64>>>::Output

fn _mul(self, rhs: Complex<f64>) -> <bf16 as NormalOut<Complex<f64>>>::Output

fn _rem(self, rhs: Complex<f64>) -> <bf16 as NormalOut<Complex<f64>>>::Output

fn _max(self, rhs: Complex<f64>) -> <bf16 as NormalOut<Complex<f64>>>::Output

fn _min(self, rhs: Complex<f64>) -> <bf16 as NormalOut<Complex<f64>>>::Output

impl NormalOut<Complex<f64>> for f16

type Output = <f16 as NormalOutPromote<Complex<f64>>>::Output

fn _pow(self, rhs: Complex<f64>) -> <f16 as NormalOut<Complex<f64>>>::Output

fn _clamp( self, min: Complex<f64>, max: Complex<f64>, ) -> <f16 as NormalOut<Complex<f64>>>::Output

fn _mul_add( self, a: Complex<f64>, b: Complex<f64>, ) -> <f16 as NormalOut<Complex<f64>>>::Output

fn _add(self, rhs: Complex<f64>) -> <f16 as NormalOut<Complex<f64>>>::Output

fn _sub(self, rhs: Complex<f64>) -> <f16 as NormalOut<Complex<f64>>>::Output

fn _mul(self, rhs: Complex<f64>) -> <f16 as NormalOut<Complex<f64>>>::Output

fn _rem(self, rhs: Complex<f64>) -> <f16 as NormalOut<Complex<f64>>>::Output

fn _max(self, rhs: Complex<f64>) -> <f16 as NormalOut<Complex<f64>>>::Output

fn _min(self, rhs: Complex<f64>) -> <f16 as NormalOut<Complex<f64>>>::Output

impl NormalOut<Complex<f64>> for Complex<f32>

type Output = <Complex<f32> as NormalOutPromote<Complex<f64>>>::Output

fn _pow( self, rhs: Complex<f64>, ) -> <Complex<f32> as NormalOut<Complex<f64>>>::Output

fn _clamp( self, min: Complex<f64>, max: Complex<f64>, ) -> <Complex<f32> as NormalOut<Complex<f64>>>::Output

fn _mul_add( self, a: Complex<f64>, b: Complex<f64>, ) -> <Complex<f32> as NormalOut<Complex<f64>>>::Output

fn _add( self, rhs: Complex<f64>, ) -> <Complex<f32> as NormalOut<Complex<f64>>>::Output

fn _sub( self, rhs: Complex<f64>, ) -> <Complex<f32> as NormalOut<Complex<f64>>>::Output

fn _mul( self, rhs: Complex<f64>, ) -> <Complex<f32> as NormalOut<Complex<f64>>>::Output

fn _rem( self, rhs: Complex<f64>, ) -> <Complex<f32> as NormalOut<Complex<f64>>>::Output

fn _max( self, rhs: Complex<f64>, ) -> <Complex<f32> as NormalOut<Complex<f64>>>::Output

fn _min( self, rhs: Complex<f64>, ) -> <Complex<f32> as NormalOut<Complex<f64>>>::Output

Implementors

impl NormalOut for bf16x8

type Output = <bf16x8 as NormalOutPromote>::Output

impl NormalOut for boolx16

type Output = <boolx16 as NormalOutPromote>::Output

impl NormalOut for cplx32x2

type Output = <cplx32x2 as NormalOutPromote>::Output

impl NormalOut for cplx64x1

type Output = <cplx64x1 as NormalOutPromote>::Output

impl NormalOut for f16x8

type Output = <f16x8 as NormalOutPromote>::Output

impl NormalOut for f32x4

type Output = <f32x4 as NormalOutPromote>::Output

impl NormalOut for f64x2

type Output = <f64x2 as NormalOutPromote>::Output

impl NormalOut for i8x16

type Output = <i8x16 as NormalOutPromote>::Output

impl NormalOut for i16x8

type Output = <i16x8 as NormalOutPromote>::Output

impl NormalOut for i32x4

type Output = <i32x4 as NormalOutPromote>::Output

impl NormalOut for i64x2

type Output = <i64x2 as NormalOutPromote>::Output

impl NormalOut for isizex2

type Output = <isizex2 as NormalOutPromote>::Output

impl NormalOut for u8x16

type Output = <u8x16 as NormalOutPromote>::Output

impl NormalOut for u16x8

type Output = <u16x8 as NormalOutPromote>::Output

impl NormalOut for u32x4

type Output = <u32x4 as NormalOutPromote>::Output

impl NormalOut for u64x2

type Output = <u64x2 as NormalOutPromote>::Output

impl NormalOut for usizex2

type Output = <usizex2 as NormalOutPromote>::Output

impl NormalOut<bool> for bf16x8

type Output = <bf16x8 as NormalOutPromote<boolx16>>::Output

impl NormalOut<bool> for boolx16

type Output = <boolx16 as NormalOutPromote>::Output

impl NormalOut<bool> for cplx32x2

type Output = <cplx32x2 as NormalOutPromote<boolx16>>::Output

impl NormalOut<bool> for cplx64x1

type Output = <cplx64x1 as NormalOutPromote<boolx16>>::Output

impl NormalOut<bool> for f16x8

type Output = <f16x8 as NormalOutPromote<boolx16>>::Output

impl NormalOut<bool> for f32x4

type Output = <f32x4 as NormalOutPromote<boolx16>>::Output

impl NormalOut<bool> for f64x2

type Output = <f64x2 as NormalOutPromote<boolx16>>::Output

impl NormalOut<bool> for i8x16

type Output = <i8x16 as NormalOutPromote<boolx16>>::Output

impl NormalOut<bool> for i16x8

type Output = <i16x8 as NormalOutPromote<boolx16>>::Output

impl NormalOut<bool> for i32x4

type Output = <i32x4 as NormalOutPromote<boolx16>>::Output

impl NormalOut<bool> for i64x2

type Output = <i64x2 as NormalOutPromote<boolx16>>::Output

impl NormalOut<bool> for isizex2

type Output = <isizex2 as NormalOutPromote<boolx16>>::Output

impl NormalOut<bool> for u8x16

type Output = <u8x16 as NormalOutPromote<boolx16>>::Output

impl NormalOut<bool> for u16x8

type Output = <u16x8 as NormalOutPromote<boolx16>>::Output

impl NormalOut<bool> for u32x4

type Output = <u32x4 as NormalOutPromote<boolx16>>::Output

impl NormalOut<bool> for u64x2

type Output = <u64x2 as NormalOutPromote<boolx16>>::Output

impl NormalOut<bool> for usizex2

type Output = <usizex2 as NormalOutPromote<boolx16>>::Output

impl NormalOut<f32> for bf16x8

type Output = <bf16x8 as NormalOutPromote<f32x4>>::Output

impl NormalOut<f32> for boolx16

type Output = <boolx16 as NormalOutPromote<f32x4>>::Output

impl NormalOut<f32> for cplx32x2

type Output = <cplx32x2 as NormalOutPromote<f32x4>>::Output

impl NormalOut<f32> for cplx64x1

type Output = <cplx64x1 as NormalOutPromote<f32x4>>::Output

impl NormalOut<f32> for f16x8

type Output = <f16x8 as NormalOutPromote<f32x4>>::Output

impl NormalOut<f32> for f32x4

type Output = <f32x4 as NormalOutPromote>::Output

impl NormalOut<f32> for f64x2

type Output = <f64x2 as NormalOutPromote<f32x4>>::Output

impl NormalOut<f32> for i8x16

type Output = <i8x16 as NormalOutPromote<f32x4>>::Output

impl NormalOut<f32> for i16x8

type Output = <i16x8 as NormalOutPromote<f32x4>>::Output

impl NormalOut<f32> for i32x4

type Output = <i32x4 as NormalOutPromote<f32x4>>::Output

impl NormalOut<f32> for i64x2

type Output = <i64x2 as NormalOutPromote<f32x4>>::Output

impl NormalOut<f32> for isizex2

type Output = <isizex2 as NormalOutPromote<f32x4>>::Output

impl NormalOut<f32> for u8x16

type Output = <u8x16 as NormalOutPromote<f32x4>>::Output

impl NormalOut<f32> for u16x8

type Output = <u16x8 as NormalOutPromote<f32x4>>::Output

impl NormalOut<f32> for u32x4

type Output = <u32x4 as NormalOutPromote<f32x4>>::Output

impl NormalOut<f32> for u64x2

type Output = <u64x2 as NormalOutPromote<f32x4>>::Output

impl NormalOut<f32> for usizex2

type Output = <usizex2 as NormalOutPromote<f32x4>>::Output

impl NormalOut<f64> for bf16x8

type Output = <bf16x8 as NormalOutPromote<f64x2>>::Output

impl NormalOut<f64> for boolx16

type Output = <boolx16 as NormalOutPromote<f64x2>>::Output

impl NormalOut<f64> for cplx32x2

type Output = <cplx32x2 as NormalOutPromote<f64x2>>::Output

impl NormalOut<f64> for cplx64x1

type Output = <cplx64x1 as NormalOutPromote<f64x2>>::Output

impl NormalOut<f64> for f16x8

type Output = <f16x8 as NormalOutPromote<f64x2>>::Output

impl NormalOut<f64> for f32x4

type Output = <f32x4 as NormalOutPromote<f64x2>>::Output

impl NormalOut<f64> for f64x2

type Output = <f64x2 as NormalOutPromote>::Output

impl NormalOut<f64> for i8x16

type Output = <i8x16 as NormalOutPromote<f64x2>>::Output

impl NormalOut<f64> for i16x8

type Output = <i16x8 as NormalOutPromote<f64x2>>::Output

impl NormalOut<f64> for i32x4

type Output = <i32x4 as NormalOutPromote<f64x2>>::Output

impl NormalOut<f64> for i64x2

type Output = <i64x2 as NormalOutPromote<f64x2>>::Output

impl NormalOut<f64> for isizex2

type Output = <isizex2 as NormalOutPromote<f64x2>>::Output

impl NormalOut<f64> for u8x16

type Output = <u8x16 as NormalOutPromote<f64x2>>::Output

impl NormalOut<f64> for u16x8

type Output = <u16x8 as NormalOutPromote<f64x2>>::Output

impl NormalOut<f64> for u32x4

type Output = <u32x4 as NormalOutPromote<f64x2>>::Output

impl NormalOut<f64> for u64x2

type Output = <u64x2 as NormalOutPromote<f64x2>>::Output

impl NormalOut<f64> for usizex2

type Output = <usizex2 as NormalOutPromote<f64x2>>::Output

impl NormalOut<i8> for bf16x8

type Output = <bf16x8 as NormalOutPromote<i8x16>>::Output

impl NormalOut<i8> for boolx16

type Output = <boolx16 as NormalOutPromote<i8x16>>::Output

impl NormalOut<i8> for cplx32x2

type Output = <cplx32x2 as NormalOutPromote<i8x16>>::Output

impl NormalOut<i8> for cplx64x1

type Output = <cplx64x1 as NormalOutPromote<i8x16>>::Output

impl NormalOut<i8> for f16x8

type Output = <f16x8 as NormalOutPromote<i8x16>>::Output

impl NormalOut<i8> for f32x4

type Output = <f32x4 as NormalOutPromote<i8x16>>::Output

impl NormalOut<i8> for f64x2

type Output = <f64x2 as NormalOutPromote<i8x16>>::Output

impl NormalOut<i8> for i8x16

type Output = <i8x16 as NormalOutPromote>::Output

impl NormalOut<i8> for i16x8

type Output = <i16x8 as NormalOutPromote<i8x16>>::Output

impl NormalOut<i8> for i32x4

type Output = <i32x4 as NormalOutPromote<i8x16>>::Output

impl NormalOut<i8> for i64x2

type Output = <i64x2 as NormalOutPromote<i8x16>>::Output

impl NormalOut<i8> for isizex2

type Output = <isizex2 as NormalOutPromote<i8x16>>::Output

impl NormalOut<i8> for u8x16

type Output = <u8x16 as NormalOutPromote<i8x16>>::Output

impl NormalOut<i8> for u16x8

type Output = <u16x8 as NormalOutPromote<i8x16>>::Output

impl NormalOut<i8> for u32x4

type Output = <u32x4 as NormalOutPromote<i8x16>>::Output

impl NormalOut<i8> for u64x2

type Output = <u64x2 as NormalOutPromote<i8x16>>::Output

impl NormalOut<i8> for usizex2

type Output = <usizex2 as NormalOutPromote<i8x16>>::Output

impl NormalOut<i16> for bf16x8

type Output = <bf16x8 as NormalOutPromote<i16x8>>::Output

impl NormalOut<i16> for boolx16

type Output = <boolx16 as NormalOutPromote<i16x8>>::Output

impl NormalOut<i16> for cplx32x2

type Output = <cplx32x2 as NormalOutPromote<i16x8>>::Output

impl NormalOut<i16> for cplx64x1

type Output = <cplx64x1 as NormalOutPromote<i16x8>>::Output

impl NormalOut<i16> for f16x8

type Output = <f16x8 as NormalOutPromote<i16x8>>::Output

impl NormalOut<i16> for f32x4

type Output = <f32x4 as NormalOutPromote<i16x8>>::Output

impl NormalOut<i16> for f64x2

type Output = <f64x2 as NormalOutPromote<i16x8>>::Output

impl NormalOut<i16> for i8x16

type Output = <i8x16 as NormalOutPromote<i16x8>>::Output

impl NormalOut<i16> for i16x8

type Output = <i16x8 as NormalOutPromote>::Output

impl NormalOut<i16> for i32x4

type Output = <i32x4 as NormalOutPromote<i16x8>>::Output

impl NormalOut<i16> for i64x2

type Output = <i64x2 as NormalOutPromote<i16x8>>::Output

impl NormalOut<i16> for isizex2

type Output = <isizex2 as NormalOutPromote<i16x8>>::Output

impl NormalOut<i16> for u8x16

type Output = <u8x16 as NormalOutPromote<i16x8>>::Output

impl NormalOut<i16> for u16x8

type Output = <u16x8 as NormalOutPromote<i16x8>>::Output

impl NormalOut<i16> for u32x4

type Output = <u32x4 as NormalOutPromote<i16x8>>::Output

impl NormalOut<i16> for u64x2

type Output = <u64x2 as NormalOutPromote<i16x8>>::Output

impl NormalOut<i16> for usizex2

type Output = <usizex2 as NormalOutPromote<i16x8>>::Output

impl NormalOut<i32> for bf16x8

type Output = <bf16x8 as NormalOutPromote<i32x4>>::Output

impl NormalOut<i32> for boolx16

type Output = <boolx16 as NormalOutPromote<i32x4>>::Output

impl NormalOut<i32> for cplx32x2

type Output = <cplx32x2 as NormalOutPromote<i32x4>>::Output

impl NormalOut<i32> for cplx64x1

type Output = <cplx64x1 as NormalOutPromote<i32x4>>::Output

impl NormalOut<i32> for f16x8

type Output = <f16x8 as NormalOutPromote<i32x4>>::Output

impl NormalOut<i32> for f32x4

type Output = <f32x4 as NormalOutPromote<i32x4>>::Output

impl NormalOut<i32> for f64x2

type Output = <f64x2 as NormalOutPromote<i32x4>>::Output

impl NormalOut<i32> for i8x16

type Output = <i8x16 as NormalOutPromote<i32x4>>::Output

impl NormalOut<i32> for i16x8

type Output = <i16x8 as NormalOutPromote<i32x4>>::Output

impl NormalOut<i32> for i32x4

type Output = <i32x4 as NormalOutPromote>::Output

impl NormalOut<i32> for i64x2

type Output = <i64x2 as NormalOutPromote<i32x4>>::Output

impl NormalOut<i32> for isizex2

type Output = <isizex2 as NormalOutPromote<i32x4>>::Output

impl NormalOut<i32> for u8x16

type Output = <u8x16 as NormalOutPromote<i32x4>>::Output

impl NormalOut<i32> for u16x8

type Output = <u16x8 as NormalOutPromote<i32x4>>::Output

impl NormalOut<i32> for u32x4

type Output = <u32x4 as NormalOutPromote<i32x4>>::Output

impl NormalOut<i32> for u64x2

type Output = <u64x2 as NormalOutPromote<i32x4>>::Output

impl NormalOut<i32> for usizex2

type Output = <usizex2 as NormalOutPromote<i32x4>>::Output

impl NormalOut<i64> for bf16x8

type Output = <bf16x8 as NormalOutPromote<i64x2>>::Output

impl NormalOut<i64> for boolx16

type Output = <boolx16 as NormalOutPromote<i64x2>>::Output

impl NormalOut<i64> for cplx32x2

type Output = <cplx32x2 as NormalOutPromote<i64x2>>::Output

impl NormalOut<i64> for cplx64x1

type Output = <cplx64x1 as NormalOutPromote<i64x2>>::Output

impl NormalOut<i64> for f16x8

type Output = <f16x8 as NormalOutPromote<i64x2>>::Output

impl NormalOut<i64> for f32x4

type Output = <f32x4 as NormalOutPromote<i64x2>>::Output

impl NormalOut<i64> for f64x2

type Output = <f64x2 as NormalOutPromote<i64x2>>::Output

impl NormalOut<i64> for i8x16

type Output = <i8x16 as NormalOutPromote<i64x2>>::Output

impl NormalOut<i64> for i16x8

type Output = <i16x8 as NormalOutPromote<i64x2>>::Output

impl NormalOut<i64> for i32x4

type Output = <i32x4 as NormalOutPromote<i64x2>>::Output

impl NormalOut<i64> for i64x2

type Output = <i64x2 as NormalOutPromote>::Output

impl NormalOut<i64> for isizex2

type Output = <isizex2 as NormalOutPromote<i64x2>>::Output

impl NormalOut<i64> for u8x16

type Output = <u8x16 as NormalOutPromote<i64x2>>::Output

impl NormalOut<i64> for u16x8

type Output = <u16x8 as NormalOutPromote<i64x2>>::Output

impl NormalOut<i64> for u32x4

type Output = <u32x4 as NormalOutPromote<i64x2>>::Output

impl NormalOut<i64> for u64x2

type Output = <u64x2 as NormalOutPromote<i64x2>>::Output

impl NormalOut<i64> for usizex2

type Output = <usizex2 as NormalOutPromote<i64x2>>::Output

impl NormalOut<isize> for bf16x8

type Output = <bf16x8 as NormalOutPromote<isizex2>>::Output

impl NormalOut<isize> for boolx16

type Output = <boolx16 as NormalOutPromote<isizex2>>::Output

impl NormalOut<isize> for cplx32x2

type Output = <cplx32x2 as NormalOutPromote<isizex2>>::Output

impl NormalOut<isize> for cplx64x1

type Output = <cplx64x1 as NormalOutPromote<isizex2>>::Output

impl NormalOut<isize> for f16x8

type Output = <f16x8 as NormalOutPromote<isizex2>>::Output

impl NormalOut<isize> for f32x4

type Output = <f32x4 as NormalOutPromote<isizex2>>::Output

impl NormalOut<isize> for f64x2

type Output = <f64x2 as NormalOutPromote<isizex2>>::Output

impl NormalOut<isize> for i8x16

type Output = <i8x16 as NormalOutPromote<isizex2>>::Output

impl NormalOut<isize> for i16x8

type Output = <i16x8 as NormalOutPromote<isizex2>>::Output

impl NormalOut<isize> for i32x4

type Output = <i32x4 as NormalOutPromote<isizex2>>::Output

impl NormalOut<isize> for i64x2

type Output = <i64x2 as NormalOutPromote<isizex2>>::Output

impl NormalOut<isize> for isizex2

type Output = <isizex2 as NormalOutPromote>::Output

impl NormalOut<isize> for u8x16

type Output = <u8x16 as NormalOutPromote<isizex2>>::Output

impl NormalOut<isize> for u16x8

type Output = <u16x8 as NormalOutPromote<isizex2>>::Output

impl NormalOut<isize> for u32x4

type Output = <u32x4 as NormalOutPromote<isizex2>>::Output

impl NormalOut<isize> for u64x2

type Output = <u64x2 as NormalOutPromote<isizex2>>::Output

impl NormalOut<isize> for usizex2

type Output = <usizex2 as NormalOutPromote<isizex2>>::Output

impl NormalOut<u8> for bf16x8

type Output = <bf16x8 as NormalOutPromote<u8x16>>::Output

impl NormalOut<u8> for boolx16

type Output = <boolx16 as NormalOutPromote<u8x16>>::Output

impl NormalOut<u8> for cplx32x2

type Output = <cplx32x2 as NormalOutPromote<u8x16>>::Output

impl NormalOut<u8> for cplx64x1

type Output = <cplx64x1 as NormalOutPromote<u8x16>>::Output

impl NormalOut<u8> for f16x8

type Output = <f16x8 as NormalOutPromote<u8x16>>::Output

impl NormalOut<u8> for f32x4

type Output = <f32x4 as NormalOutPromote<u8x16>>::Output

impl NormalOut<u8> for f64x2

type Output = <f64x2 as NormalOutPromote<u8x16>>::Output

impl NormalOut<u8> for i8x16

type Output = <i8x16 as NormalOutPromote<u8x16>>::Output

impl NormalOut<u8> for i16x8

type Output = <i16x8 as NormalOutPromote<u8x16>>::Output

impl NormalOut<u8> for i32x4

type Output = <i32x4 as NormalOutPromote<u8x16>>::Output

impl NormalOut<u8> for i64x2

type Output = <i64x2 as NormalOutPromote<u8x16>>::Output

impl NormalOut<u8> for isizex2

type Output = <isizex2 as NormalOutPromote<u8x16>>::Output

impl NormalOut<u8> for u8x16

type Output = <u8x16 as NormalOutPromote>::Output

impl NormalOut<u8> for u16x8

type Output = <u16x8 as NormalOutPromote<u8x16>>::Output

impl NormalOut<u8> for u32x4

type Output = <u32x4 as NormalOutPromote<u8x16>>::Output

impl NormalOut<u8> for u64x2

type Output = <u64x2 as NormalOutPromote<u8x16>>::Output

impl NormalOut<u8> for usizex2

type Output = <usizex2 as NormalOutPromote<u8x16>>::Output

impl NormalOut<u16> for bf16x8

type Output = <bf16x8 as NormalOutPromote<u16x8>>::Output

impl NormalOut<u16> for boolx16

type Output = <boolx16 as NormalOutPromote<u16x8>>::Output

impl NormalOut<u16> for cplx32x2

type Output = <cplx32x2 as NormalOutPromote<u16x8>>::Output

impl NormalOut<u16> for cplx64x1

type Output = <cplx64x1 as NormalOutPromote<u16x8>>::Output

impl NormalOut<u16> for f16x8

type Output = <f16x8 as NormalOutPromote<u16x8>>::Output

impl NormalOut<u16> for f32x4

type Output = <f32x4 as NormalOutPromote<u16x8>>::Output

impl NormalOut<u16> for f64x2

type Output = <f64x2 as NormalOutPromote<u16x8>>::Output

impl NormalOut<u16> for i8x16

type Output = <i8x16 as NormalOutPromote<u16x8>>::Output

impl NormalOut<u16> for i16x8

type Output = <i16x8 as NormalOutPromote<u16x8>>::Output

impl NormalOut<u16> for i32x4

type Output = <i32x4 as NormalOutPromote<u16x8>>::Output

impl NormalOut<u16> for i64x2

type Output = <i64x2 as NormalOutPromote<u16x8>>::Output

impl NormalOut<u16> for isizex2

type Output = <isizex2 as NormalOutPromote<u16x8>>::Output

impl NormalOut<u16> for u8x16

type Output = <u8x16 as NormalOutPromote<u16x8>>::Output

impl NormalOut<u16> for u16x8

type Output = <u16x8 as NormalOutPromote>::Output

impl NormalOut<u16> for u32x4

type Output = <u32x4 as NormalOutPromote<u16x8>>::Output

impl NormalOut<u16> for u64x2

type Output = <u64x2 as NormalOutPromote<u16x8>>::Output

impl NormalOut<u16> for usizex2

type Output = <usizex2 as NormalOutPromote<u16x8>>::Output

impl NormalOut<u32> for bf16x8

type Output = <bf16x8 as NormalOutPromote<u32x4>>::Output

impl NormalOut<u32> for boolx16

type Output = <boolx16 as NormalOutPromote<u32x4>>::Output

impl NormalOut<u32> for cplx32x2

type Output = <cplx32x2 as NormalOutPromote<u32x4>>::Output

impl NormalOut<u32> for cplx64x1

type Output = <cplx64x1 as NormalOutPromote<u32x4>>::Output

impl NormalOut<u32> for f16x8

type Output = <f16x8 as NormalOutPromote<u32x4>>::Output

impl NormalOut<u32> for f32x4

type Output = <f32x4 as NormalOutPromote<u32x4>>::Output

impl NormalOut<u32> for f64x2

type Output = <f64x2 as NormalOutPromote<u32x4>>::Output

impl NormalOut<u32> for i8x16

type Output = <i8x16 as NormalOutPromote<u32x4>>::Output

impl NormalOut<u32> for i16x8

type Output = <i16x8 as NormalOutPromote<u32x4>>::Output

impl NormalOut<u32> for i32x4

type Output = <i32x4 as NormalOutPromote<u32x4>>::Output

impl NormalOut<u32> for i64x2

type Output = <i64x2 as NormalOutPromote<u32x4>>::Output

impl NormalOut<u32> for isizex2

type Output = <isizex2 as NormalOutPromote<u32x4>>::Output

impl NormalOut<u32> for u8x16

type Output = <u8x16 as NormalOutPromote<u32x4>>::Output

impl NormalOut<u32> for u16x8

type Output = <u16x8 as NormalOutPromote<u32x4>>::Output

impl NormalOut<u32> for u32x4

type Output = <u32x4 as NormalOutPromote>::Output

impl NormalOut<u32> for u64x2

type Output = <u64x2 as NormalOutPromote<u32x4>>::Output

impl NormalOut<u32> for usizex2

type Output = <usizex2 as NormalOutPromote<u32x4>>::Output

impl NormalOut<u64> for bf16x8

type Output = <bf16x8 as NormalOutPromote<u64x2>>::Output

impl NormalOut<u64> for boolx16

type Output = <boolx16 as NormalOutPromote<u64x2>>::Output

impl NormalOut<u64> for cplx32x2

type Output = <cplx32x2 as NormalOutPromote<u64x2>>::Output

impl NormalOut<u64> for cplx64x1

type Output = <cplx64x1 as NormalOutPromote<u64x2>>::Output

impl NormalOut<u64> for f16x8

type Output = <f16x8 as NormalOutPromote<u64x2>>::Output

impl NormalOut<u64> for f32x4

type Output = <f32x4 as NormalOutPromote<u64x2>>::Output

impl NormalOut<u64> for f64x2

type Output = <f64x2 as NormalOutPromote<u64x2>>::Output

impl NormalOut<u64> for i8x16

type Output = <i8x16 as NormalOutPromote<u64x2>>::Output

impl NormalOut<u64> for i16x8

type Output = <i16x8 as NormalOutPromote<u64x2>>::Output

impl NormalOut<u64> for i32x4

type Output = <i32x4 as NormalOutPromote<u64x2>>::Output

impl NormalOut<u64> for i64x2

type Output = <i64x2 as NormalOutPromote<u64x2>>::Output

impl NormalOut<u64> for isizex2

type Output = <isizex2 as NormalOutPromote<u64x2>>::Output

impl NormalOut<u64> for u8x16

type Output = <u8x16 as NormalOutPromote<u64x2>>::Output

impl NormalOut<u64> for u16x8

type Output = <u16x8 as NormalOutPromote<u64x2>>::Output

impl NormalOut<u64> for u32x4

type Output = <u32x4 as NormalOutPromote<u64x2>>::Output

impl NormalOut<u64> for u64x2

type Output = <u64x2 as NormalOutPromote>::Output

impl NormalOut<u64> for usizex2

type Output = <usizex2 as NormalOutPromote<u64x2>>::Output

impl NormalOut<usize> for bf16x8

type Output = <bf16x8 as NormalOutPromote<usizex2>>::Output

impl NormalOut<usize> for boolx16

type Output = <boolx16 as NormalOutPromote<usizex2>>::Output

impl NormalOut<usize> for cplx32x2

type Output = <cplx32x2 as NormalOutPromote<usizex2>>::Output

impl NormalOut<usize> for cplx64x1

type Output = <cplx64x1 as NormalOutPromote<usizex2>>::Output

impl NormalOut<usize> for f16x8

type Output = <f16x8 as NormalOutPromote<usizex2>>::Output

impl NormalOut<usize> for f32x4

type Output = <f32x4 as NormalOutPromote<usizex2>>::Output

impl NormalOut<usize> for f64x2

type Output = <f64x2 as NormalOutPromote<usizex2>>::Output

impl NormalOut<usize> for i8x16

type Output = <i8x16 as NormalOutPromote<usizex2>>::Output

impl NormalOut<usize> for i16x8

type Output = <i16x8 as NormalOutPromote<usizex2>>::Output

impl NormalOut<usize> for i32x4

type Output = <i32x4 as NormalOutPromote<usizex2>>::Output

impl NormalOut<usize> for i64x2

type Output = <i64x2 as NormalOutPromote<usizex2>>::Output

impl NormalOut<usize> for isizex2

type Output = <isizex2 as NormalOutPromote<usizex2>>::Output

impl NormalOut<usize> for u8x16

type Output = <u8x16 as NormalOutPromote<usizex2>>::Output

impl NormalOut<usize> for u16x8

type Output = <u16x8 as NormalOutPromote<usizex2>>::Output

impl NormalOut<usize> for u32x4

type Output = <u32x4 as NormalOutPromote<usizex2>>::Output

impl NormalOut<usize> for u64x2

type Output = <u64x2 as NormalOutPromote<usizex2>>::Output

impl NormalOut<usize> for usizex2

type Output = <usizex2 as NormalOutPromote>::Output

impl NormalOut<bf16x8> for boolx16

type Output = <boolx16 as NormalOutPromote<bf16x8>>::Output

impl NormalOut<bf16x8> for cplx32x2

type Output = <cplx32x2 as NormalOutPromote<bf16x8>>::Output

impl NormalOut<bf16x8> for cplx64x1

type Output = <cplx64x1 as NormalOutPromote<bf16x8>>::Output

impl NormalOut<bf16x8> for f16x8

type Output = <f16x8 as NormalOutPromote<bf16x8>>::Output

impl NormalOut<bf16x8> for f32x4

type Output = <f32x4 as NormalOutPromote<bf16x8>>::Output

impl NormalOut<bf16x8> for f64x2

type Output = <f64x2 as NormalOutPromote<bf16x8>>::Output

impl NormalOut<bf16x8> for i8x16

type Output = <i8x16 as NormalOutPromote<bf16x8>>::Output

impl NormalOut<bf16x8> for i16x8

type Output = <i16x8 as NormalOutPromote<bf16x8>>::Output

impl NormalOut<bf16x8> for i32x4

type Output = <i32x4 as NormalOutPromote<bf16x8>>::Output

impl NormalOut<bf16x8> for i64x2

type Output = <i64x2 as NormalOutPromote<bf16x8>>::Output

impl NormalOut<bf16x8> for isizex2

type Output = <isizex2 as NormalOutPromote<bf16x8>>::Output

impl NormalOut<bf16x8> for u8x16

type Output = <u8x16 as NormalOutPromote<bf16x8>>::Output

impl NormalOut<bf16x8> for u16x8

type Output = <u16x8 as NormalOutPromote<bf16x8>>::Output

impl NormalOut<bf16x8> for u32x4

type Output = <u32x4 as NormalOutPromote<bf16x8>>::Output

impl NormalOut<bf16x8> for u64x2

type Output = <u64x2 as NormalOutPromote<bf16x8>>::Output

impl NormalOut<bf16x8> for usizex2

type Output = <usizex2 as NormalOutPromote<bf16x8>>::Output

impl NormalOut<boolx16> for bf16x8

type Output = <bf16x8 as NormalOutPromote<boolx16>>::Output

impl NormalOut<boolx16> for cplx32x2

type Output = <cplx32x2 as NormalOutPromote<boolx16>>::Output

impl NormalOut<boolx16> for cplx64x1

type Output = <cplx64x1 as NormalOutPromote<boolx16>>::Output

impl NormalOut<boolx16> for f16x8

type Output = <f16x8 as NormalOutPromote<boolx16>>::Output

impl NormalOut<boolx16> for f32x4

type Output = <f32x4 as NormalOutPromote<boolx16>>::Output

impl NormalOut<boolx16> for f64x2

type Output = <f64x2 as NormalOutPromote<boolx16>>::Output

impl NormalOut<boolx16> for i8x16

type Output = <i8x16 as NormalOutPromote<boolx16>>::Output

impl NormalOut<boolx16> for i16x8

type Output = <i16x8 as NormalOutPromote<boolx16>>::Output

impl NormalOut<boolx16> for i32x4

type Output = <i32x4 as NormalOutPromote<boolx16>>::Output

impl NormalOut<boolx16> for i64x2

type Output = <i64x2 as NormalOutPromote<boolx16>>::Output

impl NormalOut<boolx16> for isizex2

type Output = <isizex2 as NormalOutPromote<boolx16>>::Output

impl NormalOut<boolx16> for u8x16

type Output = <u8x16 as NormalOutPromote<boolx16>>::Output

impl NormalOut<boolx16> for u16x8

type Output = <u16x8 as NormalOutPromote<boolx16>>::Output

impl NormalOut<boolx16> for u32x4

type Output = <u32x4 as NormalOutPromote<boolx16>>::Output

impl NormalOut<boolx16> for u64x2

type Output = <u64x2 as NormalOutPromote<boolx16>>::Output

impl NormalOut<boolx16> for usizex2

type Output = <usizex2 as NormalOutPromote<boolx16>>::Output

impl NormalOut<cplx32x2> for bf16x8

type Output = <bf16x8 as NormalOutPromote<cplx32x2>>::Output

impl NormalOut<cplx32x2> for boolx16

type Output = <boolx16 as NormalOutPromote<cplx32x2>>::Output

impl NormalOut<cplx32x2> for cplx64x1

type Output = <cplx64x1 as NormalOutPromote<cplx32x2>>::Output

impl NormalOut<cplx32x2> for f16x8

type Output = <f16x8 as NormalOutPromote<cplx32x2>>::Output

impl NormalOut<cplx32x2> for f32x4

type Output = <f32x4 as NormalOutPromote<cplx32x2>>::Output

impl NormalOut<cplx32x2> for f64x2

type Output = <f64x2 as NormalOutPromote<cplx32x2>>::Output

impl NormalOut<cplx32x2> for i8x16

type Output = <i8x16 as NormalOutPromote<cplx32x2>>::Output

impl NormalOut<cplx32x2> for i16x8

type Output = <i16x8 as NormalOutPromote<cplx32x2>>::Output

impl NormalOut<cplx32x2> for i32x4

type Output = <i32x4 as NormalOutPromote<cplx32x2>>::Output

impl NormalOut<cplx32x2> for i64x2

type Output = <i64x2 as NormalOutPromote<cplx32x2>>::Output

impl NormalOut<cplx32x2> for isizex2

type Output = <isizex2 as NormalOutPromote<cplx32x2>>::Output

impl NormalOut<cplx32x2> for u8x16

type Output = <u8x16 as NormalOutPromote<cplx32x2>>::Output

impl NormalOut<cplx32x2> for u16x8

type Output = <u16x8 as NormalOutPromote<cplx32x2>>::Output

impl NormalOut<cplx32x2> for u32x4

type Output = <u32x4 as NormalOutPromote<cplx32x2>>::Output

impl NormalOut<cplx32x2> for u64x2

type Output = <u64x2 as NormalOutPromote<cplx32x2>>::Output

impl NormalOut<cplx32x2> for usizex2

type Output = <usizex2 as NormalOutPromote<cplx32x2>>::Output

impl NormalOut<cplx64x1> for bf16x8

type Output = <bf16x8 as NormalOutPromote<cplx64x1>>::Output

impl NormalOut<cplx64x1> for boolx16

type Output = <boolx16 as NormalOutPromote<cplx64x1>>::Output

impl NormalOut<cplx64x1> for cplx32x2

type Output = <cplx32x2 as NormalOutPromote<cplx64x1>>::Output

impl NormalOut<cplx64x1> for f16x8

type Output = <f16x8 as NormalOutPromote<cplx64x1>>::Output

impl NormalOut<cplx64x1> for f32x4

type Output = <f32x4 as NormalOutPromote<cplx64x1>>::Output

impl NormalOut<cplx64x1> for f64x2

type Output = <f64x2 as NormalOutPromote<cplx64x1>>::Output

impl NormalOut<cplx64x1> for i8x16

type Output = <i8x16 as NormalOutPromote<cplx64x1>>::Output

impl NormalOut<cplx64x1> for i16x8

type Output = <i16x8 as NormalOutPromote<cplx64x1>>::Output

impl NormalOut<cplx64x1> for i32x4

type Output = <i32x4 as NormalOutPromote<cplx64x1>>::Output

impl NormalOut<cplx64x1> for i64x2

type Output = <i64x2 as NormalOutPromote<cplx64x1>>::Output

impl NormalOut<cplx64x1> for isizex2

type Output = <isizex2 as NormalOutPromote<cplx64x1>>::Output

impl NormalOut<cplx64x1> for u8x16

type Output = <u8x16 as NormalOutPromote<cplx64x1>>::Output

impl NormalOut<cplx64x1> for u16x8

type Output = <u16x8 as NormalOutPromote<cplx64x1>>::Output

impl NormalOut<cplx64x1> for u32x4

type Output = <u32x4 as NormalOutPromote<cplx64x1>>::Output

impl NormalOut<cplx64x1> for u64x2

type Output = <u64x2 as NormalOutPromote<cplx64x1>>::Output

impl NormalOut<cplx64x1> for usizex2

type Output = <usizex2 as NormalOutPromote<cplx64x1>>::Output

impl NormalOut<f16x8> for bf16x8

type Output = <bf16x8 as NormalOutPromote<f16x8>>::Output

impl NormalOut<f16x8> for boolx16

type Output = <boolx16 as NormalOutPromote<f16x8>>::Output

impl NormalOut<f16x8> for cplx32x2

type Output = <cplx32x2 as NormalOutPromote<f16x8>>::Output

impl NormalOut<f16x8> for cplx64x1

type Output = <cplx64x1 as NormalOutPromote<f16x8>>::Output

impl NormalOut<f16x8> for f32x4

type Output = <f32x4 as NormalOutPromote<f16x8>>::Output

impl NormalOut<f16x8> for f64x2

type Output = <f64x2 as NormalOutPromote<f16x8>>::Output

impl NormalOut<f16x8> for i8x16

type Output = <i8x16 as NormalOutPromote<f16x8>>::Output

impl NormalOut<f16x8> for i16x8

type Output = <i16x8 as NormalOutPromote<f16x8>>::Output

impl NormalOut<f16x8> for i32x4

type Output = <i32x4 as NormalOutPromote<f16x8>>::Output

impl NormalOut<f16x8> for i64x2

type Output = <i64x2 as NormalOutPromote<f16x8>>::Output

impl NormalOut<f16x8> for isizex2

type Output = <isizex2 as NormalOutPromote<f16x8>>::Output

impl NormalOut<f16x8> for u8x16

type Output = <u8x16 as NormalOutPromote<f16x8>>::Output

impl NormalOut<f16x8> for u16x8

type Output = <u16x8 as NormalOutPromote<f16x8>>::Output

impl NormalOut<f16x8> for u32x4

type Output = <u32x4 as NormalOutPromote<f16x8>>::Output

impl NormalOut<f16x8> for u64x2

type Output = <u64x2 as NormalOutPromote<f16x8>>::Output

impl NormalOut<f16x8> for usizex2

type Output = <usizex2 as NormalOutPromote<f16x8>>::Output

impl NormalOut<f32x4> for bf16x8

type Output = <bf16x8 as NormalOutPromote<f32x4>>::Output

impl NormalOut<f32x4> for boolx16

type Output = <boolx16 as NormalOutPromote<f32x4>>::Output

impl NormalOut<f32x4> for cplx32x2

type Output = <cplx32x2 as NormalOutPromote<f32x4>>::Output

impl NormalOut<f32x4> for cplx64x1

type Output = <cplx64x1 as NormalOutPromote<f32x4>>::Output

impl NormalOut<f32x4> for f16x8

type Output = <f16x8 as NormalOutPromote<f32x4>>::Output

impl NormalOut<f32x4> for f64x2

type Output = <f64x2 as NormalOutPromote<f32x4>>::Output

impl NormalOut<f32x4> for i8x16

type Output = <i8x16 as NormalOutPromote<f32x4>>::Output

impl NormalOut<f32x4> for i16x8

type Output = <i16x8 as NormalOutPromote<f32x4>>::Output

impl NormalOut<f32x4> for i32x4

type Output = <i32x4 as NormalOutPromote<f32x4>>::Output

impl NormalOut<f32x4> for i64x2

type Output = <i64x2 as NormalOutPromote<f32x4>>::Output

impl NormalOut<f32x4> for isizex2

type Output = <isizex2 as NormalOutPromote<f32x4>>::Output

impl NormalOut<f32x4> for u8x16

type Output = <u8x16 as NormalOutPromote<f32x4>>::Output

impl NormalOut<f32x4> for u16x8

type Output = <u16x8 as NormalOutPromote<f32x4>>::Output

impl NormalOut<f32x4> for u32x4

type Output = <u32x4 as NormalOutPromote<f32x4>>::Output

impl NormalOut<f32x4> for u64x2

type Output = <u64x2 as NormalOutPromote<f32x4>>::Output

impl NormalOut<f32x4> for usizex2

type Output = <usizex2 as NormalOutPromote<f32x4>>::Output

impl NormalOut<f64x2> for bf16x8

type Output = <bf16x8 as NormalOutPromote<f64x2>>::Output

impl NormalOut<f64x2> for boolx16

type Output = <boolx16 as NormalOutPromote<f64x2>>::Output

impl NormalOut<f64x2> for cplx32x2

type Output = <cplx32x2 as NormalOutPromote<f64x2>>::Output

impl NormalOut<f64x2> for cplx64x1

type Output = <cplx64x1 as NormalOutPromote<f64x2>>::Output

impl NormalOut<f64x2> for f16x8

type Output = <f16x8 as NormalOutPromote<f64x2>>::Output

impl NormalOut<f64x2> for f32x4

type Output = <f32x4 as NormalOutPromote<f64x2>>::Output

impl NormalOut<f64x2> for i8x16

type Output = <i8x16 as NormalOutPromote<f64x2>>::Output

impl NormalOut<f64x2> for i16x8

type Output = <i16x8 as NormalOutPromote<f64x2>>::Output

impl NormalOut<f64x2> for i32x4

type Output = <i32x4 as NormalOutPromote<f64x2>>::Output

impl NormalOut<f64x2> for i64x2

type Output = <i64x2 as NormalOutPromote<f64x2>>::Output

impl NormalOut<f64x2> for isizex2

type Output = <isizex2 as NormalOutPromote<f64x2>>::Output

impl NormalOut<f64x2> for u8x16

type Output = <u8x16 as NormalOutPromote<f64x2>>::Output

impl NormalOut<f64x2> for u16x8

type Output = <u16x8 as NormalOutPromote<f64x2>>::Output

impl NormalOut<f64x2> for u32x4

type Output = <u32x4 as NormalOutPromote<f64x2>>::Output

impl NormalOut<f64x2> for u64x2

type Output = <u64x2 as NormalOutPromote<f64x2>>::Output

impl NormalOut<f64x2> for usizex2

type Output = <usizex2 as NormalOutPromote<f64x2>>::Output

impl NormalOut<i8x16> for bf16x8

type Output = <bf16x8 as NormalOutPromote<i8x16>>::Output

impl NormalOut<i8x16> for boolx16

type Output = <boolx16 as NormalOutPromote<i8x16>>::Output

impl NormalOut<i8x16> for cplx32x2

type Output = <cplx32x2 as NormalOutPromote<i8x16>>::Output

impl NormalOut<i8x16> for cplx64x1

type Output = <cplx64x1 as NormalOutPromote<i8x16>>::Output

impl NormalOut<i8x16> for f16x8

type Output = <f16x8 as NormalOutPromote<i8x16>>::Output

impl NormalOut<i8x16> for f32x4

type Output = <f32x4 as NormalOutPromote<i8x16>>::Output

impl NormalOut<i8x16> for f64x2

type Output = <f64x2 as NormalOutPromote<i8x16>>::Output

impl NormalOut<i8x16> for i16x8

type Output = <i16x8 as NormalOutPromote<i8x16>>::Output

impl NormalOut<i8x16> for i32x4

type Output = <i32x4 as NormalOutPromote<i8x16>>::Output

impl NormalOut<i8x16> for i64x2

type Output = <i64x2 as NormalOutPromote<i8x16>>::Output

impl NormalOut<i8x16> for isizex2

type Output = <isizex2 as NormalOutPromote<i8x16>>::Output

impl NormalOut<i8x16> for u8x16

type Output = <u8x16 as NormalOutPromote<i8x16>>::Output

impl NormalOut<i8x16> for u16x8

type Output = <u16x8 as NormalOutPromote<i8x16>>::Output

impl NormalOut<i8x16> for u32x4

type Output = <u32x4 as NormalOutPromote<i8x16>>::Output

impl NormalOut<i8x16> for u64x2

type Output = <u64x2 as NormalOutPromote<i8x16>>::Output

impl NormalOut<i8x16> for usizex2

type Output = <usizex2 as NormalOutPromote<i8x16>>::Output

impl NormalOut<i16x8> for bf16x8

type Output = <bf16x8 as NormalOutPromote<i16x8>>::Output

impl NormalOut<i16x8> for boolx16

type Output = <boolx16 as NormalOutPromote<i16x8>>::Output

impl NormalOut<i16x8> for cplx32x2

type Output = <cplx32x2 as NormalOutPromote<i16x8>>::Output

impl NormalOut<i16x8> for cplx64x1

type Output = <cplx64x1 as NormalOutPromote<i16x8>>::Output

impl NormalOut<i16x8> for f16x8

type Output = <f16x8 as NormalOutPromote<i16x8>>::Output

impl NormalOut<i16x8> for f32x4

type Output = <f32x4 as NormalOutPromote<i16x8>>::Output

impl NormalOut<i16x8> for f64x2

type Output = <f64x2 as NormalOutPromote<i16x8>>::Output

impl NormalOut<i16x8> for i8x16

type Output = <i8x16 as NormalOutPromote<i16x8>>::Output

impl NormalOut<i16x8> for i32x4

type Output = <i32x4 as NormalOutPromote<i16x8>>::Output

impl NormalOut<i16x8> for i64x2

type Output = <i64x2 as NormalOutPromote<i16x8>>::Output

impl NormalOut<i16x8> for isizex2

type Output = <isizex2 as NormalOutPromote<i16x8>>::Output

impl NormalOut<i16x8> for u8x16

type Output = <u8x16 as NormalOutPromote<i16x8>>::Output

impl NormalOut<i16x8> for u16x8

type Output = <u16x8 as NormalOutPromote<i16x8>>::Output

impl NormalOut<i16x8> for u32x4

type Output = <u32x4 as NormalOutPromote<i16x8>>::Output

impl NormalOut<i16x8> for u64x2

type Output = <u64x2 as NormalOutPromote<i16x8>>::Output

impl NormalOut<i16x8> for usizex2

type Output = <usizex2 as NormalOutPromote<i16x8>>::Output

impl NormalOut<i32x4> for bf16x8

type Output = <bf16x8 as NormalOutPromote<i32x4>>::Output

impl NormalOut<i32x4> for boolx16

type Output = <boolx16 as NormalOutPromote<i32x4>>::Output

impl NormalOut<i32x4> for cplx32x2

type Output = <cplx32x2 as NormalOutPromote<i32x4>>::Output

impl NormalOut<i32x4> for cplx64x1

type Output = <cplx64x1 as NormalOutPromote<i32x4>>::Output

impl NormalOut<i32x4> for f16x8

type Output = <f16x8 as NormalOutPromote<i32x4>>::Output

impl NormalOut<i32x4> for f32x4

type Output = <f32x4 as NormalOutPromote<i32x4>>::Output

impl NormalOut<i32x4> for f64x2

type Output = <f64x2 as NormalOutPromote<i32x4>>::Output

impl NormalOut<i32x4> for i8x16

type Output = <i8x16 as NormalOutPromote<i32x4>>::Output

impl NormalOut<i32x4> for i16x8

type Output = <i16x8 as NormalOutPromote<i32x4>>::Output

impl NormalOut<i32x4> for i64x2

type Output = <i64x2 as NormalOutPromote<i32x4>>::Output

impl NormalOut<i32x4> for isizex2

type Output = <isizex2 as NormalOutPromote<i32x4>>::Output

impl NormalOut<i32x4> for u8x16

type Output = <u8x16 as NormalOutPromote<i32x4>>::Output

impl NormalOut<i32x4> for u16x8

type Output = <u16x8 as NormalOutPromote<i32x4>>::Output

impl NormalOut<i32x4> for u32x4

type Output = <u32x4 as NormalOutPromote<i32x4>>::Output

impl NormalOut<i32x4> for u64x2

type Output = <u64x2 as NormalOutPromote<i32x4>>::Output

impl NormalOut<i32x4> for usizex2

type Output = <usizex2 as NormalOutPromote<i32x4>>::Output

impl NormalOut<i64x2> for bf16x8

type Output = <bf16x8 as NormalOutPromote<i64x2>>::Output

impl NormalOut<i64x2> for boolx16

type Output = <boolx16 as NormalOutPromote<i64x2>>::Output

impl NormalOut<i64x2> for cplx32x2

type Output = <cplx32x2 as NormalOutPromote<i64x2>>::Output

impl NormalOut<i64x2> for cplx64x1

type Output = <cplx64x1 as NormalOutPromote<i64x2>>::Output

impl NormalOut<i64x2> for f16x8

type Output = <f16x8 as NormalOutPromote<i64x2>>::Output

impl NormalOut<i64x2> for f32x4

type Output = <f32x4 as NormalOutPromote<i64x2>>::Output

impl NormalOut<i64x2> for f64x2

type Output = <f64x2 as NormalOutPromote<i64x2>>::Output

impl NormalOut<i64x2> for i8x16

type Output = <i8x16 as NormalOutPromote<i64x2>>::Output

impl NormalOut<i64x2> for i16x8

type Output = <i16x8 as NormalOutPromote<i64x2>>::Output

impl NormalOut<i64x2> for i32x4

type Output = <i32x4 as NormalOutPromote<i64x2>>::Output

impl NormalOut<i64x2> for isizex2

type Output = <isizex2 as NormalOutPromote<i64x2>>::Output

impl NormalOut<i64x2> for u8x16

type Output = <u8x16 as NormalOutPromote<i64x2>>::Output

impl NormalOut<i64x2> for u16x8

type Output = <u16x8 as NormalOutPromote<i64x2>>::Output

impl NormalOut<i64x2> for u32x4

type Output = <u32x4 as NormalOutPromote<i64x2>>::Output

impl NormalOut<i64x2> for u64x2

type Output = <u64x2 as NormalOutPromote<i64x2>>::Output

impl NormalOut<i64x2> for usizex2

type Output = <usizex2 as NormalOutPromote<i64x2>>::Output

impl NormalOut<isizex2> for bf16x8

type Output = <bf16x8 as NormalOutPromote<isizex2>>::Output

impl NormalOut<isizex2> for boolx16

type Output = <boolx16 as NormalOutPromote<isizex2>>::Output

impl NormalOut<isizex2> for cplx32x2

type Output = <cplx32x2 as NormalOutPromote<isizex2>>::Output

impl NormalOut<isizex2> for cplx64x1

type Output = <cplx64x1 as NormalOutPromote<isizex2>>::Output

impl NormalOut<isizex2> for f16x8

type Output = <f16x8 as NormalOutPromote<isizex2>>::Output

impl NormalOut<isizex2> for f32x4

type Output = <f32x4 as NormalOutPromote<isizex2>>::Output

impl NormalOut<isizex2> for f64x2

type Output = <f64x2 as NormalOutPromote<isizex2>>::Output

impl NormalOut<isizex2> for i8x16

type Output = <i8x16 as NormalOutPromote<isizex2>>::Output

impl NormalOut<isizex2> for i16x8

type Output = <i16x8 as NormalOutPromote<isizex2>>::Output

impl NormalOut<isizex2> for i32x4

type Output = <i32x4 as NormalOutPromote<isizex2>>::Output

impl NormalOut<isizex2> for i64x2

type Output = <i64x2 as NormalOutPromote<isizex2>>::Output

impl NormalOut<isizex2> for u8x16

type Output = <u8x16 as NormalOutPromote<isizex2>>::Output

impl NormalOut<isizex2> for u16x8

type Output = <u16x8 as NormalOutPromote<isizex2>>::Output

impl NormalOut<isizex2> for u32x4

type Output = <u32x4 as NormalOutPromote<isizex2>>::Output

impl NormalOut<isizex2> for u64x2

type Output = <u64x2 as NormalOutPromote<isizex2>>::Output

impl NormalOut<isizex2> for usizex2

type Output = <usizex2 as NormalOutPromote<isizex2>>::Output

impl NormalOut<u8x16> for bf16x8

type Output = <bf16x8 as NormalOutPromote<u8x16>>::Output

impl NormalOut<u8x16> for boolx16

type Output = <boolx16 as NormalOutPromote<u8x16>>::Output

impl NormalOut<u8x16> for cplx32x2

type Output = <cplx32x2 as NormalOutPromote<u8x16>>::Output

impl NormalOut<u8x16> for cplx64x1

type Output = <cplx64x1 as NormalOutPromote<u8x16>>::Output

impl NormalOut<u8x16> for f16x8

type Output = <f16x8 as NormalOutPromote<u8x16>>::Output

impl NormalOut<u8x16> for f32x4

type Output = <f32x4 as NormalOutPromote<u8x16>>::Output

impl NormalOut<u8x16> for f64x2

type Output = <f64x2 as NormalOutPromote<u8x16>>::Output

impl NormalOut<u8x16> for i8x16

type Output = <i8x16 as NormalOutPromote<u8x16>>::Output

impl NormalOut<u8x16> for i16x8

type Output = <i16x8 as NormalOutPromote<u8x16>>::Output

impl NormalOut<u8x16> for i32x4

type Output = <i32x4 as NormalOutPromote<u8x16>>::Output

impl NormalOut<u8x16> for i64x2

type Output = <i64x2 as NormalOutPromote<u8x16>>::Output

impl NormalOut<u8x16> for isizex2

type Output = <isizex2 as NormalOutPromote<u8x16>>::Output

impl NormalOut<u8x16> for u16x8

type Output = <u16x8 as NormalOutPromote<u8x16>>::Output

impl NormalOut<u8x16> for u32x4

type Output = <u32x4 as NormalOutPromote<u8x16>>::Output

impl NormalOut<u8x16> for u64x2

type Output = <u64x2 as NormalOutPromote<u8x16>>::Output

impl NormalOut<u8x16> for usizex2

type Output = <usizex2 as NormalOutPromote<u8x16>>::Output

impl NormalOut<u16x8> for bf16x8

type Output = <bf16x8 as NormalOutPromote<u16x8>>::Output

impl NormalOut<u16x8> for boolx16

type Output = <boolx16 as NormalOutPromote<u16x8>>::Output

impl NormalOut<u16x8> for cplx32x2

type Output = <cplx32x2 as NormalOutPromote<u16x8>>::Output

impl NormalOut<u16x8> for cplx64x1

type Output = <cplx64x1 as NormalOutPromote<u16x8>>::Output

impl NormalOut<u16x8> for f16x8

type Output = <f16x8 as NormalOutPromote<u16x8>>::Output

impl NormalOut<u16x8> for f32x4

type Output = <f32x4 as NormalOutPromote<u16x8>>::Output

impl NormalOut<u16x8> for f64x2

type Output = <f64x2 as NormalOutPromote<u16x8>>::Output

impl NormalOut<u16x8> for i8x16

type Output = <i8x16 as NormalOutPromote<u16x8>>::Output

impl NormalOut<u16x8> for i16x8

type Output = <i16x8 as NormalOutPromote<u16x8>>::Output

impl NormalOut<u16x8> for i32x4

type Output = <i32x4 as NormalOutPromote<u16x8>>::Output

impl NormalOut<u16x8> for i64x2

type Output = <i64x2 as NormalOutPromote<u16x8>>::Output

impl NormalOut<u16x8> for isizex2

type Output = <isizex2 as NormalOutPromote<u16x8>>::Output

impl NormalOut<u16x8> for u8x16

type Output = <u8x16 as NormalOutPromote<u16x8>>::Output

impl NormalOut<u16x8> for u32x4

type Output = <u32x4 as NormalOutPromote<u16x8>>::Output

impl NormalOut<u16x8> for u64x2

type Output = <u64x2 as NormalOutPromote<u16x8>>::Output

impl NormalOut<u16x8> for usizex2

type Output = <usizex2 as NormalOutPromote<u16x8>>::Output

impl NormalOut<u32x4> for bf16x8

type Output = <bf16x8 as NormalOutPromote<u32x4>>::Output

impl NormalOut<u32x4> for boolx16

type Output = <boolx16 as NormalOutPromote<u32x4>>::Output

impl NormalOut<u32x4> for cplx32x2

type Output = <cplx32x2 as NormalOutPromote<u32x4>>::Output

impl NormalOut<u32x4> for cplx64x1

type Output = <cplx64x1 as NormalOutPromote<u32x4>>::Output

impl NormalOut<u32x4> for f16x8

type Output = <f16x8 as NormalOutPromote<u32x4>>::Output

impl NormalOut<u32x4> for f32x4

type Output = <f32x4 as NormalOutPromote<u32x4>>::Output

impl NormalOut<u32x4> for f64x2

type Output = <f64x2 as NormalOutPromote<u32x4>>::Output

impl NormalOut<u32x4> for i8x16

type Output = <i8x16 as NormalOutPromote<u32x4>>::Output

impl NormalOut<u32x4> for i16x8

type Output = <i16x8 as NormalOutPromote<u32x4>>::Output

impl NormalOut<u32x4> for i32x4

type Output = <i32x4 as NormalOutPromote<u32x4>>::Output

impl NormalOut<u32x4> for i64x2

type Output = <i64x2 as NormalOutPromote<u32x4>>::Output

impl NormalOut<u32x4> for isizex2

type Output = <isizex2 as NormalOutPromote<u32x4>>::Output

impl NormalOut<u32x4> for u8x16

type Output = <u8x16 as NormalOutPromote<u32x4>>::Output

impl NormalOut<u32x4> for u16x8

type Output = <u16x8 as NormalOutPromote<u32x4>>::Output

impl NormalOut<u32x4> for u64x2

type Output = <u64x2 as NormalOutPromote<u32x4>>::Output

impl NormalOut<u32x4> for usizex2

type Output = <usizex2 as NormalOutPromote<u32x4>>::Output

impl NormalOut<u64x2> for bf16x8

type Output = <bf16x8 as NormalOutPromote<u64x2>>::Output

impl NormalOut<u64x2> for boolx16

type Output = <boolx16 as NormalOutPromote<u64x2>>::Output

impl NormalOut<u64x2> for cplx32x2

type Output = <cplx32x2 as NormalOutPromote<u64x2>>::Output

impl NormalOut<u64x2> for cplx64x1

type Output = <cplx64x1 as NormalOutPromote<u64x2>>::Output

impl NormalOut<u64x2> for f16x8

type Output = <f16x8 as NormalOutPromote<u64x2>>::Output

impl NormalOut<u64x2> for f32x4

type Output = <f32x4 as NormalOutPromote<u64x2>>::Output

impl NormalOut<u64x2> for f64x2

type Output = <f64x2 as NormalOutPromote<u64x2>>::Output

impl NormalOut<u64x2> for i8x16

type Output = <i8x16 as NormalOutPromote<u64x2>>::Output

impl NormalOut<u64x2> for i16x8

type Output = <i16x8 as NormalOutPromote<u64x2>>::Output

impl NormalOut<u64x2> for i32x4

type Output = <i32x4 as NormalOutPromote<u64x2>>::Output

impl NormalOut<u64x2> for i64x2

type Output = <i64x2 as NormalOutPromote<u64x2>>::Output

impl NormalOut<u64x2> for isizex2

type Output = <isizex2 as NormalOutPromote<u64x2>>::Output

impl NormalOut<u64x2> for u8x16

type Output = <u8x16 as NormalOutPromote<u64x2>>::Output

impl NormalOut<u64x2> for u16x8

type Output = <u16x8 as NormalOutPromote<u64x2>>::Output

impl NormalOut<u64x2> for u32x4

type Output = <u32x4 as NormalOutPromote<u64x2>>::Output

impl NormalOut<u64x2> for usizex2

type Output = <usizex2 as NormalOutPromote<u64x2>>::Output

impl NormalOut<usizex2> for bf16x8

type Output = <bf16x8 as NormalOutPromote<usizex2>>::Output

impl NormalOut<usizex2> for boolx16

type Output = <boolx16 as NormalOutPromote<usizex2>>::Output

impl NormalOut<usizex2> for cplx32x2

type Output = <cplx32x2 as NormalOutPromote<usizex2>>::Output

impl NormalOut<usizex2> for cplx64x1

type Output = <cplx64x1 as NormalOutPromote<usizex2>>::Output

impl NormalOut<usizex2> for f16x8

type Output = <f16x8 as NormalOutPromote<usizex2>>::Output

impl NormalOut<usizex2> for f32x4

type Output = <f32x4 as NormalOutPromote<usizex2>>::Output

impl NormalOut<usizex2> for f64x2

type Output = <f64x2 as NormalOutPromote<usizex2>>::Output

impl NormalOut<usizex2> for i8x16

type Output = <i8x16 as NormalOutPromote<usizex2>>::Output

impl NormalOut<usizex2> for i16x8

type Output = <i16x8 as NormalOutPromote<usizex2>>::Output

impl NormalOut<usizex2> for i32x4

type Output = <i32x4 as NormalOutPromote<usizex2>>::Output

impl NormalOut<usizex2> for i64x2

type Output = <i64x2 as NormalOutPromote<usizex2>>::Output

impl NormalOut<usizex2> for isizex2

type Output = <isizex2 as NormalOutPromote<usizex2>>::Output

impl NormalOut<usizex2> for u8x16

type Output = <u8x16 as NormalOutPromote<usizex2>>::Output

impl NormalOut<usizex2> for u16x8

type Output = <u16x8 as NormalOutPromote<usizex2>>::Output

impl NormalOut<usizex2> for u32x4

type Output = <u32x4 as NormalOutPromote<usizex2>>::Output

impl NormalOut<usizex2> for u64x2

type Output = <u64x2 as NormalOutPromote<usizex2>>::Output

impl NormalOut<bf16> for bf16x8

type Output = <bf16x8 as NormalOutPromote>::Output

impl NormalOut<bf16> for boolx16

type Output = <boolx16 as NormalOutPromote<bf16x8>>::Output

impl NormalOut<bf16> for cplx32x2

type Output = <cplx32x2 as NormalOutPromote<bf16x8>>::Output

impl NormalOut<bf16> for cplx64x1

type Output = <cplx64x1 as NormalOutPromote<bf16x8>>::Output

impl NormalOut<bf16> for f16x8

type Output = <f16x8 as NormalOutPromote<bf16x8>>::Output

impl NormalOut<bf16> for f32x4

type Output = <f32x4 as NormalOutPromote<bf16x8>>::Output

impl NormalOut<bf16> for f64x2

type Output = <f64x2 as NormalOutPromote<bf16x8>>::Output

impl NormalOut<bf16> for i8x16

type Output = <i8x16 as NormalOutPromote<bf16x8>>::Output

impl NormalOut<bf16> for i16x8

type Output = <i16x8 as NormalOutPromote<bf16x8>>::Output

impl NormalOut<bf16> for i32x4

type Output = <i32x4 as NormalOutPromote<bf16x8>>::Output

impl NormalOut<bf16> for i64x2

type Output = <i64x2 as NormalOutPromote<bf16x8>>::Output

impl NormalOut<bf16> for isizex2

type Output = <isizex2 as NormalOutPromote<bf16x8>>::Output

impl NormalOut<bf16> for u8x16

type Output = <u8x16 as NormalOutPromote<bf16x8>>::Output

impl NormalOut<bf16> for u16x8

type Output = <u16x8 as NormalOutPromote<bf16x8>>::Output

impl NormalOut<bf16> for u32x4

type Output = <u32x4 as NormalOutPromote<bf16x8>>::Output

impl NormalOut<bf16> for u64x2

type Output = <u64x2 as NormalOutPromote<bf16x8>>::Output

impl NormalOut<bf16> for usizex2

type Output = <usizex2 as NormalOutPromote<bf16x8>>::Output

impl NormalOut<f16> for bf16x8

type Output = <bf16x8 as NormalOutPromote<f16x8>>::Output

impl NormalOut<f16> for boolx16

type Output = <boolx16 as NormalOutPromote<f16x8>>::Output

impl NormalOut<f16> for cplx32x2

type Output = <cplx32x2 as NormalOutPromote<f16x8>>::Output

impl NormalOut<f16> for cplx64x1

type Output = <cplx64x1 as NormalOutPromote<f16x8>>::Output

impl NormalOut<f16> for f16x8

type Output = <f16x8 as NormalOutPromote>::Output

impl NormalOut<f16> for f32x4

type Output = <f32x4 as NormalOutPromote<f16x8>>::Output

impl NormalOut<f16> for f64x2

type Output = <f64x2 as NormalOutPromote<f16x8>>::Output

impl NormalOut<f16> for i8x16

type Output = <i8x16 as NormalOutPromote<f16x8>>::Output

impl NormalOut<f16> for i16x8

type Output = <i16x8 as NormalOutPromote<f16x8>>::Output

impl NormalOut<f16> for i32x4

type Output = <i32x4 as NormalOutPromote<f16x8>>::Output

impl NormalOut<f16> for i64x2

type Output = <i64x2 as NormalOutPromote<f16x8>>::Output

impl NormalOut<f16> for isizex2

type Output = <isizex2 as NormalOutPromote<f16x8>>::Output

impl NormalOut<f16> for u8x16

type Output = <u8x16 as NormalOutPromote<f16x8>>::Output

impl NormalOut<f16> for u16x8

type Output = <u16x8 as NormalOutPromote<f16x8>>::Output

impl NormalOut<f16> for u32x4

type Output = <u32x4 as NormalOutPromote<f16x8>>::Output

impl NormalOut<f16> for u64x2

type Output = <u64x2 as NormalOutPromote<f16x8>>::Output

impl NormalOut<f16> for usizex2

type Output = <usizex2 as NormalOutPromote<f16x8>>::Output

impl NormalOut<Complex<f32>> for bf16x8

type Output = <bf16x8 as NormalOutPromote<cplx32x2>>::Output

impl NormalOut<Complex<f32>> for boolx16

type Output = <boolx16 as NormalOutPromote<cplx32x2>>::Output

impl NormalOut<Complex<f32>> for cplx32x2

type Output = <cplx32x2 as NormalOutPromote>::Output

impl NormalOut<Complex<f32>> for cplx64x1

type Output = <cplx64x1 as NormalOutPromote<cplx32x2>>::Output

impl NormalOut<Complex<f32>> for f16x8

type Output = <f16x8 as NormalOutPromote<cplx32x2>>::Output

impl NormalOut<Complex<f32>> for f32x4

type Output = <f32x4 as NormalOutPromote<cplx32x2>>::Output

impl NormalOut<Complex<f32>> for f64x2

type Output = <f64x2 as NormalOutPromote<cplx32x2>>::Output

impl NormalOut<Complex<f32>> for i8x16

type Output = <i8x16 as NormalOutPromote<cplx32x2>>::Output

impl NormalOut<Complex<f32>> for i16x8

type Output = <i16x8 as NormalOutPromote<cplx32x2>>::Output

impl NormalOut<Complex<f32>> for i32x4

type Output = <i32x4 as NormalOutPromote<cplx32x2>>::Output

impl NormalOut<Complex<f32>> for i64x2

type Output = <i64x2 as NormalOutPromote<cplx32x2>>::Output

impl NormalOut<Complex<f32>> for isizex2

type Output = <isizex2 as NormalOutPromote<cplx32x2>>::Output

impl NormalOut<Complex<f32>> for u8x16

type Output = <u8x16 as NormalOutPromote<cplx32x2>>::Output

impl NormalOut<Complex<f32>> for u16x8

type Output = <u16x8 as NormalOutPromote<cplx32x2>>::Output

impl NormalOut<Complex<f32>> for u32x4

type Output = <u32x4 as NormalOutPromote<cplx32x2>>::Output

impl NormalOut<Complex<f32>> for u64x2

type Output = <u64x2 as NormalOutPromote<cplx32x2>>::Output

impl NormalOut<Complex<f32>> for usizex2

type Output = <usizex2 as NormalOutPromote<cplx32x2>>::Output

impl NormalOut<Complex<f64>> for bf16x8

type Output = <bf16x8 as NormalOutPromote<cplx64x1>>::Output

impl NormalOut<Complex<f64>> for boolx16

type Output = <boolx16 as NormalOutPromote<cplx64x1>>::Output

impl NormalOut<Complex<f64>> for cplx32x2

type Output = <cplx32x2 as NormalOutPromote<cplx64x1>>::Output

impl NormalOut<Complex<f64>> for cplx64x1

type Output = <cplx64x1 as NormalOutPromote>::Output

impl NormalOut<Complex<f64>> for f16x8

type Output = <f16x8 as NormalOutPromote<cplx64x1>>::Output

impl NormalOut<Complex<f64>> for f32x4

type Output = <f32x4 as NormalOutPromote<cplx64x1>>::Output

impl NormalOut<Complex<f64>> for f64x2

type Output = <f64x2 as NormalOutPromote<cplx64x1>>::Output

impl NormalOut<Complex<f64>> for i8x16

type Output = <i8x16 as NormalOutPromote<cplx64x1>>::Output

impl NormalOut<Complex<f64>> for i16x8

type Output = <i16x8 as NormalOutPromote<cplx64x1>>::Output

impl NormalOut<Complex<f64>> for i32x4

type Output = <i32x4 as NormalOutPromote<cplx64x1>>::Output

impl NormalOut<Complex<f64>> for i64x2

type Output = <i64x2 as NormalOutPromote<cplx64x1>>::Output

impl NormalOut<Complex<f64>> for isizex2

type Output = <isizex2 as NormalOutPromote<cplx64x1>>::Output

impl NormalOut<Complex<f64>> for u8x16

type Output = <u8x16 as NormalOutPromote<cplx64x1>>::Output

impl NormalOut<Complex<f64>> for u16x8

type Output = <u16x8 as NormalOutPromote<cplx64x1>>::Output

impl NormalOut<Complex<f64>> for u32x4

type Output = <u32x4 as NormalOutPromote<cplx64x1>>::Output

impl NormalOut<Complex<f64>> for u64x2

type Output = <u64x2 as NormalOutPromote<cplx64x1>>::Output

impl NormalOut<Complex<f64>> for usizex2

type Output = <usizex2 as NormalOutPromote<cplx64x1>>::Output