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 _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 _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]

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl NormalOut for bool

type Output = <bool as NormalOutPromote>::Output

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

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

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

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

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

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

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

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

impl NormalOut for f32

type Output = <f32 as NormalOutPromote>::Output

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

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

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

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

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

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

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

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

impl NormalOut for f64

type Output = <f64 as NormalOutPromote>::Output

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

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

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

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

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

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

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

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

impl NormalOut for i8

type Output = <i8 as NormalOutPromote>::Output

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

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

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

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

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

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

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

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

impl NormalOut for i16

type Output = <i16 as NormalOutPromote>::Output

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

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

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

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

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

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

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

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

impl NormalOut for i32

type Output = <i32 as NormalOutPromote>::Output

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

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

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

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

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

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

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

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

impl NormalOut for i64

type Output = <i64 as NormalOutPromote>::Output

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

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

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

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

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

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

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

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

impl NormalOut for isize

type Output = <isize as NormalOutPromote>::Output

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

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

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

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

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

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

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

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

impl NormalOut for u8

type Output = <u8 as NormalOutPromote>::Output

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

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

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

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

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

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

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

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

impl NormalOut for u16

type Output = <u16 as NormalOutPromote>::Output

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

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

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

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

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

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

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

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

impl NormalOut for u32

type Output = <u32 as NormalOutPromote>::Output

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

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

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

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

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

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

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

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

impl NormalOut for u64

type Output = <u64 as NormalOutPromote>::Output

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

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

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

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

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

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

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

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

impl NormalOut for usize

type Output = <usize as NormalOutPromote>::Output

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

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

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

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

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

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

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

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

impl NormalOut for bf16

type Output = <bf16 as NormalOutPromote>::Output

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

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

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

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

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

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

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

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

impl NormalOut for f16

type Output = <f16 as NormalOutPromote>::Output

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

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

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

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

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

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

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

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

impl NormalOut for Complex32

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

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

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

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

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

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

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

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

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

impl NormalOut for Complex64

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

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

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

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

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

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

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

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

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

impl NormalOut<bool> for f32

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

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

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

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

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

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

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

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

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

impl NormalOut<bool> for f64

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

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

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

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

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

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

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

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

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

impl NormalOut<bool> for i8

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

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

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

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

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

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

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

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

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

impl NormalOut<bool> for i16

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

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

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

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

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

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

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

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

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

impl NormalOut<bool> for i32

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

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

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

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

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

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

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

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

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

impl NormalOut<bool> for i64

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

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

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

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

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

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

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

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

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

impl NormalOut<bool> for isize

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

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

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

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

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

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

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

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

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

impl NormalOut<bool> for u8

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

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

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

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

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

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

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

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

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

impl NormalOut<bool> for u16

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

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

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

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

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

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

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

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

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

impl NormalOut<bool> for u32

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

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

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

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

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

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

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

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

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

impl NormalOut<bool> for u64

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

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

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

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

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

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

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

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

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

impl NormalOut<bool> for usize

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

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

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

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

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

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

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

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

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

impl NormalOut<bool> for bf16

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

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

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

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

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

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

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

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

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

impl NormalOut<bool> for f16

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

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

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

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

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

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

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

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

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

impl NormalOut<bool> for Complex32

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

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

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

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

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

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

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

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

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

impl NormalOut<bool> for Complex64

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

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

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

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

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

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

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

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

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

impl NormalOut<f32> for bool

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

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

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

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

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

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

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

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

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

impl NormalOut<f32> for f64

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

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

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

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

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

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

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

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

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

impl NormalOut<f32> for i8

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

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

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

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

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

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

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

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

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

impl NormalOut<f32> for i16

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

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

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

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

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

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

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

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

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

impl NormalOut<f32> for i32

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

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

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

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

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

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

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

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

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

impl NormalOut<f32> for i64

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

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

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

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

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

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

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

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

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

impl NormalOut<f32> for isize

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

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

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

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

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

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

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

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

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

impl NormalOut<f32> for u8

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

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

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

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

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

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

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

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

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

impl NormalOut<f32> for u16

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

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

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

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

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

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

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

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

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

impl NormalOut<f32> for u32

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

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

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

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

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

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

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

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

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

impl NormalOut<f32> for u64

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

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

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

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

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

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

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

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

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

impl NormalOut<f32> for usize

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

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

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

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

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

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

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

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

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

impl NormalOut<f32> for bf16

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

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

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

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

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

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

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

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

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

impl NormalOut<f32> for f16

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

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

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

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

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

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

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

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

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

impl NormalOut<f32> for Complex32

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

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

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

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

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

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

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

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

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

impl NormalOut<f32> for Complex64

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

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

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

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

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

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

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

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

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

impl NormalOut<f64> for bool

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

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

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

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

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

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

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

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

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

impl NormalOut<f64> for f32

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

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

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

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

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

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

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

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

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

impl NormalOut<f64> for i8

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

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

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

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

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

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

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

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

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

impl NormalOut<f64> for i16

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

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

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

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

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

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

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

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

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

impl NormalOut<f64> for i32

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

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

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

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

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

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

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

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

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

impl NormalOut<f64> for i64

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

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

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

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

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

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

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

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

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

impl NormalOut<f64> for isize

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

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

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

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

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

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

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

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

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

impl NormalOut<f64> for u8

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

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

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

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

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

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

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

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

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

impl NormalOut<f64> for u16

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

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

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

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

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

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

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

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

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

impl NormalOut<f64> for u32

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

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

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

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

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

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

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

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

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

impl NormalOut<f64> for u64

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

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

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

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

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

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

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

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

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

impl NormalOut<f64> for usize

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

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

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

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

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

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

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

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

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

impl NormalOut<f64> for bf16

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

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

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

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

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

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

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

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

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

impl NormalOut<f64> for f16

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

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

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

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

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

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

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

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

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

impl NormalOut<f64> for Complex32

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

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

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

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

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

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

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

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

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

impl NormalOut<f64> for Complex64

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

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

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

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

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

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

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

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

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

impl NormalOut<i8> for bool

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

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

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

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

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

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

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

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

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

impl NormalOut<i8> for f32

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

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

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

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

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

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

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

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

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

impl NormalOut<i8> for f64

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

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

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

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

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

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

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

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

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

impl NormalOut<i8> for i16

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

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

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

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

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

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

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

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

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

impl NormalOut<i8> for i32

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

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

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

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

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

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

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

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

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

impl NormalOut<i8> for i64

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

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

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

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

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

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

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

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

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

impl NormalOut<i8> for isize

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

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

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

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

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

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

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

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

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

impl NormalOut<i8> for u8

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

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

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

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

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

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

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

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

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

impl NormalOut<i8> for u16

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

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

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

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

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

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

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

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

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

impl NormalOut<i8> for u32

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

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

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

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

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

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

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

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

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

impl NormalOut<i8> for u64

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

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

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

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

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

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

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

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

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

impl NormalOut<i8> for usize

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

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

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

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

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

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

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

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

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

impl NormalOut<i8> for bf16

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

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

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

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

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

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

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

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

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

impl NormalOut<i8> for f16

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

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

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

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

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

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

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

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

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

impl NormalOut<i8> for Complex32

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

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

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

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

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

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

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

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

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

impl NormalOut<i8> for Complex64

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

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

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

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

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

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

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

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

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

impl NormalOut<i16> for bool

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

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

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

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

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

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

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

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

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

impl NormalOut<i16> for f32

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

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

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

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

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

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

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

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

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

impl NormalOut<i16> for f64

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

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

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

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

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

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

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

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

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

impl NormalOut<i16> for i8

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

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

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

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

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

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

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

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

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

impl NormalOut<i16> for i32

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

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

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

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

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

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

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

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

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

impl NormalOut<i16> for i64

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

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

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

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

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

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

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

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

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

impl NormalOut<i16> for isize

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

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

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

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

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

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

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

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

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

impl NormalOut<i16> for u8

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

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

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

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

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

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

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

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

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

impl NormalOut<i16> for u16

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

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

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

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

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

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

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

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

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

impl NormalOut<i16> for u32

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

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

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

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

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

fn _mul(self, rhs: i16) -> Self::Output

fn _rem(self, rhs: i16) -> Self::Output

fn _max(self, rhs: i16) -> Self::Output

fn _min(self, rhs: i16) -> Self::Output

impl NormalOut<i16> for u64

type Output = <u64 as NormalOutPromote<i16>>::Output

fn _clamp(self, min: i16, max: i16) -> Self::Output

fn _mul_add(self, a: i16, b: i16) -> Self::Output

fn _add(self, rhs: i16) -> Self::Output

fn _sub(self, rhs: i16) -> Self::Output

fn _mul(self, rhs: i16) -> Self::Output

fn _rem(self, rhs: i16) -> Self::Output

fn _max(self, rhs: i16) -> Self::Output

fn _min(self, rhs: i16) -> Self::Output

impl NormalOut<i16> for usize

type Output = <usize as NormalOutPromote<i16>>::Output

fn _clamp(self, min: i16, max: i16) -> Self::Output

fn _mul_add(self, a: i16, b: i16) -> Self::Output

fn _add(self, rhs: i16) -> Self::Output

fn _sub(self, rhs: i16) -> Self::Output

fn _mul(self, rhs: i16) -> Self::Output

fn _rem(self, rhs: i16) -> Self::Output

fn _max(self, rhs: i16) -> Self::Output

fn _min(self, rhs: i16) -> Self::Output

impl NormalOut<i16> for bf16

type Output = <bf16 as NormalOutPromote<i16>>::Output

fn _clamp(self, min: i16, max: i16) -> Self::Output

fn _mul_add(self, a: i16, b: i16) -> Self::Output

fn _add(self, rhs: i16) -> Self::Output

fn _sub(self, rhs: i16) -> Self::Output

fn _mul(self, rhs: i16) -> Self::Output

fn _rem(self, rhs: i16) -> Self::Output

fn _max(self, rhs: i16) -> Self::Output

fn _min(self, rhs: i16) -> Self::Output

impl NormalOut<i16> for f16

type Output = <f16 as NormalOutPromote<i16>>::Output

fn _clamp(self, min: i16, max: i16) -> Self::Output

fn _mul_add(self, a: i16, b: i16) -> Self::Output

fn _add(self, rhs: i16) -> Self::Output

fn _sub(self, rhs: i16) -> Self::Output

fn _mul(self, rhs: i16) -> Self::Output

fn _rem(self, rhs: i16) -> Self::Output

fn _max(self, rhs: i16) -> Self::Output

fn _min(self, rhs: i16) -> Self::Output

impl NormalOut<i16> for Complex32

type Output = <Complex<f32> as NormalOutPromote<i16>>::Output

fn _clamp(self, min: i16, max: i16) -> Self::Output

fn _mul_add(self, a: i16, b: i16) -> Self::Output

fn _add(self, rhs: i16) -> Self::Output

fn _sub(self, rhs: i16) -> Self::Output

fn _mul(self, rhs: i16) -> Self::Output

fn _rem(self, rhs: i16) -> Self::Output

fn _max(self, rhs: i16) -> Self::Output

fn _min(self, rhs: i16) -> Self::Output

impl NormalOut<i16> for Complex64

type Output = <Complex<f64> as NormalOutPromote<i16>>::Output

fn _clamp(self, min: i16, max: i16) -> Self::Output

fn _mul_add(self, a: i16, b: i16) -> Self::Output

fn _add(self, rhs: i16) -> Self::Output

fn _sub(self, rhs: i16) -> Self::Output

fn _mul(self, rhs: i16) -> Self::Output

fn _rem(self, rhs: i16) -> Self::Output

fn _max(self, rhs: i16) -> Self::Output

fn _min(self, rhs: i16) -> Self::Output

impl NormalOut<i32> for bool

type Output = <bool as NormalOutPromote<i32>>::Output

fn _clamp(self, min: i32, max: i32) -> Self::Output

fn _mul_add(self, a: i32, b: i32) -> Self::Output

fn _add(self, rhs: i32) -> Self::Output

fn _sub(self, rhs: i32) -> Self::Output

fn _mul(self, rhs: i32) -> Self::Output

fn _rem(self, rhs: i32) -> Self::Output

fn _max(self, rhs: i32) -> Self::Output

fn _min(self, rhs: i32) -> Self::Output

impl NormalOut<i32> for f32

type Output = <f32 as NormalOutPromote<i32>>::Output

fn _clamp(self, min: i32, max: i32) -> Self::Output

fn _mul_add(self, a: i32, b: i32) -> Self::Output

fn _add(self, rhs: i32) -> Self::Output

fn _sub(self, rhs: i32) -> Self::Output

fn _mul(self, rhs: i32) -> Self::Output

fn _rem(self, rhs: i32) -> Self::Output

fn _max(self, rhs: i32) -> Self::Output

fn _min(self, rhs: i32) -> Self::Output

impl NormalOut<i32> for f64

type Output = <f64 as NormalOutPromote<i32>>::Output

fn _clamp(self, min: i32, max: i32) -> Self::Output

fn _mul_add(self, a: i32, b: i32) -> Self::Output

fn _add(self, rhs: i32) -> Self::Output

fn _sub(self, rhs: i32) -> Self::Output

fn _mul(self, rhs: i32) -> Self::Output

fn _rem(self, rhs: i32) -> Self::Output

fn _max(self, rhs: i32) -> Self::Output

fn _min(self, rhs: i32) -> Self::Output

impl NormalOut<i32> for i8

type Output = <i8 as NormalOutPromote<i32>>::Output

fn _clamp(self, min: i32, max: i32) -> Self::Output

fn _mul_add(self, a: i32, b: i32) -> Self::Output

fn _add(self, rhs: i32) -> Self::Output

fn _sub(self, rhs: i32) -> Self::Output

fn _mul(self, rhs: i32) -> Self::Output

fn _rem(self, rhs: i32) -> Self::Output

fn _max(self, rhs: i32) -> Self::Output

fn _min(self, rhs: i32) -> Self::Output

impl NormalOut<i32> for i16

type Output = <i16 as NormalOutPromote<i32>>::Output

fn _clamp(self, min: i32, max: i32) -> Self::Output

fn _mul_add(self, a: i32, b: i32) -> Self::Output

fn _add(self, rhs: i32) -> Self::Output

fn _sub(self, rhs: i32) -> Self::Output

fn _mul(self, rhs: i32) -> Self::Output

fn _rem(self, rhs: i32) -> Self::Output

fn _max(self, rhs: i32) -> Self::Output

fn _min(self, rhs: i32) -> Self::Output

impl NormalOut<i32> for i64

type Output = <i64 as NormalOutPromote<i32>>::Output

fn _clamp(self, min: i32, max: i32) -> Self::Output

fn _mul_add(self, a: i32, b: i32) -> Self::Output

fn _add(self, rhs: i32) -> Self::Output

fn _sub(self, rhs: i32) -> Self::Output

fn _mul(self, rhs: i32) -> Self::Output

fn _rem(self, rhs: i32) -> Self::Output

fn _max(self, rhs: i32) -> Self::Output

fn _min(self, rhs: i32) -> Self::Output

impl NormalOut<i32> for isize

type Output = <isize as NormalOutPromote<i32>>::Output

fn _clamp(self, min: i32, max: i32) -> Self::Output

fn _mul_add(self, a: i32, b: i32) -> Self::Output

fn _add(self, rhs: i32) -> Self::Output

fn _sub(self, rhs: i32) -> Self::Output

fn _mul(self, rhs: i32) -> Self::Output

fn _rem(self, rhs: i32) -> Self::Output

fn _max(self, rhs: i32) -> Self::Output

fn _min(self, rhs: i32) -> Self::Output

impl NormalOut<i32> for u8

type Output = <u8 as NormalOutPromote<i32>>::Output

fn _clamp(self, min: i32, max: i32) -> Self::Output

fn _mul_add(self, a: i32, b: i32) -> Self::Output

fn _add(self, rhs: i32) -> Self::Output

fn _sub(self, rhs: i32) -> Self::Output

fn _mul(self, rhs: i32) -> Self::Output

fn _rem(self, rhs: i32) -> Self::Output

fn _max(self, rhs: i32) -> Self::Output

fn _min(self, rhs: i32) -> Self::Output

impl NormalOut<i32> for u16

type Output = <u16 as NormalOutPromote<i32>>::Output

fn _clamp(self, min: i32, max: i32) -> Self::Output

fn _mul_add(self, a: i32, b: i32) -> Self::Output

fn _add(self, rhs: i32) -> Self::Output

fn _sub(self, rhs: i32) -> Self::Output

fn _mul(self, rhs: i32) -> Self::Output

fn _rem(self, rhs: i32) -> Self::Output

fn _max(self, rhs: i32) -> Self::Output

fn _min(self, rhs: i32) -> Self::Output

impl NormalOut<i32> for u32

type Output = <u32 as NormalOutPromote<i32>>::Output

fn _clamp(self, min: i32, max: i32) -> Self::Output

fn _mul_add(self, a: i32, b: i32) -> Self::Output

fn _add(self, rhs: i32) -> Self::Output

fn _sub(self, rhs: i32) -> Self::Output

fn _mul(self, rhs: i32) -> Self::Output

fn _rem(self, rhs: i32) -> Self::Output

fn _max(self, rhs: i32) -> Self::Output

fn _min(self, rhs: i32) -> Self::Output

impl NormalOut<i32> for u64

type Output = <u64 as NormalOutPromote<i32>>::Output

fn _clamp(self, min: i32, max: i32) -> Self::Output

fn _mul_add(self, a: i32, b: i32) -> Self::Output

fn _add(self, rhs: i32) -> Self::Output

fn _sub(self, rhs: i32) -> Self::Output

fn _mul(self, rhs: i32) -> Self::Output

fn _rem(self, rhs: i32) -> Self::Output

fn _max(self, rhs: i32) -> Self::Output

fn _min(self, rhs: i32) -> Self::Output

impl NormalOut<i32> for usize

type Output = <usize as NormalOutPromote<i32>>::Output

fn _clamp(self, min: i32, max: i32) -> Self::Output

fn _mul_add(self, a: i32, b: i32) -> Self::Output

fn _add(self, rhs: i32) -> Self::Output

fn _sub(self, rhs: i32) -> Self::Output

fn _mul(self, rhs: i32) -> Self::Output

fn _rem(self, rhs: i32) -> Self::Output

fn _max(self, rhs: i32) -> Self::Output

fn _min(self, rhs: i32) -> Self::Output

impl NormalOut<i32> for bf16

type Output = <bf16 as NormalOutPromote<i32>>::Output

fn _clamp(self, min: i32, max: i32) -> Self::Output

fn _mul_add(self, a: i32, b: i32) -> Self::Output

fn _add(self, rhs: i32) -> Self::Output

fn _sub(self, rhs: i32) -> Self::Output

fn _mul(self, rhs: i32) -> Self::Output

fn _rem(self, rhs: i32) -> Self::Output

fn _max(self, rhs: i32) -> Self::Output

fn _min(self, rhs: i32) -> Self::Output

impl NormalOut<i32> for f16

type Output = <f16 as NormalOutPromote<i32>>::Output

fn _clamp(self, min: i32, max: i32) -> Self::Output

fn _mul_add(self, a: i32, b: i32) -> Self::Output

fn _add(self, rhs: i32) -> Self::Output

fn _sub(self, rhs: i32) -> Self::Output

fn _mul(self, rhs: i32) -> Self::Output

fn _rem(self, rhs: i32) -> Self::Output

fn _max(self, rhs: i32) -> Self::Output

fn _min(self, rhs: i32) -> Self::Output

impl NormalOut<i32> for Complex32

type Output = <Complex<f32> as NormalOutPromote<i32>>::Output

fn _clamp(self, min: i32, max: i32) -> Self::Output

fn _mul_add(self, a: i32, b: i32) -> Self::Output

fn _add(self, rhs: i32) -> Self::Output

fn _sub(self, rhs: i32) -> Self::Output

fn _mul(self, rhs: i32) -> Self::Output

fn _rem(self, rhs: i32) -> Self::Output

fn _max(self, rhs: i32) -> Self::Output

fn _min(self, rhs: i32) -> Self::Output

impl NormalOut<i32> for Complex64

type Output = <Complex<f64> as NormalOutPromote<i32>>::Output

fn _clamp(self, min: i32, max: i32) -> Self::Output

fn _mul_add(self, a: i32, b: i32) -> Self::Output

fn _add(self, rhs: i32) -> Self::Output

fn _sub(self, rhs: i32) -> Self::Output

fn _mul(self, rhs: i32) -> Self::Output

fn _rem(self, rhs: i32) -> Self::Output

fn _max(self, rhs: i32) -> Self::Output

fn _min(self, rhs: i32) -> Self::Output

impl NormalOut<i64> for bool

type Output = <bool as NormalOutPromote<i64>>::Output

fn _clamp(self, min: i64, max: i64) -> Self::Output

fn _mul_add(self, a: i64, b: i64) -> Self::Output

fn _add(self, rhs: i64) -> Self::Output

fn _sub(self, rhs: i64) -> Self::Output

fn _mul(self, rhs: i64) -> Self::Output

fn _rem(self, rhs: i64) -> Self::Output

fn _max(self, rhs: i64) -> Self::Output

fn _min(self, rhs: i64) -> Self::Output

impl NormalOut<i64> for f32

type Output = <f32 as NormalOutPromote<i64>>::Output

fn _clamp(self, min: i64, max: i64) -> Self::Output

fn _mul_add(self, a: i64, b: i64) -> Self::Output

fn _add(self, rhs: i64) -> Self::Output

fn _sub(self, rhs: i64) -> Self::Output

fn _mul(self, rhs: i64) -> Self::Output

fn _rem(self, rhs: i64) -> Self::Output

fn _max(self, rhs: i64) -> Self::Output

fn _min(self, rhs: i64) -> Self::Output

impl NormalOut<i64> for f64

type Output = <f64 as NormalOutPromote<i64>>::Output

fn _clamp(self, min: i64, max: i64) -> Self::Output

fn _mul_add(self, a: i64, b: i64) -> Self::Output

fn _add(self, rhs: i64) -> Self::Output

fn _sub(self, rhs: i64) -> Self::Output

fn _mul(self, rhs: i64) -> Self::Output

fn _rem(self, rhs: i64) -> Self::Output

fn _max(self, rhs: i64) -> Self::Output

fn _min(self, rhs: i64) -> Self::Output

impl NormalOut<i64> for i8

type Output = <i8 as NormalOutPromote<i64>>::Output

fn _clamp(self, min: i64, max: i64) -> Self::Output

fn _mul_add(self, a: i64, b: i64) -> Self::Output

fn _add(self, rhs: i64) -> Self::Output

fn _sub(self, rhs: i64) -> Self::Output

fn _mul(self, rhs: i64) -> Self::Output

fn _rem(self, rhs: i64) -> Self::Output

fn _max(self, rhs: i64) -> Self::Output

fn _min(self, rhs: i64) -> Self::Output

impl NormalOut<i64> for i16

type Output = <i16 as NormalOutPromote<i64>>::Output

fn _clamp(self, min: i64, max: i64) -> Self::Output

fn _mul_add(self, a: i64, b: i64) -> Self::Output

fn _add(self, rhs: i64) -> Self::Output

fn _sub(self, rhs: i64) -> Self::Output

fn _mul(self, rhs: i64) -> Self::Output

fn _rem(self, rhs: i64) -> Self::Output

fn _max(self, rhs: i64) -> Self::Output

fn _min(self, rhs: i64) -> Self::Output

impl NormalOut<i64> for i32

type Output = <i32 as NormalOutPromote<i64>>::Output

fn _clamp(self, min: i64, max: i64) -> Self::Output

fn _mul_add(self, a: i64, b: i64) -> Self::Output

fn _add(self, rhs: i64) -> Self::Output

fn _sub(self, rhs: i64) -> Self::Output

fn _mul(self, rhs: i64) -> Self::Output

fn _rem(self, rhs: i64) -> Self::Output

fn _max(self, rhs: i64) -> Self::Output

fn _min(self, rhs: i64) -> Self::Output

impl NormalOut<i64> for isize

type Output = <isize as NormalOutPromote<i64>>::Output

fn _clamp(self, min: i64, max: i64) -> Self::Output

fn _mul_add(self, a: i64, b: i64) -> Self::Output

fn _add(self, rhs: i64) -> Self::Output

fn _sub(self, rhs: i64) -> Self::Output

fn _mul(self, rhs: i64) -> Self::Output

fn _rem(self, rhs: i64) -> Self::Output

fn _max(self, rhs: i64) -> Self::Output

fn _min(self, rhs: i64) -> Self::Output

impl NormalOut<i64> for u8

type Output = <u8 as NormalOutPromote<i64>>::Output

fn _clamp(self, min: i64, max: i64) -> Self::Output

fn _mul_add(self, a: i64, b: i64) -> Self::Output

fn _add(self, rhs: i64) -> Self::Output

fn _sub(self, rhs: i64) -> Self::Output

fn _mul(self, rhs: i64) -> Self::Output

fn _rem(self, rhs: i64) -> Self::Output

fn _max(self, rhs: i64) -> Self::Output

fn _min(self, rhs: i64) -> Self::Output

impl NormalOut<i64> for u16

type Output = <u16 as NormalOutPromote<i64>>::Output

fn _clamp(self, min: i64, max: i64) -> Self::Output

fn _mul_add(self, a: i64, b: i64) -> Self::Output

fn _add(self, rhs: i64) -> Self::Output

fn _sub(self, rhs: i64) -> Self::Output

fn _mul(self, rhs: i64) -> Self::Output

fn _rem(self, rhs: i64) -> Self::Output

fn _max(self, rhs: i64) -> Self::Output

fn _min(self, rhs: i64) -> Self::Output

impl NormalOut<i64> for u32

type Output = <u32 as NormalOutPromote<i64>>::Output

fn _clamp(self, min: i64, max: i64) -> Self::Output

fn _mul_add(self, a: i64, b: i64) -> Self::Output

fn _add(self, rhs: i64) -> Self::Output

fn _sub(self, rhs: i64) -> Self::Output

fn _mul(self, rhs: i64) -> Self::Output

fn _rem(self, rhs: i64) -> Self::Output

fn _max(self, rhs: i64) -> Self::Output

fn _min(self, rhs: i64) -> Self::Output

impl NormalOut<i64> for u64

type Output = <u64 as NormalOutPromote<i64>>::Output

fn _clamp(self, min: i64, max: i64) -> Self::Output

fn _mul_add(self, a: i64, b: i64) -> Self::Output

fn _add(self, rhs: i64) -> Self::Output

fn _sub(self, rhs: i64) -> Self::Output

fn _mul(self, rhs: i64) -> Self::Output

fn _rem(self, rhs: i64) -> Self::Output

fn _max(self, rhs: i64) -> Self::Output

fn _min(self, rhs: i64) -> Self::Output

impl NormalOut<i64> for usize

type Output = <usize as NormalOutPromote<i64>>::Output

fn _clamp(self, min: i64, max: i64) -> Self::Output

fn _mul_add(self, a: i64, b: i64) -> Self::Output

fn _add(self, rhs: i64) -> Self::Output

fn _sub(self, rhs: i64) -> Self::Output

fn _mul(self, rhs: i64) -> Self::Output

fn _rem(self, rhs: i64) -> Self::Output

fn _max(self, rhs: i64) -> Self::Output

fn _min(self, rhs: i64) -> Self::Output

impl NormalOut<i64> for bf16

type Output = <bf16 as NormalOutPromote<i64>>::Output

fn _clamp(self, min: i64, max: i64) -> Self::Output

fn _mul_add(self, a: i64, b: i64) -> Self::Output

fn _add(self, rhs: i64) -> Self::Output

fn _sub(self, rhs: i64) -> Self::Output

fn _mul(self, rhs: i64) -> Self::Output

fn _rem(self, rhs: i64) -> Self::Output

fn _max(self, rhs: i64) -> Self::Output

fn _min(self, rhs: i64) -> Self::Output

impl NormalOut<i64> for f16

type Output = <f16 as NormalOutPromote<i64>>::Output

fn _clamp(self, min: i64, max: i64) -> Self::Output

fn _mul_add(self, a: i64, b: i64) -> Self::Output

fn _add(self, rhs: i64) -> Self::Output

fn _sub(self, rhs: i64) -> Self::Output

fn _mul(self, rhs: i64) -> Self::Output

fn _rem(self, rhs: i64) -> Self::Output

fn _max(self, rhs: i64) -> Self::Output

fn _min(self, rhs: i64) -> Self::Output

impl NormalOut<i64> for Complex32

type Output = <Complex<f32> as NormalOutPromote<i64>>::Output

fn _clamp(self, min: i64, max: i64) -> Self::Output

fn _mul_add(self, a: i64, b: i64) -> Self::Output

fn _add(self, rhs: i64) -> Self::Output

fn _sub(self, rhs: i64) -> Self::Output

fn _mul(self, rhs: i64) -> Self::Output

fn _rem(self, rhs: i64) -> Self::Output

fn _max(self, rhs: i64) -> Self::Output

fn _min(self, rhs: i64) -> Self::Output

impl NormalOut<i64> for Complex64

type Output = <Complex<f64> as NormalOutPromote<i64>>::Output

fn _clamp(self, min: i64, max: i64) -> Self::Output

fn _mul_add(self, a: i64, b: i64) -> Self::Output

fn _add(self, rhs: i64) -> Self::Output

fn _sub(self, rhs: i64) -> Self::Output

fn _mul(self, rhs: i64) -> Self::Output

fn _rem(self, rhs: i64) -> Self::Output

fn _max(self, rhs: i64) -> Self::Output

fn _min(self, rhs: i64) -> Self::Output

impl NormalOut<isize> for bool

type Output = <bool as NormalOutPromote<isize>>::Output

fn _clamp(self, min: isize, max: isize) -> Self::Output

fn _mul_add(self, a: isize, b: isize) -> Self::Output

fn _add(self, rhs: isize) -> Self::Output

fn _sub(self, rhs: isize) -> Self::Output

fn _mul(self, rhs: isize) -> Self::Output

fn _rem(self, rhs: isize) -> Self::Output

fn _max(self, rhs: isize) -> Self::Output

fn _min(self, rhs: isize) -> Self::Output

impl NormalOut<isize> for f32

type Output = <f32 as NormalOutPromote<isize>>::Output

fn _clamp(self, min: isize, max: isize) -> Self::Output

fn _mul_add(self, a: isize, b: isize) -> Self::Output

fn _add(self, rhs: isize) -> Self::Output

fn _sub(self, rhs: isize) -> Self::Output

fn _mul(self, rhs: isize) -> Self::Output

fn _rem(self, rhs: isize) -> Self::Output

fn _max(self, rhs: isize) -> Self::Output

fn _min(self, rhs: isize) -> Self::Output

impl NormalOut<isize> for f64

type Output = <f64 as NormalOutPromote<isize>>::Output

fn _clamp(self, min: isize, max: isize) -> Self::Output

fn _mul_add(self, a: isize, b: isize) -> Self::Output

fn _add(self, rhs: isize) -> Self::Output

fn _sub(self, rhs: isize) -> Self::Output

fn _mul(self, rhs: isize) -> Self::Output

fn _rem(self, rhs: isize) -> Self::Output

fn _max(self, rhs: isize) -> Self::Output

fn _min(self, rhs: isize) -> Self::Output

impl NormalOut<isize> for i8

type Output = <i8 as NormalOutPromote<isize>>::Output

fn _clamp(self, min: isize, max: isize) -> Self::Output

fn _mul_add(self, a: isize, b: isize) -> Self::Output

fn _add(self, rhs: isize) -> Self::Output

fn _sub(self, rhs: isize) -> Self::Output

fn _mul(self, rhs: isize) -> Self::Output

fn _rem(self, rhs: isize) -> Self::Output

fn _max(self, rhs: isize) -> Self::Output

fn _min(self, rhs: isize) -> Self::Output

impl NormalOut<isize> for i16

type Output = <i16 as NormalOutPromote<isize>>::Output

fn _clamp(self, min: isize, max: isize) -> Self::Output

fn _mul_add(self, a: isize, b: isize) -> Self::Output

fn _add(self, rhs: isize) -> Self::Output

fn _sub(self, rhs: isize) -> Self::Output

fn _mul(self, rhs: isize) -> Self::Output

fn _rem(self, rhs: isize) -> Self::Output

fn _max(self, rhs: isize) -> Self::Output

fn _min(self, rhs: isize) -> Self::Output

impl NormalOut<isize> for i32

type Output = <i32 as NormalOutPromote<isize>>::Output

fn _clamp(self, min: isize, max: isize) -> Self::Output

fn _mul_add(self, a: isize, b: isize) -> Self::Output

fn _add(self, rhs: isize) -> Self::Output

fn _sub(self, rhs: isize) -> Self::Output

fn _mul(self, rhs: isize) -> Self::Output

fn _rem(self, rhs: isize) -> Self::Output

fn _max(self, rhs: isize) -> Self::Output

fn _min(self, rhs: isize) -> Self::Output

impl NormalOut<isize> for i64

type Output = <i64 as NormalOutPromote<isize>>::Output

fn _clamp(self, min: isize, max: isize) -> Self::Output

fn _mul_add(self, a: isize, b: isize) -> Self::Output

fn _add(self, rhs: isize) -> Self::Output

fn _sub(self, rhs: isize) -> Self::Output

fn _mul(self, rhs: isize) -> Self::Output

fn _rem(self, rhs: isize) -> Self::Output

fn _max(self, rhs: isize) -> Self::Output

fn _min(self, rhs: isize) -> Self::Output

impl NormalOut<isize> for u8

type Output = <u8 as NormalOutPromote<isize>>::Output

fn _clamp(self, min: isize, max: isize) -> Self::Output

fn _mul_add(self, a: isize, b: isize) -> Self::Output

fn _add(self, rhs: isize) -> Self::Output

fn _sub(self, rhs: isize) -> Self::Output

fn _mul(self, rhs: isize) -> Self::Output

fn _rem(self, rhs: isize) -> Self::Output

fn _max(self, rhs: isize) -> Self::Output

fn _min(self, rhs: isize) -> Self::Output

impl NormalOut<isize> for u16

type Output = <u16 as NormalOutPromote<isize>>::Output

fn _clamp(self, min: isize, max: isize) -> Self::Output

fn _mul_add(self, a: isize, b: isize) -> Self::Output

fn _add(self, rhs: isize) -> Self::Output

fn _sub(self, rhs: isize) -> Self::Output

fn _mul(self, rhs: isize) -> Self::Output

fn _rem(self, rhs: isize) -> Self::Output

fn _max(self, rhs: isize) -> Self::Output

fn _min(self, rhs: isize) -> Self::Output

impl NormalOut<isize> for u32

type Output = <u32 as NormalOutPromote<isize>>::Output

fn _clamp(self, min: isize, max: isize) -> Self::Output

fn _mul_add(self, a: isize, b: isize) -> Self::Output

fn _add(self, rhs: isize) -> Self::Output

fn _sub(self, rhs: isize) -> Self::Output

fn _mul(self, rhs: isize) -> Self::Output

fn _rem(self, rhs: isize) -> Self::Output

fn _max(self, rhs: isize) -> Self::Output

fn _min(self, rhs: isize) -> Self::Output

impl NormalOut<isize> for u64

type Output = <u64 as NormalOutPromote<isize>>::Output

fn _clamp(self, min: isize, max: isize) -> Self::Output

fn _mul_add(self, a: isize, b: isize) -> Self::Output

fn _add(self, rhs: isize) -> Self::Output

fn _sub(self, rhs: isize) -> Self::Output

fn _mul(self, rhs: isize) -> Self::Output

fn _rem(self, rhs: isize) -> Self::Output

fn _max(self, rhs: isize) -> Self::Output

fn _min(self, rhs: isize) -> Self::Output

impl NormalOut<isize> for usize

type Output = <usize as NormalOutPromote<isize>>::Output

fn _clamp(self, min: isize, max: isize) -> Self::Output

fn _mul_add(self, a: isize, b: isize) -> Self::Output

fn _add(self, rhs: isize) -> Self::Output

fn _sub(self, rhs: isize) -> Self::Output

fn _mul(self, rhs: isize) -> Self::Output

fn _rem(self, rhs: isize) -> Self::Output

fn _max(self, rhs: isize) -> Self::Output

fn _min(self, rhs: isize) -> Self::Output

impl NormalOut<isize> for bf16

type Output = <bf16 as NormalOutPromote<isize>>::Output

fn _clamp(self, min: isize, max: isize) -> Self::Output

fn _mul_add(self, a: isize, b: isize) -> Self::Output

fn _add(self, rhs: isize) -> Self::Output

fn _sub(self, rhs: isize) -> Self::Output

fn _mul(self, rhs: isize) -> Self::Output

fn _rem(self, rhs: isize) -> Self::Output

fn _max(self, rhs: isize) -> Self::Output

fn _min(self, rhs: isize) -> Self::Output

impl NormalOut<isize> for f16

type Output = <f16 as NormalOutPromote<isize>>::Output

fn _clamp(self, min: isize, max: isize) -> Self::Output

fn _mul_add(self, a: isize, b: isize) -> Self::Output

fn _add(self, rhs: isize) -> Self::Output

fn _sub(self, rhs: isize) -> Self::Output

fn _mul(self, rhs: isize) -> Self::Output

fn _rem(self, rhs: isize) -> Self::Output

fn _max(self, rhs: isize) -> Self::Output

fn _min(self, rhs: isize) -> Self::Output

impl NormalOut<isize> for Complex32

type Output = <Complex<f32> as NormalOutPromote<isize>>::Output

fn _clamp(self, min: isize, max: isize) -> Self::Output

fn _mul_add(self, a: isize, b: isize) -> Self::Output

fn _add(self, rhs: isize) -> Self::Output

fn _sub(self, rhs: isize) -> Self::Output

fn _mul(self, rhs: isize) -> Self::Output

fn _rem(self, rhs: isize) -> Self::Output

fn _max(self, rhs: isize) -> Self::Output

fn _min(self, rhs: isize) -> Self::Output

impl NormalOut<isize> for Complex64

type Output = <Complex<f64> as NormalOutPromote<isize>>::Output

fn _clamp(self, min: isize, max: isize) -> Self::Output

fn _mul_add(self, a: isize, b: isize) -> Self::Output

fn _add(self, rhs: isize) -> Self::Output

fn _sub(self, rhs: isize) -> Self::Output

fn _mul(self, rhs: isize) -> Self::Output

fn _rem(self, rhs: isize) -> Self::Output

fn _max(self, rhs: isize) -> Self::Output

fn _min(self, rhs: isize) -> Self::Output

impl NormalOut<u8> for bool

type Output = <bool as NormalOutPromote<u8>>::Output

fn _clamp(self, min: u8, max: u8) -> Self::Output

fn _mul_add(self, a: u8, b: u8) -> Self::Output

fn _add(self, rhs: u8) -> Self::Output

fn _sub(self, rhs: u8) -> Self::Output

fn _mul(self, rhs: u8) -> Self::Output

fn _rem(self, rhs: u8) -> Self::Output

fn _max(self, rhs: u8) -> Self::Output

fn _min(self, rhs: u8) -> Self::Output

impl NormalOut<u8> for f32

type Output = <f32 as NormalOutPromote<u8>>::Output

fn _clamp(self, min: u8, max: u8) -> Self::Output

fn _mul_add(self, a: u8, b: u8) -> Self::Output

fn _add(self, rhs: u8) -> Self::Output

fn _sub(self, rhs: u8) -> Self::Output

fn _mul(self, rhs: u8) -> Self::Output

fn _rem(self, rhs: u8) -> Self::Output

fn _max(self, rhs: u8) -> Self::Output

fn _min(self, rhs: u8) -> Self::Output

impl NormalOut<u8> for f64

type Output = <f64 as NormalOutPromote<u8>>::Output

fn _clamp(self, min: u8, max: u8) -> Self::Output

fn _mul_add(self, a: u8, b: u8) -> Self::Output

fn _add(self, rhs: u8) -> Self::Output

fn _sub(self, rhs: u8) -> Self::Output

fn _mul(self, rhs: u8) -> Self::Output

fn _rem(self, rhs: u8) -> Self::Output

fn _max(self, rhs: u8) -> Self::Output

fn _min(self, rhs: u8) -> Self::Output

impl NormalOut<u8> for i8

type Output = <i8 as NormalOutPromote<u8>>::Output

fn _clamp(self, min: u8, max: u8) -> Self::Output

fn _mul_add(self, a: u8, b: u8) -> Self::Output

fn _add(self, rhs: u8) -> Self::Output

fn _sub(self, rhs: u8) -> Self::Output

fn _mul(self, rhs: u8) -> Self::Output

fn _rem(self, rhs: u8) -> Self::Output

fn _max(self, rhs: u8) -> Self::Output

fn _min(self, rhs: u8) -> Self::Output

impl NormalOut<u8> for i16

type Output = <i16 as NormalOutPromote<u8>>::Output

fn _clamp(self, min: u8, max: u8) -> Self::Output

fn _mul_add(self, a: u8, b: u8) -> Self::Output

fn _add(self, rhs: u8) -> Self::Output

fn _sub(self, rhs: u8) -> Self::Output

fn _mul(self, rhs: u8) -> Self::Output

fn _rem(self, rhs: u8) -> Self::Output

fn _max(self, rhs: u8) -> Self::Output

fn _min(self, rhs: u8) -> Self::Output

impl NormalOut<u8> for i32

type Output = <i32 as NormalOutPromote<u8>>::Output

fn _clamp(self, min: u8, max: u8) -> Self::Output

fn _mul_add(self, a: u8, b: u8) -> Self::Output

fn _add(self, rhs: u8) -> Self::Output

fn _sub(self, rhs: u8) -> Self::Output

fn _mul(self, rhs: u8) -> Self::Output

fn _rem(self, rhs: u8) -> Self::Output

fn _max(self, rhs: u8) -> Self::Output

fn _min(self, rhs: u8) -> Self::Output

impl NormalOut<u8> for i64

type Output = <i64 as NormalOutPromote<u8>>::Output

fn _clamp(self, min: u8, max: u8) -> Self::Output

fn _mul_add(self, a: u8, b: u8) -> Self::Output

fn _add(self, rhs: u8) -> Self::Output

fn _sub(self, rhs: u8) -> Self::Output

fn _mul(self, rhs: u8) -> Self::Output

fn _rem(self, rhs: u8) -> Self::Output

fn _max(self, rhs: u8) -> Self::Output

fn _min(self, rhs: u8) -> Self::Output

impl NormalOut<u8> for isize

type Output = <isize as NormalOutPromote<u8>>::Output

fn _clamp(self, min: u8, max: u8) -> Self::Output

fn _mul_add(self, a: u8, b: u8) -> Self::Output

fn _add(self, rhs: u8) -> Self::Output

fn _sub(self, rhs: u8) -> Self::Output

fn _mul(self, rhs: u8) -> Self::Output

fn _rem(self, rhs: u8) -> Self::Output

fn _max(self, rhs: u8) -> Self::Output

fn _min(self, rhs: u8) -> Self::Output

impl NormalOut<u8> for u16

type Output = <u16 as NormalOutPromote<u8>>::Output

fn _clamp(self, min: u8, max: u8) -> Self::Output

fn _mul_add(self, a: u8, b: u8) -> Self::Output

fn _add(self, rhs: u8) -> Self::Output

fn _sub(self, rhs: u8) -> Self::Output

fn _mul(self, rhs: u8) -> Self::Output

fn _rem(self, rhs: u8) -> Self::Output

fn _max(self, rhs: u8) -> Self::Output

fn _min(self, rhs: u8) -> Self::Output

impl NormalOut<u8> for u32

type Output = <u32 as NormalOutPromote<u8>>::Output

fn _clamp(self, min: u8, max: u8) -> Self::Output

fn _mul_add(self, a: u8, b: u8) -> Self::Output

fn _add(self, rhs: u8) -> Self::Output

fn _sub(self, rhs: u8) -> Self::Output

fn _mul(self, rhs: u8) -> Self::Output

fn _rem(self, rhs: u8) -> Self::Output

fn _max(self, rhs: u8) -> Self::Output

fn _min(self, rhs: u8) -> Self::Output

impl NormalOut<u8> for u64

type Output = <u64 as NormalOutPromote<u8>>::Output

fn _clamp(self, min: u8, max: u8) -> Self::Output

fn _mul_add(self, a: u8, b: u8) -> Self::Output

fn _add(self, rhs: u8) -> Self::Output

fn _sub(self, rhs: u8) -> Self::Output

fn _mul(self, rhs: u8) -> Self::Output

fn _rem(self, rhs: u8) -> Self::Output

fn _max(self, rhs: u8) -> Self::Output

fn _min(self, rhs: u8) -> Self::Output

impl NormalOut<u8> for usize

type Output = <usize as NormalOutPromote<u8>>::Output

fn _clamp(self, min: u8, max: u8) -> Self::Output

fn _mul_add(self, a: u8, b: u8) -> Self::Output

fn _add(self, rhs: u8) -> Self::Output

fn _sub(self, rhs: u8) -> Self::Output

fn _mul(self, rhs: u8) -> Self::Output

fn _rem(self, rhs: u8) -> Self::Output

fn _max(self, rhs: u8) -> Self::Output

fn _min(self, rhs: u8) -> Self::Output

impl NormalOut<u8> for bf16

type Output = <bf16 as NormalOutPromote<u8>>::Output

fn _clamp(self, min: u8, max: u8) -> Self::Output

fn _mul_add(self, a: u8, b: u8) -> Self::Output

fn _add(self, rhs: u8) -> Self::Output

fn _sub(self, rhs: u8) -> Self::Output

fn _mul(self, rhs: u8) -> Self::Output

fn _rem(self, rhs: u8) -> Self::Output

fn _max(self, rhs: u8) -> Self::Output

fn _min(self, rhs: u8) -> Self::Output

impl NormalOut<u8> for f16

type Output = <f16 as NormalOutPromote<u8>>::Output

fn _clamp(self, min: u8, max: u8) -> Self::Output

fn _mul_add(self, a: u8, b: u8) -> Self::Output

fn _add(self, rhs: u8) -> Self::Output

fn _sub(self, rhs: u8) -> Self::Output

fn _mul(self, rhs: u8) -> Self::Output

fn _rem(self, rhs: u8) -> Self::Output

fn _max(self, rhs: u8) -> Self::Output

fn _min(self, rhs: u8) -> Self::Output

impl NormalOut<u8> for Complex32

type Output = <Complex<f32> as NormalOutPromote<u8>>::Output

fn _clamp(self, min: u8, max: u8) -> Self::Output

fn _mul_add(self, a: u8, b: u8) -> Self::Output

fn _add(self, rhs: u8) -> Self::Output

fn _sub(self, rhs: u8) -> Self::Output

fn _mul(self, rhs: u8) -> Self::Output

fn _rem(self, rhs: u8) -> Self::Output

fn _max(self, rhs: u8) -> Self::Output

fn _min(self, rhs: u8) -> Self::Output

impl NormalOut<u8> for Complex64

type Output = <Complex<f64> as NormalOutPromote<u8>>::Output

fn _clamp(self, min: u8, max: u8) -> Self::Output

fn _mul_add(self, a: u8, b: u8) -> Self::Output

fn _add(self, rhs: u8) -> Self::Output

fn _sub(self, rhs: u8) -> Self::Output

fn _mul(self, rhs: u8) -> Self::Output

fn _rem(self, rhs: u8) -> Self::Output

fn _max(self, rhs: u8) -> Self::Output

fn _min(self, rhs: u8) -> Self::Output

impl NormalOut<u16> for bool

type Output = <bool as NormalOutPromote<u16>>::Output

fn _clamp(self, min: u16, max: u16) -> Self::Output

fn _mul_add(self, a: u16, b: u16) -> Self::Output

fn _add(self, rhs: u16) -> Self::Output

fn _sub(self, rhs: u16) -> Self::Output

fn _mul(self, rhs: u16) -> Self::Output

fn _rem(self, rhs: u16) -> Self::Output

fn _max(self, rhs: u16) -> Self::Output

fn _min(self, rhs: u16) -> Self::Output

impl NormalOut<u16> for f32

type Output = <f32 as NormalOutPromote<u16>>::Output

fn _clamp(self, min: u16, max: u16) -> Self::Output

fn _mul_add(self, a: u16, b: u16) -> Self::Output

fn _add(self, rhs: u16) -> Self::Output

fn _sub(self, rhs: u16) -> Self::Output

fn _mul(self, rhs: u16) -> Self::Output

fn _rem(self, rhs: u16) -> Self::Output

fn _max(self, rhs: u16) -> Self::Output

fn _min(self, rhs: u16) -> Self::Output

impl NormalOut<u16> for f64

type Output = <f64 as NormalOutPromote<u16>>::Output

fn _clamp(self, min: u16, max: u16) -> Self::Output

fn _mul_add(self, a: u16, b: u16) -> Self::Output

fn _add(self, rhs: u16) -> Self::Output

fn _sub(self, rhs: u16) -> Self::Output

fn _mul(self, rhs: u16) -> Self::Output

fn _rem(self, rhs: u16) -> Self::Output

fn _max(self, rhs: u16) -> Self::Output

fn _min(self, rhs: u16) -> Self::Output

impl NormalOut<u16> for i8

type Output = <i8 as NormalOutPromote<u16>>::Output

fn _clamp(self, min: u16, max: u16) -> Self::Output

fn _mul_add(self, a: u16, b: u16) -> Self::Output

fn _add(self, rhs: u16) -> Self::Output

fn _sub(self, rhs: u16) -> Self::Output

fn _mul(self, rhs: u16) -> Self::Output

fn _rem(self, rhs: u16) -> Self::Output

fn _max(self, rhs: u16) -> Self::Output

fn _min(self, rhs: u16) -> Self::Output

impl NormalOut<u16> for i16

type Output = <i16 as NormalOutPromote<u16>>::Output

fn _clamp(self, min: u16, max: u16) -> Self::Output

fn _mul_add(self, a: u16, b: u16) -> Self::Output

fn _add(self, rhs: u16) -> Self::Output

fn _sub(self, rhs: u16) -> Self::Output

fn _mul(self, rhs: u16) -> Self::Output

fn _rem(self, rhs: u16) -> Self::Output

fn _max(self, rhs: u16) -> Self::Output

fn _min(self, rhs: u16) -> Self::Output

impl NormalOut<u16> for i32

type Output = <i32 as NormalOutPromote<u16>>::Output

fn _clamp(self, min: u16, max: u16) -> Self::Output

fn _mul_add(self, a: u16, b: u16) -> Self::Output

fn _add(self, rhs: u16) -> Self::Output

fn _sub(self, rhs: u16) -> Self::Output

fn _mul(self, rhs: u16) -> Self::Output

fn _rem(self, rhs: u16) -> Self::Output

fn _max(self, rhs: u16) -> Self::Output

fn _min(self, rhs: u16) -> Self::Output

impl NormalOut<u16> for i64

type Output = <i64 as NormalOutPromote<u16>>::Output

fn _clamp(self, min: u16, max: u16) -> Self::Output

fn _mul_add(self, a: u16, b: u16) -> Self::Output

fn _add(self, rhs: u16) -> Self::Output

fn _sub(self, rhs: u16) -> Self::Output

fn _mul(self, rhs: u16) -> Self::Output

fn _rem(self, rhs: u16) -> Self::Output

fn _max(self, rhs: u16) -> Self::Output

fn _min(self, rhs: u16) -> Self::Output

impl NormalOut<u16> for isize

type Output = <isize as NormalOutPromote<u16>>::Output

fn _clamp(self, min: u16, max: u16) -> Self::Output

fn _mul_add(self, a: u16, b: u16) -> Self::Output

fn _add(self, rhs: u16) -> Self::Output

fn _sub(self, rhs: u16) -> Self::Output

fn _mul(self, rhs: u16) -> Self::Output

fn _rem(self, rhs: u16) -> Self::Output

fn _max(self, rhs: u16) -> Self::Output

fn _min(self, rhs: u16) -> Self::Output

impl NormalOut<u16> for u8

type Output = <u8 as NormalOutPromote<u16>>::Output

fn _clamp(self, min: u16, max: u16) -> Self::Output

fn _mul_add(self, a: u16, b: u16) -> Self::Output

fn _add(self, rhs: u16) -> Self::Output

fn _sub(self, rhs: u16) -> Self::Output

fn _mul(self, rhs: u16) -> Self::Output

fn _rem(self, rhs: u16) -> Self::Output

fn _max(self, rhs: u16) -> Self::Output

fn _min(self, rhs: u16) -> Self::Output

impl NormalOut<u16> for u32

type Output = <u32 as NormalOutPromote<u16>>::Output

fn _clamp(self, min: u16, max: u16) -> Self::Output

fn _mul_add(self, a: u16, b: u16) -> Self::Output

fn _add(self, rhs: u16) -> Self::Output

fn _sub(self, rhs: u16) -> Self::Output

fn _mul(self, rhs: u16) -> Self::Output

fn _rem(self, rhs: u16) -> Self::Output

fn _max(self, rhs: u16) -> Self::Output

fn _min(self, rhs: u16) -> Self::Output

impl NormalOut<u16> for u64

type Output = <u64 as NormalOutPromote<u16>>::Output

fn _clamp(self, min: u16, max: u16) -> Self::Output

fn _mul_add(self, a: u16, b: u16) -> Self::Output

fn _add(self, rhs: u16) -> Self::Output

fn _sub(self, rhs: u16) -> Self::Output

fn _mul(self, rhs: u16) -> Self::Output

fn _rem(self, rhs: u16) -> Self::Output

fn _max(self, rhs: u16) -> Self::Output

fn _min(self, rhs: u16) -> Self::Output

impl NormalOut<u16> for usize

type Output = <usize as NormalOutPromote<u16>>::Output

fn _clamp(self, min: u16, max: u16) -> Self::Output

fn _mul_add(self, a: u16, b: u16) -> Self::Output

fn _add(self, rhs: u16) -> Self::Output

fn _sub(self, rhs: u16) -> Self::Output

fn _mul(self, rhs: u16) -> Self::Output

fn _rem(self, rhs: u16) -> Self::Output

fn _max(self, rhs: u16) -> Self::Output

fn _min(self, rhs: u16) -> Self::Output

impl NormalOut<u16> for bf16

type Output = <bf16 as NormalOutPromote<u16>>::Output

fn _clamp(self, min: u16, max: u16) -> Self::Output

fn _mul_add(self, a: u16, b: u16) -> Self::Output

fn _add(self, rhs: u16) -> Self::Output

fn _sub(self, rhs: u16) -> Self::Output

fn _mul(self, rhs: u16) -> Self::Output

fn _rem(self, rhs: u16) -> Self::Output

fn _max(self, rhs: u16) -> Self::Output

fn _min(self, rhs: u16) -> Self::Output

impl NormalOut<u16> for f16

type Output = <f16 as NormalOutPromote<u16>>::Output

fn _clamp(self, min: u16, max: u16) -> Self::Output

fn _mul_add(self, a: u16, b: u16) -> Self::Output

fn _add(self, rhs: u16) -> Self::Output

fn _sub(self, rhs: u16) -> Self::Output

fn _mul(self, rhs: u16) -> Self::Output

fn _rem(self, rhs: u16) -> Self::Output

fn _max(self, rhs: u16) -> Self::Output

fn _min(self, rhs: u16) -> Self::Output

impl NormalOut<u16> for Complex32

type Output = <Complex<f32> as NormalOutPromote<u16>>::Output

fn _clamp(self, min: u16, max: u16) -> Self::Output

fn _mul_add(self, a: u16, b: u16) -> Self::Output

fn _add(self, rhs: u16) -> Self::Output

fn _sub(self, rhs: u16) -> Self::Output

fn _mul(self, rhs: u16) -> Self::Output

fn _rem(self, rhs: u16) -> Self::Output

fn _max(self, rhs: u16) -> Self::Output

fn _min(self, rhs: u16) -> Self::Output

impl NormalOut<u16> for Complex64

type Output = <Complex<f64> as NormalOutPromote<u16>>::Output

fn _clamp(self, min: u16, max: u16) -> Self::Output

fn _mul_add(self, a: u16, b: u16) -> Self::Output

fn _add(self, rhs: u16) -> Self::Output

fn _sub(self, rhs: u16) -> Self::Output

fn _mul(self, rhs: u16) -> Self::Output

fn _rem(self, rhs: u16) -> Self::Output

fn _max(self, rhs: u16) -> Self::Output

fn _min(self, rhs: u16) -> Self::Output

impl NormalOut<u32> for bool

type Output = <bool as NormalOutPromote<u32>>::Output

fn _clamp(self, min: u32, max: u32) -> Self::Output

fn _mul_add(self, a: u32, b: u32) -> Self::Output

fn _add(self, rhs: u32) -> Self::Output

fn _sub(self, rhs: u32) -> Self::Output

fn _mul(self, rhs: u32) -> Self::Output

fn _rem(self, rhs: u32) -> Self::Output

fn _max(self, rhs: u32) -> Self::Output

fn _min(self, rhs: u32) -> Self::Output

impl NormalOut<u32> for f32

type Output = <f32 as NormalOutPromote<u32>>::Output

fn _clamp(self, min: u32, max: u32) -> Self::Output

fn _mul_add(self, a: u32, b: u32) -> Self::Output

fn _add(self, rhs: u32) -> Self::Output

fn _sub(self, rhs: u32) -> Self::Output

fn _mul(self, rhs: u32) -> Self::Output

fn _rem(self, rhs: u32) -> Self::Output

fn _max(self, rhs: u32) -> Self::Output

fn _min(self, rhs: u32) -> Self::Output

impl NormalOut<u32> for f64

type Output = <f64 as NormalOutPromote<u32>>::Output

fn _clamp(self, min: u32, max: u32) -> Self::Output

fn _mul_add(self, a: u32, b: u32) -> Self::Output

fn _add(self, rhs: u32) -> Self::Output

fn _sub(self, rhs: u32) -> Self::Output

fn _mul(self, rhs: u32) -> Self::Output

fn _rem(self, rhs: u32) -> Self::Output

fn _max(self, rhs: u32) -> Self::Output

fn _min(self, rhs: u32) -> Self::Output

impl NormalOut<u32> for i8

type Output = <i8 as NormalOutPromote<u32>>::Output

fn _clamp(self, min: u32, max: u32) -> Self::Output

fn _mul_add(self, a: u32, b: u32) -> Self::Output

fn _add(self, rhs: u32) -> Self::Output

fn _sub(self, rhs: u32) -> Self::Output

fn _mul(self, rhs: u32) -> Self::Output

fn _rem(self, rhs: u32) -> Self::Output

fn _max(self, rhs: u32) -> Self::Output

fn _min(self, rhs: u32) -> Self::Output

impl NormalOut<u32> for i16

type Output = <i16 as NormalOutPromote<u32>>::Output

fn _clamp(self, min: u32, max: u32) -> Self::Output

fn _mul_add(self, a: u32, b: u32) -> Self::Output

fn _add(self, rhs: u32) -> Self::Output

fn _sub(self, rhs: u32) -> Self::Output

fn _mul(self, rhs: u32) -> Self::Output

fn _rem(self, rhs: u32) -> Self::Output

fn _max(self, rhs: u32) -> Self::Output

fn _min(self, rhs: u32) -> Self::Output

impl NormalOut<u32> for i32

type Output = <i32 as NormalOutPromote<u32>>::Output

fn _clamp(self, min: u32, max: u32) -> Self::Output

fn _mul_add(self, a: u32, b: u32) -> Self::Output

fn _add(self, rhs: u32) -> Self::Output

fn _sub(self, rhs: u32) -> Self::Output

fn _mul(self, rhs: u32) -> Self::Output

fn _rem(self, rhs: u32) -> Self::Output

fn _max(self, rhs: u32) -> Self::Output

fn _min(self, rhs: u32) -> Self::Output

impl NormalOut<u32> for i64

type Output = <i64 as NormalOutPromote<u32>>::Output

fn _clamp(self, min: u32, max: u32) -> Self::Output

fn _mul_add(self, a: u32, b: u32) -> Self::Output

fn _add(self, rhs: u32) -> Self::Output

fn _sub(self, rhs: u32) -> Self::Output

fn _mul(self, rhs: u32) -> Self::Output

fn _rem(self, rhs: u32) -> Self::Output

fn _max(self, rhs: u32) -> Self::Output

fn _min(self, rhs: u32) -> Self::Output

impl NormalOut<u32> for isize

type Output = <isize as NormalOutPromote<u32>>::Output

fn _clamp(self, min: u32, max: u32) -> Self::Output

fn _mul_add(self, a: u32, b: u32) -> Self::Output

fn _add(self, rhs: u32) -> Self::Output

fn _sub(self, rhs: u32) -> Self::Output

fn _mul(self, rhs: u32) -> Self::Output

fn _rem(self, rhs: u32) -> Self::Output

fn _max(self, rhs: u32) -> Self::Output

fn _min(self, rhs: u32) -> Self::Output

impl NormalOut<u32> for u8

type Output = <u8 as NormalOutPromote<u32>>::Output

fn _clamp(self, min: u32, max: u32) -> Self::Output

fn _mul_add(self, a: u32, b: u32) -> Self::Output

fn _add(self, rhs: u32) -> Self::Output

fn _sub(self, rhs: u32) -> Self::Output

fn _mul(self, rhs: u32) -> Self::Output

fn _rem(self, rhs: u32) -> Self::Output

fn _max(self, rhs: u32) -> Self::Output

fn _min(self, rhs: u32) -> Self::Output

impl NormalOut<u32> for u16

type Output = <u16 as NormalOutPromote<u32>>::Output

fn _clamp(self, min: u32, max: u32) -> Self::Output

fn _mul_add(self, a: u32, b: u32) -> Self::Output

fn _add(self, rhs: u32) -> Self::Output

fn _sub(self, rhs: u32) -> Self::Output

fn _mul(self, rhs: u32) -> Self::Output

fn _rem(self, rhs: u32) -> Self::Output

fn _max(self, rhs: u32) -> Self::Output

fn _min(self, rhs: u32) -> Self::Output

impl NormalOut<u32> for u64

type Output = <u64 as NormalOutPromote<u32>>::Output

fn _clamp(self, min: u32, max: u32) -> Self::Output

fn _mul_add(self, a: u32, b: u32) -> Self::Output

fn _add(self, rhs: u32) -> Self::Output

fn _sub(self, rhs: u32) -> Self::Output

fn _mul(self, rhs: u32) -> Self::Output

fn _rem(self, rhs: u32) -> Self::Output

fn _max(self, rhs: u32) -> Self::Output

fn _min(self, rhs: u32) -> Self::Output

impl NormalOut<u32> for usize

type Output = <usize as NormalOutPromote<u32>>::Output

fn _clamp(self, min: u32, max: u32) -> Self::Output

fn _mul_add(self, a: u32, b: u32) -> Self::Output

fn _add(self, rhs: u32) -> Self::Output

fn _sub(self, rhs: u32) -> Self::Output

fn _mul(self, rhs: u32) -> Self::Output

fn _rem(self, rhs: u32) -> Self::Output

fn _max(self, rhs: u32) -> Self::Output

fn _min(self, rhs: u32) -> Self::Output

impl NormalOut<u32> for bf16

type Output = <bf16 as NormalOutPromote<u32>>::Output

fn _clamp(self, min: u32, max: u32) -> Self::Output

fn _mul_add(self, a: u32, b: u32) -> Self::Output

fn _add(self, rhs: u32) -> Self::Output

fn _sub(self, rhs: u32) -> Self::Output

fn _mul(self, rhs: u32) -> Self::Output

fn _rem(self, rhs: u32) -> Self::Output

fn _max(self, rhs: u32) -> Self::Output

fn _min(self, rhs: u32) -> Self::Output

impl NormalOut<u32> for f16

type Output = <f16 as NormalOutPromote<u32>>::Output

fn _clamp(self, min: u32, max: u32) -> Self::Output

fn _mul_add(self, a: u32, b: u32) -> Self::Output

fn _add(self, rhs: u32) -> Self::Output

fn _sub(self, rhs: u32) -> Self::Output

fn _mul(self, rhs: u32) -> Self::Output

fn _rem(self, rhs: u32) -> Self::Output

fn _max(self, rhs: u32) -> Self::Output

fn _min(self, rhs: u32) -> Self::Output

impl NormalOut<u32> for Complex32

type Output = <Complex<f32> as NormalOutPromote<u32>>::Output

fn _clamp(self, min: u32, max: u32) -> Self::Output

fn _mul_add(self, a: u32, b: u32) -> Self::Output

fn _add(self, rhs: u32) -> Self::Output

fn _sub(self, rhs: u32) -> Self::Output

fn _mul(self, rhs: u32) -> Self::Output

fn _rem(self, rhs: u32) -> Self::Output

fn _max(self, rhs: u32) -> Self::Output

fn _min(self, rhs: u32) -> Self::Output

impl NormalOut<u32> for Complex64

type Output = <Complex<f64> as NormalOutPromote<u32>>::Output

fn _clamp(self, min: u32, max: u32) -> Self::Output

fn _mul_add(self, a: u32, b: u32) -> Self::Output

fn _add(self, rhs: u32) -> Self::Output

fn _sub(self, rhs: u32) -> Self::Output

fn _mul(self, rhs: u32) -> Self::Output

fn _rem(self, rhs: u32) -> Self::Output

fn _max(self, rhs: u32) -> Self::Output

fn _min(self, rhs: u32) -> Self::Output

impl NormalOut<u64> for bool

type Output = <bool as NormalOutPromote<u64>>::Output

fn _clamp(self, min: u64, max: u64) -> Self::Output

fn _mul_add(self, a: u64, b: u64) -> Self::Output

fn _add(self, rhs: u64) -> Self::Output

fn _sub(self, rhs: u64) -> Self::Output

fn _mul(self, rhs: u64) -> Self::Output

fn _rem(self, rhs: u64) -> Self::Output

fn _max(self, rhs: u64) -> Self::Output

fn _min(self, rhs: u64) -> Self::Output

impl NormalOut<u64> for f32

type Output = <f32 as NormalOutPromote<u64>>::Output

fn _clamp(self, min: u64, max: u64) -> Self::Output

fn _mul_add(self, a: u64, b: u64) -> Self::Output

fn _add(self, rhs: u64) -> Self::Output

fn _sub(self, rhs: u64) -> Self::Output

fn _mul(self, rhs: u64) -> Self::Output

fn _rem(self, rhs: u64) -> Self::Output

fn _max(self, rhs: u64) -> Self::Output

fn _min(self, rhs: u64) -> Self::Output

impl NormalOut<u64> for f64

type Output = <f64 as NormalOutPromote<u64>>::Output

fn _clamp(self, min: u64, max: u64) -> Self::Output

fn _mul_add(self, a: u64, b: u64) -> Self::Output

fn _add(self, rhs: u64) -> Self::Output

fn _sub(self, rhs: u64) -> Self::Output

fn _mul(self, rhs: u64) -> Self::Output

fn _rem(self, rhs: u64) -> Self::Output

fn _max(self, rhs: u64) -> Self::Output

fn _min(self, rhs: u64) -> Self::Output

impl NormalOut<u64> for i8

type Output = <i8 as NormalOutPromote<u64>>::Output

fn _clamp(self, min: u64, max: u64) -> Self::Output

fn _mul_add(self, a: u64, b: u64) -> Self::Output

fn _add(self, rhs: u64) -> Self::Output

fn _sub(self, rhs: u64) -> Self::Output

fn _mul(self, rhs: u64) -> Self::Output

fn _rem(self, rhs: u64) -> Self::Output

fn _max(self, rhs: u64) -> Self::Output

fn _min(self, rhs: u64) -> Self::Output

impl NormalOut<u64> for i16

type Output = <i16 as NormalOutPromote<u64>>::Output

fn _clamp(self, min: u64, max: u64) -> Self::Output

fn _mul_add(self, a: u64, b: u64) -> Self::Output

fn _add(self, rhs: u64) -> Self::Output

fn _sub(self, rhs: u64) -> Self::Output

fn _mul(self, rhs: u64) -> Self::Output

fn _rem(self, rhs: u64) -> Self::Output

fn _max(self, rhs: u64) -> Self::Output

fn _min(self, rhs: u64) -> Self::Output

impl NormalOut<u64> for i32

type Output = <i32 as NormalOutPromote<u64>>::Output

fn _clamp(self, min: u64, max: u64) -> Self::Output

fn _mul_add(self, a: u64, b: u64) -> Self::Output

fn _add(self, rhs: u64) -> Self::Output

fn _sub(self, rhs: u64) -> Self::Output

fn _mul(self, rhs: u64) -> Self::Output

fn _rem(self, rhs: u64) -> Self::Output

fn _max(self, rhs: u64) -> Self::Output

fn _min(self, rhs: u64) -> Self::Output

impl NormalOut<u64> for i64

type Output = <i64 as NormalOutPromote<u64>>::Output

fn _clamp(self, min: u64, max: u64) -> Self::Output

fn _mul_add(self, a: u64, b: u64) -> Self::Output

fn _add(self, rhs: u64) -> Self::Output

fn _sub(self, rhs: u64) -> Self::Output

fn _mul(self, rhs: u64) -> Self::Output

fn _rem(self, rhs: u64) -> Self::Output

fn _max(self, rhs: u64) -> Self::Output

fn _min(self, rhs: u64) -> Self::Output

impl NormalOut<u64> for isize

type Output = <isize as NormalOutPromote<u64>>::Output

fn _clamp(self, min: u64, max: u64) -> Self::Output

fn _mul_add(self, a: u64, b: u64) -> Self::Output

fn _add(self, rhs: u64) -> Self::Output

fn _sub(self, rhs: u64) -> Self::Output

fn _mul(self, rhs: u64) -> Self::Output

fn _rem(self, rhs: u64) -> Self::Output

fn _max(self, rhs: u64) -> Self::Output

fn _min(self, rhs: u64) -> Self::Output

impl NormalOut<u64> for u8

type Output = <u8 as NormalOutPromote<u64>>::Output

fn _clamp(self, min: u64, max: u64) -> Self::Output

fn _mul_add(self, a: u64, b: u64) -> Self::Output

fn _add(self, rhs: u64) -> Self::Output

fn _sub(self, rhs: u64) -> Self::Output

fn _mul(self, rhs: u64) -> Self::Output

fn _rem(self, rhs: u64) -> Self::Output

fn _max(self, rhs: u64) -> Self::Output

fn _min(self, rhs: u64) -> Self::Output

impl NormalOut<u64> for u16

type Output = <u16 as NormalOutPromote<u64>>::Output

fn _clamp(self, min: u64, max: u64) -> Self::Output

fn _mul_add(self, a: u64, b: u64) -> Self::Output

fn _add(self, rhs: u64) -> Self::Output

fn _sub(self, rhs: u64) -> Self::Output

fn _mul(self, rhs: u64) -> Self::Output

fn _rem(self, rhs: u64) -> Self::Output

fn _max(self, rhs: u64) -> Self::Output

fn _min(self, rhs: u64) -> Self::Output

impl NormalOut<u64> for u32

type Output = <u32 as NormalOutPromote<u64>>::Output

fn _clamp(self, min: u64, max: u64) -> Self::Output

fn _mul_add(self, a: u64, b: u64) -> Self::Output

fn _add(self, rhs: u64) -> Self::Output

fn _sub(self, rhs: u64) -> Self::Output

fn _mul(self, rhs: u64) -> Self::Output

fn _rem(self, rhs: u64) -> Self::Output

fn _max(self, rhs: u64) -> Self::Output

fn _min(self, rhs: u64) -> Self::Output

impl NormalOut<u64> for usize

type Output = <usize as NormalOutPromote<u64>>::Output

fn _clamp(self, min: u64, max: u64) -> Self::Output

fn _mul_add(self, a: u64, b: u64) -> Self::Output

fn _add(self, rhs: u64) -> Self::Output

fn _sub(self, rhs: u64) -> Self::Output

fn _mul(self, rhs: u64) -> Self::Output

fn _rem(self, rhs: u64) -> Self::Output

fn _max(self, rhs: u64) -> Self::Output

fn _min(self, rhs: u64) -> Self::Output

impl NormalOut<u64> for bf16

type Output = <bf16 as NormalOutPromote<u64>>::Output

fn _clamp(self, min: u64, max: u64) -> Self::Output

fn _mul_add(self, a: u64, b: u64) -> Self::Output

fn _add(self, rhs: u64) -> Self::Output

fn _sub(self, rhs: u64) -> Self::Output

fn _mul(self, rhs: u64) -> Self::Output

fn _rem(self, rhs: u64) -> Self::Output

fn _max(self, rhs: u64) -> Self::Output

fn _min(self, rhs: u64) -> Self::Output

impl NormalOut<u64> for f16

type Output = <f16 as NormalOutPromote<u64>>::Output

fn _clamp(self, min: u64, max: u64) -> Self::Output

fn _mul_add(self, a: u64, b: u64) -> Self::Output

fn _add(self, rhs: u64) -> Self::Output

fn _sub(self, rhs: u64) -> Self::Output

fn _mul(self, rhs: u64) -> Self::Output

fn _rem(self, rhs: u64) -> Self::Output

fn _max(self, rhs: u64) -> Self::Output

fn _min(self, rhs: u64) -> Self::Output

impl NormalOut<u64> for Complex32

type Output = <Complex<f32> as NormalOutPromote<u64>>::Output

fn _clamp(self, min: u64, max: u64) -> Self::Output

fn _mul_add(self, a: u64, b: u64) -> Self::Output

fn _add(self, rhs: u64) -> Self::Output

fn _sub(self, rhs: u64) -> Self::Output

fn _mul(self, rhs: u64) -> Self::Output

fn _rem(self, rhs: u64) -> Self::Output

fn _max(self, rhs: u64) -> Self::Output

fn _min(self, rhs: u64) -> Self::Output

impl NormalOut<u64> for Complex64

type Output = <Complex<f64> as NormalOutPromote<u64>>::Output

fn _clamp(self, min: u64, max: u64) -> Self::Output

fn _mul_add(self, a: u64, b: u64) -> Self::Output

fn _add(self, rhs: u64) -> Self::Output

fn _sub(self, rhs: u64) -> Self::Output

fn _mul(self, rhs: u64) -> Self::Output

fn _rem(self, rhs: u64) -> Self::Output

fn _max(self, rhs: u64) -> Self::Output

fn _min(self, rhs: u64) -> Self::Output

impl NormalOut<usize> for bool

type Output = <bool as NormalOutPromote<usize>>::Output

fn _clamp(self, min: usize, max: usize) -> Self::Output

fn _mul_add(self, a: usize, b: usize) -> Self::Output

fn _add(self, rhs: usize) -> Self::Output

fn _sub(self, rhs: usize) -> Self::Output

fn _mul(self, rhs: usize) -> Self::Output

fn _rem(self, rhs: usize) -> Self::Output

fn _max(self, rhs: usize) -> Self::Output

fn _min(self, rhs: usize) -> Self::Output

impl NormalOut<usize> for f32

type Output = <f32 as NormalOutPromote<usize>>::Output

fn _clamp(self, min: usize, max: usize) -> Self::Output

fn _mul_add(self, a: usize, b: usize) -> Self::Output

fn _add(self, rhs: usize) -> Self::Output

fn _sub(self, rhs: usize) -> Self::Output

fn _mul(self, rhs: usize) -> Self::Output

fn _rem(self, rhs: usize) -> Self::Output

fn _max(self, rhs: usize) -> Self::Output

fn _min(self, rhs: usize) -> Self::Output

impl NormalOut<usize> for f64

type Output = <f64 as NormalOutPromote<usize>>::Output

fn _clamp(self, min: usize, max: usize) -> Self::Output

fn _mul_add(self, a: usize, b: usize) -> Self::Output

fn _add(self, rhs: usize) -> Self::Output

fn _sub(self, rhs: usize) -> Self::Output

fn _mul(self, rhs: usize) -> Self::Output

fn _rem(self, rhs: usize) -> Self::Output

fn _max(self, rhs: usize) -> Self::Output

fn _min(self, rhs: usize) -> Self::Output

impl NormalOut<usize> for i8

type Output = <i8 as NormalOutPromote<usize>>::Output

fn _clamp(self, min: usize, max: usize) -> Self::Output

fn _mul_add(self, a: usize, b: usize) -> Self::Output

fn _add(self, rhs: usize) -> Self::Output

fn _sub(self, rhs: usize) -> Self::Output

fn _mul(self, rhs: usize) -> Self::Output

fn _rem(self, rhs: usize) -> Self::Output

fn _max(self, rhs: usize) -> Self::Output

fn _min(self, rhs: usize) -> Self::Output

impl NormalOut<usize> for i16

type Output = <i16 as NormalOutPromote<usize>>::Output

fn _clamp(self, min: usize, max: usize) -> Self::Output

fn _mul_add(self, a: usize, b: usize) -> Self::Output

fn _add(self, rhs: usize) -> Self::Output

fn _sub(self, rhs: usize) -> Self::Output

fn _mul(self, rhs: usize) -> Self::Output

fn _rem(self, rhs: usize) -> Self::Output

fn _max(self, rhs: usize) -> Self::Output

fn _min(self, rhs: usize) -> Self::Output

impl NormalOut<usize> for i32

type Output = <i32 as NormalOutPromote<usize>>::Output

fn _clamp(self, min: usize, max: usize) -> Self::Output

fn _mul_add(self, a: usize, b: usize) -> Self::Output

fn _add(self, rhs: usize) -> Self::Output

fn _sub(self, rhs: usize) -> Self::Output

fn _mul(self, rhs: usize) -> Self::Output

fn _rem(self, rhs: usize) -> Self::Output

fn _max(self, rhs: usize) -> Self::Output

fn _min(self, rhs: usize) -> Self::Output

impl NormalOut<usize> for i64

type Output = <i64 as NormalOutPromote<usize>>::Output

fn _clamp(self, min: usize, max: usize) -> Self::Output

fn _mul_add(self, a: usize, b: usize) -> Self::Output

fn _add(self, rhs: usize) -> Self::Output

fn _sub(self, rhs: usize) -> Self::Output

fn _mul(self, rhs: usize) -> Self::Output

fn _rem(self, rhs: usize) -> Self::Output

fn _max(self, rhs: usize) -> Self::Output

fn _min(self, rhs: usize) -> Self::Output

impl NormalOut<usize> for isize

type Output = <isize as NormalOutPromote<usize>>::Output

fn _clamp(self, min: usize, max: usize) -> Self::Output

fn _mul_add(self, a: usize, b: usize) -> Self::Output

fn _add(self, rhs: usize) -> Self::Output

fn _sub(self, rhs: usize) -> Self::Output

fn _mul(self, rhs: usize) -> Self::Output

fn _rem(self, rhs: usize) -> Self::Output

fn _max(self, rhs: usize) -> Self::Output

fn _min(self, rhs: usize) -> Self::Output

impl NormalOut<usize> for u8

type Output = <u8 as NormalOutPromote<usize>>::Output

fn _clamp(self, min: usize, max: usize) -> Self::Output

fn _mul_add(self, a: usize, b: usize) -> Self::Output

fn _add(self, rhs: usize) -> Self::Output

fn _sub(self, rhs: usize) -> Self::Output

fn _mul(self, rhs: usize) -> Self::Output

fn _rem(self, rhs: usize) -> Self::Output

fn _max(self, rhs: usize) -> Self::Output

fn _min(self, rhs: usize) -> Self::Output

impl NormalOut<usize> for u16

type Output = <u16 as NormalOutPromote<usize>>::Output

fn _clamp(self, min: usize, max: usize) -> Self::Output

fn _mul_add(self, a: usize, b: usize) -> Self::Output

fn _add(self, rhs: usize) -> Self::Output

fn _sub(self, rhs: usize) -> Self::Output

fn _mul(self, rhs: usize) -> Self::Output

fn _rem(self, rhs: usize) -> Self::Output

fn _max(self, rhs: usize) -> Self::Output

fn _min(self, rhs: usize) -> Self::Output

impl NormalOut<usize> for u32

type Output = <u32 as NormalOutPromote<usize>>::Output

fn _clamp(self, min: usize, max: usize) -> Self::Output

fn _mul_add(self, a: usize, b: usize) -> Self::Output

fn _add(self, rhs: usize) -> Self::Output

fn _sub(self, rhs: usize) -> Self::Output

fn _mul(self, rhs: usize) -> Self::Output

fn _rem(self, rhs: usize) -> Self::Output

fn _max(self, rhs: usize) -> Self::Output

fn _min(self, rhs: usize) -> Self::Output

impl NormalOut<usize> for u64

type Output = <u64 as NormalOutPromote<usize>>::Output

fn _clamp(self, min: usize, max: usize) -> Self::Output

fn _mul_add(self, a: usize, b: usize) -> Self::Output

fn _add(self, rhs: usize) -> Self::Output

fn _sub(self, rhs: usize) -> Self::Output

fn _mul(self, rhs: usize) -> Self::Output

fn _rem(self, rhs: usize) -> Self::Output

fn _max(self, rhs: usize) -> Self::Output

fn _min(self, rhs: usize) -> Self::Output

impl NormalOut<usize> for bf16

type Output = <bf16 as NormalOutPromote<usize>>::Output

fn _clamp(self, min: usize, max: usize) -> Self::Output

fn _mul_add(self, a: usize, b: usize) -> Self::Output

fn _add(self, rhs: usize) -> Self::Output

fn _sub(self, rhs: usize) -> Self::Output

fn _mul(self, rhs: usize) -> Self::Output

fn _rem(self, rhs: usize) -> Self::Output

fn _max(self, rhs: usize) -> Self::Output

fn _min(self, rhs: usize) -> Self::Output

impl NormalOut<usize> for f16

type Output = <f16 as NormalOutPromote<usize>>::Output

fn _clamp(self, min: usize, max: usize) -> Self::Output

fn _mul_add(self, a: usize, b: usize) -> Self::Output

fn _add(self, rhs: usize) -> Self::Output

fn _sub(self, rhs: usize) -> Self::Output

fn _mul(self, rhs: usize) -> Self::Output

fn _rem(self, rhs: usize) -> Self::Output

fn _max(self, rhs: usize) -> Self::Output

fn _min(self, rhs: usize) -> Self::Output

impl NormalOut<usize> for Complex32

type Output = <Complex<f32> as NormalOutPromote<usize>>::Output

fn _clamp(self, min: usize, max: usize) -> Self::Output

fn _mul_add(self, a: usize, b: usize) -> Self::Output

fn _add(self, rhs: usize) -> Self::Output

fn _sub(self, rhs: usize) -> Self::Output

fn _mul(self, rhs: usize) -> Self::Output

fn _rem(self, rhs: usize) -> Self::Output

fn _max(self, rhs: usize) -> Self::Output

fn _min(self, rhs: usize) -> Self::Output

impl NormalOut<usize> for Complex64

type Output = <Complex<f64> as NormalOutPromote<usize>>::Output

fn _clamp(self, min: usize, max: usize) -> Self::Output

fn _mul_add(self, a: usize, b: usize) -> Self::Output

fn _add(self, rhs: usize) -> Self::Output

fn _sub(self, rhs: usize) -> Self::Output

fn _mul(self, rhs: usize) -> Self::Output

fn _rem(self, rhs: usize) -> Self::Output

fn _max(self, rhs: usize) -> Self::Output

fn _min(self, rhs: usize) -> Self::Output

impl NormalOut<bf16x8> for bool

type Output = <boolx16 as NormalOutPromote<bf16x8>>::Output

fn _mul_add(self, a: bf16x8, b: bf16x8) -> Self::Output

fn _add(self, rhs: bf16x8) -> Self::Output

fn _sub(self, rhs: bf16x8) -> Self::Output

fn _mul(self, rhs: bf16x8) -> Self::Output

fn _rem(self, rhs: bf16x8) -> Self::Output

fn _clamp(self, min: bf16x8, max: bf16x8) -> Self::Output

fn _max(self, rhs: bf16x8) -> Self::Output

fn _min(self, rhs: bf16x8) -> Self::Output

impl NormalOut<bf16x8> for f32

type Output = <f32x4 as NormalOutPromote<bf16x8>>::Output

fn _mul_add(self, a: bf16x8, b: bf16x8) -> Self::Output

fn _add(self, rhs: bf16x8) -> Self::Output

fn _sub(self, rhs: bf16x8) -> Self::Output

fn _mul(self, rhs: bf16x8) -> Self::Output

fn _rem(self, rhs: bf16x8) -> Self::Output

fn _clamp(self, min: bf16x8, max: bf16x8) -> Self::Output

fn _max(self, rhs: bf16x8) -> Self::Output

fn _min(self, rhs: bf16x8) -> Self::Output

impl NormalOut<bf16x8> for f64

type Output = <f64x2 as NormalOutPromote<bf16x8>>::Output

fn _mul_add(self, a: bf16x8, b: bf16x8) -> Self::Output

fn _add(self, rhs: bf16x8) -> Self::Output

fn _sub(self, rhs: bf16x8) -> Self::Output

fn _mul(self, rhs: bf16x8) -> Self::Output

fn _rem(self, rhs: bf16x8) -> Self::Output

fn _clamp(self, min: bf16x8, max: bf16x8) -> Self::Output

fn _max(self, rhs: bf16x8) -> Self::Output

fn _min(self, rhs: bf16x8) -> Self::Output

impl NormalOut<bf16x8> for i8

type Output = <i8x16 as NormalOutPromote<bf16x8>>::Output

fn _mul_add(self, a: bf16x8, b: bf16x8) -> Self::Output

fn _add(self, rhs: bf16x8) -> Self::Output

fn _sub(self, rhs: bf16x8) -> Self::Output

fn _mul(self, rhs: bf16x8) -> Self::Output

fn _rem(self, rhs: bf16x8) -> Self::Output

fn _clamp(self, min: bf16x8, max: bf16x8) -> Self::Output

fn _max(self, rhs: bf16x8) -> Self::Output

fn _min(self, rhs: bf16x8) -> Self::Output

impl NormalOut<bf16x8> for i16

type Output = <i16x8 as NormalOutPromote<bf16x8>>::Output

fn _add(self, rhs: bf16x8) -> Self::Output

fn _sub(self, rhs: bf16x8) -> Self::Output

fn _mul(self, rhs: bf16x8) -> Self::Output

fn _max(self, rhs: bf16x8) -> Self::Output

fn _min(self, rhs: bf16x8) -> Self::Output

fn _rem(self, rhs: bf16x8) -> Self::Output

fn _clamp(self, min: bf16x8, max: bf16x8) -> Self::Output

fn _mul_add(self, a: bf16x8, b: bf16x8) -> Self::Output

impl NormalOut<bf16x8> for i32

type Output = <i32x4 as NormalOutPromote<bf16x8>>::Output

fn _mul_add(self, a: bf16x8, b: bf16x8) -> Self::Output

fn _add(self, rhs: bf16x8) -> Self::Output

fn _sub(self, rhs: bf16x8) -> Self::Output

fn _mul(self, rhs: bf16x8) -> Self::Output

fn _rem(self, rhs: bf16x8) -> Self::Output

fn _clamp(self, min: bf16x8, max: bf16x8) -> Self::Output

fn _max(self, rhs: bf16x8) -> Self::Output

fn _min(self, rhs: bf16x8) -> Self::Output

impl NormalOut<bf16x8> for i64

type Output = <i64x2 as NormalOutPromote<bf16x8>>::Output

fn _mul_add(self, a: bf16x8, b: bf16x8) -> Self::Output

fn _add(self, rhs: bf16x8) -> Self::Output

fn _sub(self, rhs: bf16x8) -> Self::Output

fn _mul(self, rhs: bf16x8) -> Self::Output

fn _rem(self, rhs: bf16x8) -> Self::Output

fn _clamp(self, min: bf16x8, max: bf16x8) -> Self::Output

fn _max(self, rhs: bf16x8) -> Self::Output

fn _min(self, rhs: bf16x8) -> Self::Output

impl NormalOut<bf16x8> for isize

type Output = <isizex2 as NormalOutPromote<bf16x8>>::Output

fn _mul_add(self, a: bf16x8, b: bf16x8) -> Self::Output

fn _add(self, rhs: bf16x8) -> Self::Output

fn _sub(self, rhs: bf16x8) -> Self::Output

fn _mul(self, rhs: bf16x8) -> Self::Output

fn _rem(self, rhs: bf16x8) -> Self::Output

fn _clamp(self, min: bf16x8, max: bf16x8) -> Self::Output

fn _max(self, rhs: bf16x8) -> Self::Output

fn _min(self, rhs: bf16x8) -> Self::Output

impl NormalOut<bf16x8> for u8

type Output = <u8x16 as NormalOutPromote<bf16x8>>::Output

fn _mul_add(self, a: bf16x8, b: bf16x8) -> Self::Output

fn _add(self, rhs: bf16x8) -> Self::Output

fn _sub(self, rhs: bf16x8) -> Self::Output

fn _mul(self, rhs: bf16x8) -> Self::Output

fn _rem(self, rhs: bf16x8) -> Self::Output

fn _clamp(self, min: bf16x8, max: bf16x8) -> Self::Output

fn _max(self, rhs: bf16x8) -> Self::Output

fn _min(self, rhs: bf16x8) -> Self::Output

impl NormalOut<bf16x8> for u16

type Output = <u16x8 as NormalOutPromote<bf16x8>>::Output

fn _add(self, rhs: bf16x8) -> Self::Output

fn _sub(self, rhs: bf16x8) -> Self::Output

fn _mul(self, rhs: bf16x8) -> Self::Output

fn _max(self, rhs: bf16x8) -> Self::Output

fn _min(self, rhs: bf16x8) -> Self::Output

fn _rem(self, rhs: bf16x8) -> Self::Output

fn _clamp(self, min: bf16x8, max: bf16x8) -> Self::Output

fn _mul_add(self, a: bf16x8, b: bf16x8) -> Self::Output

impl NormalOut<bf16x8> for u32

type Output = <u32x4 as NormalOutPromote<bf16x8>>::Output

fn _mul_add(self, a: bf16x8, b: bf16x8) -> Self::Output

fn _add(self, rhs: bf16x8) -> Self::Output

fn _sub(self, rhs: bf16x8) -> Self::Output

fn _mul(self, rhs: bf16x8) -> Self::Output

fn _rem(self, rhs: bf16x8) -> Self::Output

fn _clamp(self, min: bf16x8, max: bf16x8) -> Self::Output

fn _max(self, rhs: bf16x8) -> Self::Output

fn _min(self, rhs: bf16x8) -> Self::Output

impl NormalOut<bf16x8> for u64

type Output = <u64x2 as NormalOutPromote<bf16x8>>::Output

fn _mul_add(self, a: bf16x8, b: bf16x8) -> Self::Output

fn _add(self, rhs: bf16x8) -> Self::Output

fn _sub(self, rhs: bf16x8) -> Self::Output

fn _mul(self, rhs: bf16x8) -> Self::Output

fn _rem(self, rhs: bf16x8) -> Self::Output

fn _clamp(self, min: bf16x8, max: bf16x8) -> Self::Output

fn _max(self, rhs: bf16x8) -> Self::Output

fn _min(self, rhs: bf16x8) -> Self::Output

impl NormalOut<bf16x8> for usize

type Output = <usizex2 as NormalOutPromote<bf16x8>>::Output

fn _mul_add(self, a: bf16x8, b: bf16x8) -> Self::Output

fn _add(self, rhs: bf16x8) -> Self::Output

fn _sub(self, rhs: bf16x8) -> Self::Output

fn _mul(self, rhs: bf16x8) -> Self::Output

fn _rem(self, rhs: bf16x8) -> Self::Output

fn _clamp(self, min: bf16x8, max: bf16x8) -> Self::Output

fn _max(self, rhs: bf16x8) -> Self::Output

fn _min(self, rhs: bf16x8) -> Self::Output

impl NormalOut<bf16x8> for bf16

type Output = <bf16x8 as NormalOutPromote>::Output

fn _add(self, rhs: bf16x8) -> Self::Output

fn _sub(self, rhs: bf16x8) -> Self::Output

fn _mul(self, rhs: bf16x8) -> Self::Output

fn _max(self, rhs: bf16x8) -> Self::Output

fn _min(self, rhs: bf16x8) -> Self::Output

fn _rem(self, rhs: bf16x8) -> Self::Output

fn _clamp(self, min: bf16x8, max: bf16x8) -> Self::Output

fn _mul_add(self, a: bf16x8, b: bf16x8) -> Self::Output

impl NormalOut<bf16x8> for f16

type Output = <f16x8 as NormalOutPromote<bf16x8>>::Output

fn _add(self, rhs: bf16x8) -> Self::Output

fn _sub(self, rhs: bf16x8) -> Self::Output

fn _mul(self, rhs: bf16x8) -> Self::Output

fn _max(self, rhs: bf16x8) -> Self::Output

fn _min(self, rhs: bf16x8) -> Self::Output

fn _rem(self, rhs: bf16x8) -> Self::Output

fn _clamp(self, min: bf16x8, max: bf16x8) -> Self::Output

fn _mul_add(self, a: bf16x8, b: bf16x8) -> Self::Output

impl NormalOut<bf16x8> for Complex32

type Output = <cplx32x2 as NormalOutPromote<bf16x8>>::Output

fn _mul_add(self, a: bf16x8, b: bf16x8) -> Self::Output

fn _add(self, rhs: bf16x8) -> Self::Output

fn _sub(self, rhs: bf16x8) -> Self::Output

fn _mul(self, rhs: bf16x8) -> Self::Output

fn _rem(self, rhs: bf16x8) -> Self::Output

fn _clamp(self, min: bf16x8, max: bf16x8) -> Self::Output

fn _max(self, rhs: bf16x8) -> Self::Output

fn _min(self, rhs: bf16x8) -> Self::Output

impl NormalOut<bf16x8> for Complex64

type Output = <cplx64x1 as NormalOutPromote<bf16x8>>::Output

fn _mul_add(self, a: bf16x8, b: bf16x8) -> Self::Output

fn _add(self, rhs: bf16x8) -> Self::Output

fn _sub(self, rhs: bf16x8) -> Self::Output

fn _mul(self, rhs: bf16x8) -> Self::Output

fn _rem(self, rhs: bf16x8) -> Self::Output

fn _clamp(self, min: bf16x8, max: bf16x8) -> Self::Output

fn _max(self, rhs: bf16x8) -> Self::Output

fn _min(self, rhs: bf16x8) -> Self::Output

impl NormalOut<boolx16> for bool

type Output = <boolx16 as NormalOutPromote>::Output

fn _add(self, rhs: boolx16) -> Self::Output

fn _sub(self, rhs: boolx16) -> Self::Output

fn _mul(self, rhs: boolx16) -> Self::Output

fn _max(self, rhs: boolx16) -> Self::Output

fn _min(self, rhs: boolx16) -> Self::Output

fn _rem(self, rhs: boolx16) -> Self::Output

fn _clamp(self, min: boolx16, max: boolx16) -> Self::Output

fn _mul_add(self, a: boolx16, b: boolx16) -> Self::Output

impl NormalOut<boolx16> for f32

type Output = <f32x4 as NormalOutPromote<boolx16>>::Output

fn _mul_add(self, a: boolx16, b: boolx16) -> Self::Output

fn _add(self, rhs: boolx16) -> Self::Output

fn _sub(self, rhs: boolx16) -> Self::Output

fn _mul(self, rhs: boolx16) -> Self::Output

fn _rem(self, rhs: boolx16) -> Self::Output

fn _clamp(self, min: boolx16, max: boolx16) -> Self::Output

fn _max(self, rhs: boolx16) -> Self::Output

fn _min(self, rhs: boolx16) -> Self::Output

impl NormalOut<boolx16> for f64

type Output = <f64x2 as NormalOutPromote<boolx16>>::Output

fn _mul_add(self, a: boolx16, b: boolx16) -> Self::Output

fn _add(self, rhs: boolx16) -> Self::Output

fn _sub(self, rhs: boolx16) -> Self::Output

fn _mul(self, rhs: boolx16) -> Self::Output

fn _rem(self, rhs: boolx16) -> Self::Output

fn _clamp(self, min: boolx16, max: boolx16) -> Self::Output

fn _max(self, rhs: boolx16) -> Self::Output

fn _min(self, rhs: boolx16) -> Self::Output

impl NormalOut<boolx16> for i8

type Output = <i8x16 as NormalOutPromote<boolx16>>::Output

fn _add(self, rhs: boolx16) -> Self::Output

fn _sub(self, rhs: boolx16) -> Self::Output

fn _mul(self, rhs: boolx16) -> Self::Output

fn _max(self, rhs: boolx16) -> Self::Output

fn _min(self, rhs: boolx16) -> Self::Output

fn _rem(self, rhs: boolx16) -> Self::Output

fn _clamp(self, min: boolx16, max: boolx16) -> Self::Output

fn _mul_add(self, a: boolx16, b: boolx16) -> Self::Output

impl NormalOut<boolx16> for i16

type Output = <i16x8 as NormalOutPromote<boolx16>>::Output

fn _mul_add(self, a: boolx16, b: boolx16) -> Self::Output

fn _add(self, rhs: boolx16) -> Self::Output

fn _sub(self, rhs: boolx16) -> Self::Output

fn _mul(self, rhs: boolx16) -> Self::Output

fn _rem(self, rhs: boolx16) -> Self::Output

fn _clamp(self, min: boolx16, max: boolx16) -> Self::Output

fn _max(self, rhs: boolx16) -> Self::Output

fn _min(self, rhs: boolx16) -> Self::Output

impl NormalOut<boolx16> for i32

type Output = <i32x4 as NormalOutPromote<boolx16>>::Output

fn _mul_add(self, a: boolx16, b: boolx16) -> Self::Output

fn _add(self, rhs: boolx16) -> Self::Output

fn _sub(self, rhs: boolx16) -> Self::Output

fn _mul(self, rhs: boolx16) -> Self::Output

fn _rem(self, rhs: boolx16) -> Self::Output

fn _clamp(self, min: boolx16, max: boolx16) -> Self::Output

fn _max(self, rhs: boolx16) -> Self::Output

fn _min(self, rhs: boolx16) -> Self::Output

impl NormalOut<boolx16> for i64

type Output = <i64x2 as NormalOutPromote<boolx16>>::Output

fn _mul_add(self, a: boolx16, b: boolx16) -> Self::Output

fn _add(self, rhs: boolx16) -> Self::Output

fn _sub(self, rhs: boolx16) -> Self::Output

fn _mul(self, rhs: boolx16) -> Self::Output

fn _rem(self, rhs: boolx16) -> Self::Output

fn _clamp(self, min: boolx16, max: boolx16) -> Self::Output

fn _max(self, rhs: boolx16) -> Self::Output

fn _min(self, rhs: boolx16) -> Self::Output

impl NormalOut<boolx16> for isize

type Output = <isizex2 as NormalOutPromote<boolx16>>::Output

fn _mul_add(self, a: boolx16, b: boolx16) -> Self::Output

fn _add(self, rhs: boolx16) -> Self::Output

fn _sub(self, rhs: boolx16) -> Self::Output

fn _mul(self, rhs: boolx16) -> Self::Output

fn _rem(self, rhs: boolx16) -> Self::Output

fn _clamp(self, min: boolx16, max: boolx16) -> Self::Output

fn _max(self, rhs: boolx16) -> Self::Output

fn _min(self, rhs: boolx16) -> Self::Output

impl NormalOut<boolx16> for u8

type Output = <u8x16 as NormalOutPromote<boolx16>>::Output

fn _add(self, rhs: boolx16) -> Self::Output

fn _sub(self, rhs: boolx16) -> Self::Output

fn _mul(self, rhs: boolx16) -> Self::Output

fn _max(self, rhs: boolx16) -> Self::Output

fn _min(self, rhs: boolx16) -> Self::Output

fn _rem(self, rhs: boolx16) -> Self::Output

fn _clamp(self, min: boolx16, max: boolx16) -> Self::Output

fn _mul_add(self, a: boolx16, b: boolx16) -> Self::Output

impl NormalOut<boolx16> for u16

type Output = <u16x8 as NormalOutPromote<boolx16>>::Output

fn _mul_add(self, a: boolx16, b: boolx16) -> Self::Output

fn _add(self, rhs: boolx16) -> Self::Output

fn _sub(self, rhs: boolx16) -> Self::Output

fn _mul(self, rhs: boolx16) -> Self::Output

fn _rem(self, rhs: boolx16) -> Self::Output

fn _clamp(self, min: boolx16, max: boolx16) -> Self::Output

fn _max(self, rhs: boolx16) -> Self::Output

fn _min(self, rhs: boolx16) -> Self::Output

impl NormalOut<boolx16> for u32

type Output = <u32x4 as NormalOutPromote<boolx16>>::Output

fn _mul_add(self, a: boolx16, b: boolx16) -> Self::Output

fn _add(self, rhs: boolx16) -> Self::Output

fn _sub(self, rhs: boolx16) -> Self::Output

fn _mul(self, rhs: boolx16) -> Self::Output

fn _rem(self, rhs: boolx16) -> Self::Output

fn _clamp(self, min: boolx16, max: boolx16) -> Self::Output

fn _max(self, rhs: boolx16) -> Self::Output

fn _min(self, rhs: boolx16) -> Self::Output

impl NormalOut<boolx16> for u64

type Output = <u64x2 as NormalOutPromote<boolx16>>::Output

fn _mul_add(self, a: boolx16, b: boolx16) -> Self::Output

fn _add(self, rhs: boolx16) -> Self::Output

fn _sub(self, rhs: boolx16) -> Self::Output

fn _mul(self, rhs: boolx16) -> Self::Output

fn _rem(self, rhs: boolx16) -> Self::Output

fn _clamp(self, min: boolx16, max: boolx16) -> Self::Output

fn _max(self, rhs: boolx16) -> Self::Output

fn _min(self, rhs: boolx16) -> Self::Output

impl NormalOut<boolx16> for usize

type Output = <usizex2 as NormalOutPromote<boolx16>>::Output

fn _mul_add(self, a: boolx16, b: boolx16) -> Self::Output

fn _add(self, rhs: boolx16) -> Self::Output

fn _sub(self, rhs: boolx16) -> Self::Output

fn _mul(self, rhs: boolx16) -> Self::Output

fn _rem(self, rhs: boolx16) -> Self::Output

fn _clamp(self, min: boolx16, max: boolx16) -> Self::Output

fn _max(self, rhs: boolx16) -> Self::Output

fn _min(self, rhs: boolx16) -> Self::Output

impl NormalOut<boolx16> for bf16

type Output = <bf16x8 as NormalOutPromote<boolx16>>::Output

fn _mul_add(self, a: boolx16, b: boolx16) -> Self::Output

fn _add(self, rhs: boolx16) -> Self::Output

fn _sub(self, rhs: boolx16) -> Self::Output

fn _mul(self, rhs: boolx16) -> Self::Output

fn _rem(self, rhs: boolx16) -> Self::Output

fn _clamp(self, min: boolx16, max: boolx16) -> Self::Output

fn _max(self, rhs: boolx16) -> Self::Output

fn _min(self, rhs: boolx16) -> Self::Output

impl NormalOut<boolx16> for f16

type Output = <f16x8 as NormalOutPromote<boolx16>>::Output

fn _mul_add(self, a: boolx16, b: boolx16) -> Self::Output

fn _add(self, rhs: boolx16) -> Self::Output

fn _sub(self, rhs: boolx16) -> Self::Output

fn _mul(self, rhs: boolx16) -> Self::Output

fn _rem(self, rhs: boolx16) -> Self::Output

fn _clamp(self, min: boolx16, max: boolx16) -> Self::Output

fn _max(self, rhs: boolx16) -> Self::Output

fn _min(self, rhs: boolx16) -> Self::Output

impl NormalOut<boolx16> for Complex32

type Output = <cplx32x2 as NormalOutPromote<boolx16>>::Output

fn _mul_add(self, a: boolx16, b: boolx16) -> Self::Output

fn _add(self, rhs: boolx16) -> Self::Output

fn _sub(self, rhs: boolx16) -> Self::Output

fn _mul(self, rhs: boolx16) -> Self::Output

fn _rem(self, rhs: boolx16) -> Self::Output

fn _clamp(self, min: boolx16, max: boolx16) -> Self::Output

fn _max(self, rhs: boolx16) -> Self::Output

fn _min(self, rhs: boolx16) -> Self::Output

impl NormalOut<boolx16> for Complex64

type Output = <cplx64x1 as NormalOutPromote<boolx16>>::Output

fn _mul_add(self, a: boolx16, b: boolx16) -> Self::Output

fn _add(self, rhs: boolx16) -> Self::Output

fn _sub(self, rhs: boolx16) -> Self::Output

fn _mul(self, rhs: boolx16) -> Self::Output

fn _rem(self, rhs: boolx16) -> Self::Output

fn _clamp(self, min: boolx16, max: boolx16) -> Self::Output

fn _max(self, rhs: boolx16) -> Self::Output

fn _min(self, rhs: boolx16) -> Self::Output

impl NormalOut<cplx32x2> for bool

type Output = <boolx16 as NormalOutPromote<cplx32x2>>::Output

fn _mul_add(self, a: cplx32x2, b: cplx32x2) -> Self::Output

fn _add(self, rhs: cplx32x2) -> Self::Output

fn _sub(self, rhs: cplx32x2) -> Self::Output

fn _mul(self, rhs: cplx32x2) -> Self::Output

fn _rem(self, rhs: cplx32x2) -> Self::Output

fn _clamp(self, min: cplx32x2, max: cplx32x2) -> Self::Output

fn _max(self, rhs: cplx32x2) -> Self::Output

fn _min(self, rhs: cplx32x2) -> Self::Output

impl NormalOut<cplx32x2> for f32

type Output = <f32x4 as NormalOutPromote<cplx32x2>>::Output

fn _mul_add(self, a: cplx32x2, b: cplx32x2) -> Self::Output

fn _add(self, rhs: cplx32x2) -> Self::Output

fn _sub(self, rhs: cplx32x2) -> Self::Output

fn _mul(self, rhs: cplx32x2) -> Self::Output

fn _rem(self, rhs: cplx32x2) -> Self::Output

fn _clamp(self, min: cplx32x2, max: cplx32x2) -> Self::Output

fn _max(self, rhs: cplx32x2) -> Self::Output

fn _min(self, rhs: cplx32x2) -> Self::Output

impl NormalOut<cplx32x2> for f64

type Output = <f64x2 as NormalOutPromote<cplx32x2>>::Output

fn _add(self, rhs: cplx32x2) -> Self::Output

fn _sub(self, rhs: cplx32x2) -> Self::Output

fn _mul(self, rhs: cplx32x2) -> Self::Output

fn _max(self, rhs: cplx32x2) -> Self::Output

fn _min(self, rhs: cplx32x2) -> Self::Output

fn _rem(self, rhs: cplx32x2) -> Self::Output

fn _clamp(self, min: cplx32x2, max: cplx32x2) -> Self::Output

fn _mul_add(self, a: cplx32x2, b: cplx32x2) -> Self::Output

impl NormalOut<cplx32x2> for i8

type Output = <i8x16 as NormalOutPromote<cplx32x2>>::Output

fn _mul_add(self, a: cplx32x2, b: cplx32x2) -> Self::Output

fn _add(self, rhs: cplx32x2) -> Self::Output

fn _sub(self, rhs: cplx32x2) -> Self::Output

fn _mul(self, rhs: cplx32x2) -> Self::Output

fn _rem(self, rhs: cplx32x2) -> Self::Output

fn _clamp(self, min: cplx32x2, max: cplx32x2) -> Self::Output

fn _max(self, rhs: cplx32x2) -> Self::Output

fn _min(self, rhs: cplx32x2) -> Self::Output

impl NormalOut<cplx32x2> for i16

type Output = <i16x8 as NormalOutPromote<cplx32x2>>::Output

fn _mul_add(self, a: cplx32x2, b: cplx32x2) -> Self::Output

fn _add(self, rhs: cplx32x2) -> Self::Output

fn _sub(self, rhs: cplx32x2) -> Self::Output

fn _mul(self, rhs: cplx32x2) -> Self::Output

fn _rem(self, rhs: cplx32x2) -> Self::Output

fn _clamp(self, min: cplx32x2, max: cplx32x2) -> Self::Output

fn _max(self, rhs: cplx32x2) -> Self::Output

fn _min(self, rhs: cplx32x2) -> Self::Output

impl NormalOut<cplx32x2> for i32

type Output = <i32x4 as NormalOutPromote<cplx32x2>>::Output

fn _mul_add(self, a: cplx32x2, b: cplx32x2) -> Self::Output

fn _add(self, rhs: cplx32x2) -> Self::Output

fn _sub(self, rhs: cplx32x2) -> Self::Output

fn _mul(self, rhs: cplx32x2) -> Self::Output

fn _rem(self, rhs: cplx32x2) -> Self::Output

fn _clamp(self, min: cplx32x2, max: cplx32x2) -> Self::Output

fn _max(self, rhs: cplx32x2) -> Self::Output

fn _min(self, rhs: cplx32x2) -> Self::Output

impl NormalOut<cplx32x2> for i64

type Output = <i64x2 as NormalOutPromote<cplx32x2>>::Output

fn _add(self, rhs: cplx32x2) -> Self::Output

fn _sub(self, rhs: cplx32x2) -> Self::Output

fn _mul(self, rhs: cplx32x2) -> Self::Output

fn _max(self, rhs: cplx32x2) -> Self::Output

fn _min(self, rhs: cplx32x2) -> Self::Output

fn _rem(self, rhs: cplx32x2) -> Self::Output

fn _clamp(self, min: cplx32x2, max: cplx32x2) -> Self::Output

fn _mul_add(self, a: cplx32x2, b: cplx32x2) -> Self::Output

impl NormalOut<cplx32x2> for isize

type Output = <isizex2 as NormalOutPromote<cplx32x2>>::Output

fn _add(self, rhs: cplx32x2) -> Self::Output

fn _sub(self, rhs: cplx32x2) -> Self::Output

fn _mul(self, rhs: cplx32x2) -> Self::Output

fn _max(self, rhs: cplx32x2) -> Self::Output

fn _min(self, rhs: cplx32x2) -> Self::Output

fn _rem(self, rhs: cplx32x2) -> Self::Output

fn _clamp(self, min: cplx32x2, max: cplx32x2) -> Self::Output

fn _mul_add(self, a: cplx32x2, b: cplx32x2) -> Self::Output

impl NormalOut<cplx32x2> for u8

type Output = <u8x16 as NormalOutPromote<cplx32x2>>::Output

fn _mul_add(self, a: cplx32x2, b: cplx32x2) -> Self::Output

fn _add(self, rhs: cplx32x2) -> Self::Output

fn _sub(self, rhs: cplx32x2) -> Self::Output

fn _mul(self, rhs: cplx32x2) -> Self::Output

fn _rem(self, rhs: cplx32x2) -> Self::Output

fn _clamp(self, min: cplx32x2, max: cplx32x2) -> Self::Output

fn _max(self, rhs: cplx32x2) -> Self::Output

fn _min(self, rhs: cplx32x2) -> Self::Output

impl NormalOut<cplx32x2> for u16

type Output = <u16x8 as NormalOutPromote<cplx32x2>>::Output

fn _mul_add(self, a: cplx32x2, b: cplx32x2) -> Self::Output

fn _add(self, rhs: cplx32x2) -> Self::Output

fn _sub(self, rhs: cplx32x2) -> Self::Output

fn _mul(self, rhs: cplx32x2) -> Self::Output

fn _rem(self, rhs: cplx32x2) -> Self::Output

fn _clamp(self, min: cplx32x2, max: cplx32x2) -> Self::Output

fn _max(self, rhs: cplx32x2) -> Self::Output

fn _min(self, rhs: cplx32x2) -> Self::Output

impl NormalOut<cplx32x2> for u32

type Output = <u32x4 as NormalOutPromote<cplx32x2>>::Output

fn _mul_add(self, a: cplx32x2, b: cplx32x2) -> Self::Output

fn _add(self, rhs: cplx32x2) -> Self::Output

fn _sub(self, rhs: cplx32x2) -> Self::Output

fn _mul(self, rhs: cplx32x2) -> Self::Output

fn _rem(self, rhs: cplx32x2) -> Self::Output

fn _clamp(self, min: cplx32x2, max: cplx32x2) -> Self::Output

fn _max(self, rhs: cplx32x2) -> Self::Output

fn _min(self, rhs: cplx32x2) -> Self::Output

impl NormalOut<cplx32x2> for u64

type Output = <u64x2 as NormalOutPromote<cplx32x2>>::Output

fn _add(self, rhs: cplx32x2) -> Self::Output

fn _sub(self, rhs: cplx32x2) -> Self::Output

fn _mul(self, rhs: cplx32x2) -> Self::Output

fn _max(self, rhs: cplx32x2) -> Self::Output

fn _min(self, rhs: cplx32x2) -> Self::Output

fn _rem(self, rhs: cplx32x2) -> Self::Output

fn _clamp(self, min: cplx32x2, max: cplx32x2) -> Self::Output

fn _mul_add(self, a: cplx32x2, b: cplx32x2) -> Self::Output

impl NormalOut<cplx32x2> for usize

type Output = <usizex2 as NormalOutPromote<cplx32x2>>::Output

fn _add(self, rhs: cplx32x2) -> Self::Output

fn _sub(self, rhs: cplx32x2) -> Self::Output

fn _mul(self, rhs: cplx32x2) -> Self::Output

fn _max(self, rhs: cplx32x2) -> Self::Output

fn _min(self, rhs: cplx32x2) -> Self::Output

fn _rem(self, rhs: cplx32x2) -> Self::Output

fn _clamp(self, min: cplx32x2, max: cplx32x2) -> Self::Output

fn _mul_add(self, a: cplx32x2, b: cplx32x2) -> Self::Output

impl NormalOut<cplx32x2> for bf16

type Output = <bf16x8 as NormalOutPromote<cplx32x2>>::Output

fn _mul_add(self, a: cplx32x2, b: cplx32x2) -> Self::Output

fn _add(self, rhs: cplx32x2) -> Self::Output

fn _sub(self, rhs: cplx32x2) -> Self::Output

fn _mul(self, rhs: cplx32x2) -> Self::Output

fn _rem(self, rhs: cplx32x2) -> Self::Output

fn _clamp(self, min: cplx32x2, max: cplx32x2) -> Self::Output

fn _max(self, rhs: cplx32x2) -> Self::Output

fn _min(self, rhs: cplx32x2) -> Self::Output

impl NormalOut<cplx32x2> for f16

type Output = <f16x8 as NormalOutPromote<cplx32x2>>::Output

fn _mul_add(self, a: cplx32x2, b: cplx32x2) -> Self::Output

fn _add(self, rhs: cplx32x2) -> Self::Output

fn _sub(self, rhs: cplx32x2) -> Self::Output

fn _mul(self, rhs: cplx32x2) -> Self::Output

fn _rem(self, rhs: cplx32x2) -> Self::Output

fn _clamp(self, min: cplx32x2, max: cplx32x2) -> Self::Output

fn _max(self, rhs: cplx32x2) -> Self::Output

fn _min(self, rhs: cplx32x2) -> Self::Output

impl NormalOut<cplx32x2> for Complex32

type Output = <cplx32x2 as NormalOutPromote>::Output

fn _add(self, rhs: cplx32x2) -> Self::Output

fn _sub(self, rhs: cplx32x2) -> Self::Output

fn _mul(self, rhs: cplx32x2) -> Self::Output

fn _max(self, rhs: cplx32x2) -> Self::Output

fn _min(self, rhs: cplx32x2) -> Self::Output

fn _rem(self, rhs: cplx32x2) -> Self::Output

fn _clamp(self, min: cplx32x2, max: cplx32x2) -> Self::Output

fn _mul_add(self, a: cplx32x2, b: cplx32x2) -> Self::Output

impl NormalOut<cplx32x2> for Complex64

type Output = <cplx64x1 as NormalOutPromote<cplx32x2>>::Output

fn _mul_add(self, a: cplx32x2, b: cplx32x2) -> Self::Output

fn _add(self, rhs: cplx32x2) -> Self::Output

fn _sub(self, rhs: cplx32x2) -> Self::Output

fn _mul(self, rhs: cplx32x2) -> Self::Output

fn _rem(self, rhs: cplx32x2) -> Self::Output

fn _clamp(self, min: cplx32x2, max: cplx32x2) -> Self::Output

fn _max(self, rhs: cplx32x2) -> Self::Output

fn _min(self, rhs: cplx32x2) -> Self::Output

impl NormalOut<cplx64x1> for bool

type Output = <boolx16 as NormalOutPromote<cplx64x1>>::Output

fn _mul_add(self, a: cplx64x1, b: cplx64x1) -> Self::Output

fn _add(self, rhs: cplx64x1) -> Self::Output

fn _sub(self, rhs: cplx64x1) -> Self::Output

fn _mul(self, rhs: cplx64x1) -> Self::Output

fn _rem(self, rhs: cplx64x1) -> Self::Output

fn _clamp(self, min: cplx64x1, max: cplx64x1) -> Self::Output

fn _max(self, rhs: cplx64x1) -> Self::Output

fn _min(self, rhs: cplx64x1) -> Self::Output

impl NormalOut<cplx64x1> for f32

type Output = <f32x4 as NormalOutPromote<cplx64x1>>::Output

fn _mul_add(self, a: cplx64x1, b: cplx64x1) -> Self::Output

fn _add(self, rhs: cplx64x1) -> Self::Output

fn _sub(self, rhs: cplx64x1) -> Self::Output

fn _mul(self, rhs: cplx64x1) -> Self::Output

fn _rem(self, rhs: cplx64x1) -> Self::Output

fn _clamp(self, min: cplx64x1, max: cplx64x1) -> Self::Output

fn _max(self, rhs: cplx64x1) -> Self::Output

fn _min(self, rhs: cplx64x1) -> Self::Output

impl NormalOut<cplx64x1> for f64

type Output = <f64x2 as NormalOutPromote<cplx64x1>>::Output

fn _mul_add(self, a: cplx64x1, b: cplx64x1) -> Self::Output

fn _add(self, rhs: cplx64x1) -> Self::Output

fn _sub(self, rhs: cplx64x1) -> Self::Output

fn _mul(self, rhs: cplx64x1) -> Self::Output

fn _rem(self, rhs: cplx64x1) -> Self::Output

fn _clamp(self, min: cplx64x1, max: cplx64x1) -> Self::Output

fn _max(self, rhs: cplx64x1) -> Self::Output

fn _min(self, rhs: cplx64x1) -> Self::Output

impl NormalOut<cplx64x1> for i8

type Output = <i8x16 as NormalOutPromote<cplx64x1>>::Output

fn _mul_add(self, a: cplx64x1, b: cplx64x1) -> Self::Output

fn _add(self, rhs: cplx64x1) -> Self::Output

fn _sub(self, rhs: cplx64x1) -> Self::Output

fn _mul(self, rhs: cplx64x1) -> Self::Output

fn _rem(self, rhs: cplx64x1) -> Self::Output

fn _clamp(self, min: cplx64x1, max: cplx64x1) -> Self::Output

fn _max(self, rhs: cplx64x1) -> Self::Output

fn _min(self, rhs: cplx64x1) -> Self::Output

impl NormalOut<cplx64x1> for i16

type Output = <i16x8 as NormalOutPromote<cplx64x1>>::Output

fn _mul_add(self, a: cplx64x1, b: cplx64x1) -> Self::Output

fn _add(self, rhs: cplx64x1) -> Self::Output

fn _sub(self, rhs: cplx64x1) -> Self::Output

fn _mul(self, rhs: cplx64x1) -> Self::Output

fn _rem(self, rhs: cplx64x1) -> Self::Output

fn _clamp(self, min: cplx64x1, max: cplx64x1) -> Self::Output

fn _max(self, rhs: cplx64x1) -> Self::Output

fn _min(self, rhs: cplx64x1) -> Self::Output

impl NormalOut<cplx64x1> for i32

type Output = <i32x4 as NormalOutPromote<cplx64x1>>::Output

fn _mul_add(self, a: cplx64x1, b: cplx64x1) -> Self::Output

fn _add(self, rhs: cplx64x1) -> Self::Output

fn _sub(self, rhs: cplx64x1) -> Self::Output

fn _mul(self, rhs: cplx64x1) -> Self::Output

fn _rem(self, rhs: cplx64x1) -> Self::Output

fn _clamp(self, min: cplx64x1, max: cplx64x1) -> Self::Output

fn _max(self, rhs: cplx64x1) -> Self::Output

fn _min(self, rhs: cplx64x1) -> Self::Output

impl NormalOut<cplx64x1> for i64

type Output = <i64x2 as NormalOutPromote<cplx64x1>>::Output

fn _mul_add(self, a: cplx64x1, b: cplx64x1) -> Self::Output

fn _add(self, rhs: cplx64x1) -> Self::Output

fn _sub(self, rhs: cplx64x1) -> Self::Output

fn _mul(self, rhs: cplx64x1) -> Self::Output

fn _rem(self, rhs: cplx64x1) -> Self::Output

fn _clamp(self, min: cplx64x1, max: cplx64x1) -> Self::Output

fn _max(self, rhs: cplx64x1) -> Self::Output

fn _min(self, rhs: cplx64x1) -> Self::Output

impl NormalOut<cplx64x1> for isize

type Output = <isizex2 as NormalOutPromote<cplx64x1>>::Output

fn _mul_add(self, a: cplx64x1, b: cplx64x1) -> Self::Output

fn _add(self, rhs: cplx64x1) -> Self::Output

fn _sub(self, rhs: cplx64x1) -> Self::Output

fn _mul(self, rhs: cplx64x1) -> Self::Output

fn _rem(self, rhs: cplx64x1) -> Self::Output

fn _clamp(self, min: cplx64x1, max: cplx64x1) -> Self::Output

fn _max(self, rhs: cplx64x1) -> Self::Output

fn _min(self, rhs: cplx64x1) -> Self::Output

impl NormalOut<cplx64x1> for u8

type Output = <u8x16 as NormalOutPromote<cplx64x1>>::Output

fn _mul_add(self, a: cplx64x1, b: cplx64x1) -> Self::Output

fn _add(self, rhs: cplx64x1) -> Self::Output

fn _sub(self, rhs: cplx64x1) -> Self::Output

fn _mul(self, rhs: cplx64x1) -> Self::Output

fn _rem(self, rhs: cplx64x1) -> Self::Output

fn _clamp(self, min: cplx64x1, max: cplx64x1) -> Self::Output

fn _max(self, rhs: cplx64x1) -> Self::Output

fn _min(self, rhs: cplx64x1) -> Self::Output

impl NormalOut<cplx64x1> for u16

type Output = <u16x8 as NormalOutPromote<cplx64x1>>::Output

fn _mul_add(self, a: cplx64x1, b: cplx64x1) -> Self::Output

fn _add(self, rhs: cplx64x1) -> Self::Output

fn _sub(self, rhs: cplx64x1) -> Self::Output

fn _mul(self, rhs: cplx64x1) -> Self::Output

fn _rem(self, rhs: cplx64x1) -> Self::Output

fn _clamp(self, min: cplx64x1, max: cplx64x1) -> Self::Output

fn _max(self, rhs: cplx64x1) -> Self::Output

fn _min(self, rhs: cplx64x1) -> Self::Output

impl NormalOut<cplx64x1> for u32

type Output = <u32x4 as NormalOutPromote<cplx64x1>>::Output

fn _mul_add(self, a: cplx64x1, b: cplx64x1) -> Self::Output

fn _add(self, rhs: cplx64x1) -> Self::Output

fn _sub(self, rhs: cplx64x1) -> Self::Output

fn _mul(self, rhs: cplx64x1) -> Self::Output

fn _rem(self, rhs: cplx64x1) -> Self::Output

fn _clamp(self, min: cplx64x1, max: cplx64x1) -> Self::Output

fn _max(self, rhs: cplx64x1) -> Self::Output

fn _min(self, rhs: cplx64x1) -> Self::Output

impl NormalOut<cplx64x1> for u64

type Output = <u64x2 as NormalOutPromote<cplx64x1>>::Output

fn _mul_add(self, a: cplx64x1, b: cplx64x1) -> Self::Output

fn _add(self, rhs: cplx64x1) -> Self::Output

fn _sub(self, rhs: cplx64x1) -> Self::Output

fn _mul(self, rhs: cplx64x1) -> Self::Output

fn _rem(self, rhs: cplx64x1) -> Self::Output

fn _clamp(self, min: cplx64x1, max: cplx64x1) -> Self::Output

fn _max(self, rhs: cplx64x1) -> Self::Output

fn _min(self, rhs: cplx64x1) -> Self::Output

impl NormalOut<cplx64x1> for usize

type Output = <usizex2 as NormalOutPromote<cplx64x1>>::Output

fn _mul_add(self, a: cplx64x1, b: cplx64x1) -> Self::Output

fn _add(self, rhs: cplx64x1) -> Self::Output

fn _sub(self, rhs: cplx64x1) -> Self::Output

fn _mul(self, rhs: cplx64x1) -> Self::Output

fn _rem(self, rhs: cplx64x1) -> Self::Output

fn _clamp(self, min: cplx64x1, max: cplx64x1) -> Self::Output

fn _max(self, rhs: cplx64x1) -> Self::Output

fn _min(self, rhs: cplx64x1) -> Self::Output

impl NormalOut<cplx64x1> for bf16

type Output = <bf16x8 as NormalOutPromote<cplx64x1>>::Output

fn _mul_add(self, a: cplx64x1, b: cplx64x1) -> Self::Output

fn _add(self, rhs: cplx64x1) -> Self::Output

fn _sub(self, rhs: cplx64x1) -> Self::Output

fn _mul(self, rhs: cplx64x1) -> Self::Output

fn _rem(self, rhs: cplx64x1) -> Self::Output

fn _clamp(self, min: cplx64x1, max: cplx64x1) -> Self::Output

fn _max(self, rhs: cplx64x1) -> Self::Output

fn _min(self, rhs: cplx64x1) -> Self::Output

impl NormalOut<cplx64x1> for f16

type Output = <f16x8 as NormalOutPromote<cplx64x1>>::Output

fn _mul_add(self, a: cplx64x1, b: cplx64x1) -> Self::Output

fn _add(self, rhs: cplx64x1) -> Self::Output

fn _sub(self, rhs: cplx64x1) -> Self::Output

fn _mul(self, rhs: cplx64x1) -> Self::Output

fn _rem(self, rhs: cplx64x1) -> Self::Output

fn _clamp(self, min: cplx64x1, max: cplx64x1) -> Self::Output

fn _max(self, rhs: cplx64x1) -> Self::Output

fn _min(self, rhs: cplx64x1) -> Self::Output

impl NormalOut<cplx64x1> for Complex32

type Output = <cplx32x2 as NormalOutPromote<cplx64x1>>::Output

fn _mul_add(self, a: cplx64x1, b: cplx64x1) -> Self::Output

fn _add(self, rhs: cplx64x1) -> Self::Output

fn _sub(self, rhs: cplx64x1) -> Self::Output

fn _mul(self, rhs: cplx64x1) -> Self::Output

fn _rem(self, rhs: cplx64x1) -> Self::Output

fn _clamp(self, min: cplx64x1, max: cplx64x1) -> Self::Output

fn _max(self, rhs: cplx64x1) -> Self::Output

fn _min(self, rhs: cplx64x1) -> Self::Output

impl NormalOut<cplx64x1> for Complex64

type Output = <cplx64x1 as NormalOutPromote>::Output

fn _add(self, rhs: cplx64x1) -> Self::Output

fn _sub(self, rhs: cplx64x1) -> Self::Output

fn _mul(self, rhs: cplx64x1) -> Self::Output

fn _max(self, rhs: cplx64x1) -> Self::Output

fn _min(self, rhs: cplx64x1) -> Self::Output

fn _rem(self, rhs: cplx64x1) -> Self::Output

fn _clamp(self, min: cplx64x1, max: cplx64x1) -> Self::Output

fn _mul_add(self, a: cplx64x1, b: cplx64x1) -> Self::Output

impl NormalOut<f16x8> for bool

type Output = <boolx16 as NormalOutPromote<f16x8>>::Output

fn _mul_add(self, a: f16x8, b: f16x8) -> Self::Output

fn _add(self, rhs: f16x8) -> Self::Output

fn _sub(self, rhs: f16x8) -> Self::Output

fn _mul(self, rhs: f16x8) -> Self::Output

fn _rem(self, rhs: f16x8) -> Self::Output

fn _clamp(self, min: f16x8, max: f16x8) -> Self::Output

fn _max(self, rhs: f16x8) -> Self::Output

fn _min(self, rhs: f16x8) -> Self::Output

impl NormalOut<f16x8> for f32

type Output = <f32x4 as NormalOutPromote<f16x8>>::Output

fn _mul_add(self, a: f16x8, b: f16x8) -> Self::Output

fn _add(self, rhs: f16x8) -> Self::Output

fn _sub(self, rhs: f16x8) -> Self::Output

fn _mul(self, rhs: f16x8) -> Self::Output

fn _rem(self, rhs: f16x8) -> Self::Output

fn _clamp(self, min: f16x8, max: f16x8) -> Self::Output

fn _max(self, rhs: f16x8) -> Self::Output

fn _min(self, rhs: f16x8) -> Self::Output

impl NormalOut<f16x8> for f64

type Output = <f64x2 as NormalOutPromote<f16x8>>::Output

fn _mul_add(self, a: f16x8, b: f16x8) -> Self::Output

fn _add(self, rhs: f16x8) -> Self::Output

fn _sub(self, rhs: f16x8) -> Self::Output

fn _mul(self, rhs: f16x8) -> Self::Output

fn _rem(self, rhs: f16x8) -> Self::Output

fn _clamp(self, min: f16x8, max: f16x8) -> Self::Output

fn _max(self, rhs: f16x8) -> Self::Output

fn _min(self, rhs: f16x8) -> Self::Output

impl NormalOut<f16x8> for i8

type Output = <i8x16 as NormalOutPromote<f16x8>>::Output

fn _mul_add(self, a: f16x8, b: f16x8) -> Self::Output

fn _add(self, rhs: f16x8) -> Self::Output

fn _sub(self, rhs: f16x8) -> Self::Output

fn _mul(self, rhs: f16x8) -> Self::Output

fn _rem(self, rhs: f16x8) -> Self::Output

fn _clamp(self, min: f16x8, max: f16x8) -> Self::Output

fn _max(self, rhs: f16x8) -> Self::Output

fn _min(self, rhs: f16x8) -> Self::Output

impl NormalOut<f16x8> for i16

type Output = <i16x8 as NormalOutPromote<f16x8>>::Output

fn _add(self, rhs: f16x8) -> Self::Output

fn _sub(self, rhs: f16x8) -> Self::Output

fn _mul(self, rhs: f16x8) -> Self::Output

fn _max(self, rhs: f16x8) -> Self::Output

fn _min(self, rhs: f16x8) -> Self::Output

fn _rem(self, rhs: f16x8) -> Self::Output

fn _clamp(self, min: f16x8, max: f16x8) -> Self::Output

fn _mul_add(self, a: f16x8, b: f16x8) -> Self::Output

impl NormalOut<f16x8> for i32

type Output = <i32x4 as NormalOutPromote<f16x8>>::Output

fn _mul_add(self, a: f16x8, b: f16x8) -> Self::Output

fn _add(self, rhs: f16x8) -> Self::Output

fn _sub(self, rhs: f16x8) -> Self::Output

fn _mul(self, rhs: f16x8) -> Self::Output

fn _rem(self, rhs: f16x8) -> Self::Output

fn _clamp(self, min: f16x8, max: f16x8) -> Self::Output

fn _max(self, rhs: f16x8) -> Self::Output

fn _min(self, rhs: f16x8) -> Self::Output

impl NormalOut<f16x8> for i64

type Output = <i64x2 as NormalOutPromote<f16x8>>::Output

fn _mul_add(self, a: f16x8, b: f16x8) -> Self::Output

fn _add(self, rhs: f16x8) -> Self::Output

fn _sub(self, rhs: f16x8) -> Self::Output

fn _mul(self, rhs: f16x8) -> Self::Output

fn _rem(self, rhs: f16x8) -> Self::Output

fn _clamp(self, min: f16x8, max: f16x8) -> Self::Output

fn _max(self, rhs: f16x8) -> Self::Output

fn _min(self, rhs: f16x8) -> Self::Output

impl NormalOut<f16x8> for isize

type Output = <isizex2 as NormalOutPromote<f16x8>>::Output

fn _mul_add(self, a: f16x8, b: f16x8) -> Self::Output

fn _add(self, rhs: f16x8) -> Self::Output

fn _sub(self, rhs: f16x8) -> Self::Output

fn _mul(self, rhs: f16x8) -> Self::Output

fn _rem(self, rhs: f16x8) -> Self::Output

fn _clamp(self, min: f16x8, max: f16x8) -> Self::Output

fn _max(self, rhs: f16x8) -> Self::Output

fn _min(self, rhs: f16x8) -> Self::Output

impl NormalOut<f16x8> for u8

type Output = <u8x16 as NormalOutPromote<f16x8>>::Output

fn _mul_add(self, a: f16x8, b: f16x8) -> Self::Output

fn _add(self, rhs: f16x8) -> Self::Output

fn _sub(self, rhs: f16x8) -> Self::Output

fn _mul(self, rhs: f16x8) -> Self::Output

fn _rem(self, rhs: f16x8) -> Self::Output

fn _clamp(self, min: f16x8, max: f16x8) -> Self::Output

fn _max(self, rhs: f16x8) -> Self::Output

fn _min(self, rhs: f16x8) -> Self::Output

impl NormalOut<f16x8> for u16

type Output = <u16x8 as NormalOutPromote<f16x8>>::Output

fn _add(self, rhs: f16x8) -> Self::Output

fn _sub(self, rhs: f16x8) -> Self::Output

fn _mul(self, rhs: f16x8) -> Self::Output

fn _max(self, rhs: f16x8) -> Self::Output

fn _min(self, rhs: f16x8) -> Self::Output

fn _rem(self, rhs: f16x8) -> Self::Output

fn _clamp(self, min: f16x8, max: f16x8) -> Self::Output

fn _mul_add(self, a: f16x8, b: f16x8) -> Self::Output

impl NormalOut<f16x8> for u32

type Output = <u32x4 as NormalOutPromote<f16x8>>::Output

fn _mul_add(self, a: f16x8, b: f16x8) -> Self::Output

fn _add(self, rhs: f16x8) -> Self::Output

fn _sub(self, rhs: f16x8) -> Self::Output

fn _mul(self, rhs: f16x8) -> Self::Output

fn _rem(self, rhs: f16x8) -> Self::Output

fn _clamp(self, min: f16x8, max: f16x8) -> Self::Output

fn _max(self, rhs: f16x8) -> Self::Output

fn _min(self, rhs: f16x8) -> Self::Output

impl NormalOut<f16x8> for u64

type Output = <u64x2 as NormalOutPromote<f16x8>>::Output

fn _mul_add(self, a: f16x8, b: f16x8) -> Self::Output

fn _add(self, rhs: f16x8) -> Self::Output

fn _sub(self, rhs: f16x8) -> Self::Output

fn _mul(self, rhs: f16x8) -> Self::Output

fn _rem(self, rhs: f16x8) -> Self::Output

fn _clamp(self, min: f16x8, max: f16x8) -> Self::Output

fn _max(self, rhs: f16x8) -> Self::Output

fn _min(self, rhs: f16x8) -> Self::Output

impl NormalOut<f16x8> for usize

type Output = <usizex2 as NormalOutPromote<f16x8>>::Output

fn _mul_add(self, a: f16x8, b: f16x8) -> Self::Output

fn _add(self, rhs: f16x8) -> Self::Output

fn _sub(self, rhs: f16x8) -> Self::Output

fn _mul(self, rhs: f16x8) -> Self::Output

fn _rem(self, rhs: f16x8) -> Self::Output

fn _clamp(self, min: f16x8, max: f16x8) -> Self::Output

fn _max(self, rhs: f16x8) -> Self::Output

fn _min(self, rhs: f16x8) -> Self::Output

impl NormalOut<f16x8> for bf16

type Output = <bf16x8 as NormalOutPromote<f16x8>>::Output

fn _add(self, rhs: f16x8) -> Self::Output

fn _sub(self, rhs: f16x8) -> Self::Output

fn _mul(self, rhs: f16x8) -> Self::Output

fn _max(self, rhs: f16x8) -> Self::Output

fn _min(self, rhs: f16x8) -> Self::Output

fn _rem(self, rhs: f16x8) -> Self::Output

fn _clamp(self, min: f16x8, max: f16x8) -> Self::Output

fn _mul_add(self, a: f16x8, b: f16x8) -> Self::Output

impl NormalOut<f16x8> for f16

type Output = <f16x8 as NormalOutPromote>::Output

fn _add(self, rhs: f16x8) -> Self::Output

fn _sub(self, rhs: f16x8) -> Self::Output

fn _mul(self, rhs: f16x8) -> Self::Output

fn _max(self, rhs: f16x8) -> Self::Output

fn _min(self, rhs: f16x8) -> Self::Output

fn _rem(self, rhs: f16x8) -> Self::Output

fn _clamp(self, min: f16x8, max: f16x8) -> Self::Output

fn _mul_add(self, a: f16x8, b: f16x8) -> Self::Output

impl NormalOut<f16x8> for Complex32

type Output = <cplx32x2 as NormalOutPromote<f16x8>>::Output

fn _mul_add(self, a: f16x8, b: f16x8) -> Self::Output

fn _add(self, rhs: f16x8) -> Self::Output

fn _sub(self, rhs: f16x8) -> Self::Output

fn _mul(self, rhs: f16x8) -> Self::Output

fn _rem(self, rhs: f16x8) -> Self::Output

fn _clamp(self, min: f16x8, max: f16x8) -> Self::Output

fn _max(self, rhs: f16x8) -> Self::Output

fn _min(self, rhs: f16x8) -> Self::Output

impl NormalOut<f16x8> for Complex64

type Output = <cplx64x1 as NormalOutPromote<f16x8>>::Output

fn _mul_add(self, a: f16x8, b: f16x8) -> Self::Output

fn _add(self, rhs: f16x8) -> Self::Output

fn _sub(self, rhs: f16x8) -> Self::Output

fn _mul(self, rhs: f16x8) -> Self::Output

fn _rem(self, rhs: f16x8) -> Self::Output

fn _clamp(self, min: f16x8, max: f16x8) -> Self::Output

fn _max(self, rhs: f16x8) -> Self::Output

fn _min(self, rhs: f16x8) -> Self::Output

impl NormalOut<f32x4> for bool

type Output = <boolx16 as NormalOutPromote<f32x4>>::Output

fn _mul_add(self, a: f32x4, b: f32x4) -> Self::Output

fn _add(self, rhs: f32x4) -> Self::Output

fn _sub(self, rhs: f32x4) -> Self::Output

fn _mul(self, rhs: f32x4) -> Self::Output

fn _rem(self, rhs: f32x4) -> Self::Output

fn _clamp(self, min: f32x4, max: f32x4) -> Self::Output

fn _max(self, rhs: f32x4) -> Self::Output

fn _min(self, rhs: f32x4) -> Self::Output

impl NormalOut<f32x4> for f32

type Output = <f32x4 as NormalOutPromote>::Output

fn _add(self, rhs: f32x4) -> Self::Output

fn _sub(self, rhs: f32x4) -> Self::Output

fn _mul(self, rhs: f32x4) -> Self::Output

fn _max(self, rhs: f32x4) -> Self::Output

fn _min(self, rhs: f32x4) -> Self::Output

fn _rem(self, rhs: f32x4) -> Self::Output

fn _clamp(self, min: f32x4, max: f32x4) -> Self::Output

fn _mul_add(self, a: f32x4, b: f32x4) -> Self::Output

impl NormalOut<f32x4> for f64

type Output = <f64x2 as NormalOutPromote<f32x4>>::Output

fn _mul_add(self, a: f32x4, b: f32x4) -> Self::Output

fn _add(self, rhs: f32x4) -> Self::Output

fn _sub(self, rhs: f32x4) -> Self::Output

fn _mul(self, rhs: f32x4) -> Self::Output

fn _rem(self, rhs: f32x4) -> Self::Output

fn _clamp(self, min: f32x4, max: f32x4) -> Self::Output

fn _max(self, rhs: f32x4) -> Self::Output

fn _min(self, rhs: f32x4) -> Self::Output

impl NormalOut<f32x4> for i8

type Output = <i8x16 as NormalOutPromote<f32x4>>::Output

fn _mul_add(self, a: f32x4, b: f32x4) -> Self::Output

fn _add(self, rhs: f32x4) -> Self::Output

fn _sub(self, rhs: f32x4) -> Self::Output

fn _mul(self, rhs: f32x4) -> Self::Output

fn _rem(self, rhs: f32x4) -> Self::Output

fn _clamp(self, min: f32x4, max: f32x4) -> Self::Output

fn _max(self, rhs: f32x4) -> Self::Output

fn _min(self, rhs: f32x4) -> Self::Output

impl NormalOut<f32x4> for i16

type Output = <i16x8 as NormalOutPromote<f32x4>>::Output

fn _mul_add(self, a: f32x4, b: f32x4) -> Self::Output

fn _add(self, rhs: f32x4) -> Self::Output

fn _sub(self, rhs: f32x4) -> Self::Output

fn _mul(self, rhs: f32x4) -> Self::Output

fn _rem(self, rhs: f32x4) -> Self::Output

fn _clamp(self, min: f32x4, max: f32x4) -> Self::Output

fn _max(self, rhs: f32x4) -> Self::Output

fn _min(self, rhs: f32x4) -> Self::Output

impl NormalOut<f32x4> for i32

type Output = <i32x4 as NormalOutPromote<f32x4>>::Output

fn _add(self, rhs: f32x4) -> Self::Output

fn _sub(self, rhs: f32x4) -> Self::Output

fn _mul(self, rhs: f32x4) -> Self::Output

fn _max(self, rhs: f32x4) -> Self::Output

fn _min(self, rhs: f32x4) -> Self::Output

fn _rem(self, rhs: f32x4) -> Self::Output

fn _clamp(self, min: f32x4, max: f32x4) -> Self::Output

fn _mul_add(self, a: f32x4, b: f32x4) -> Self::Output

impl NormalOut<f32x4> for i64

type Output = <i64x2 as NormalOutPromote<f32x4>>::Output

fn _mul_add(self, a: f32x4, b: f32x4) -> Self::Output

fn _add(self, rhs: f32x4) -> Self::Output

fn _sub(self, rhs: f32x4) -> Self::Output

fn _mul(self, rhs: f32x4) -> Self::Output

fn _rem(self, rhs: f32x4) -> Self::Output

fn _clamp(self, min: f32x4, max: f32x4) -> Self::Output

fn _max(self, rhs: f32x4) -> Self::Output

fn _min(self, rhs: f32x4) -> Self::Output

impl NormalOut<f32x4> for isize

type Output = <isizex2 as NormalOutPromote<f32x4>>::Output

fn _mul_add(self, a: f32x4, b: f32x4) -> Self::Output

fn _add(self, rhs: f32x4) -> Self::Output

fn _sub(self, rhs: f32x4) -> Self::Output

fn _mul(self, rhs: f32x4) -> Self::Output

fn _rem(self, rhs: f32x4) -> Self::Output

fn _clamp(self, min: f32x4, max: f32x4) -> Self::Output

fn _max(self, rhs: f32x4) -> Self::Output

fn _min(self, rhs: f32x4) -> Self::Output

impl NormalOut<f32x4> for u8

type Output = <u8x16 as NormalOutPromote<f32x4>>::Output

fn _mul_add(self, a: f32x4, b: f32x4) -> Self::Output

fn _add(self, rhs: f32x4) -> Self::Output

fn _sub(self, rhs: f32x4) -> Self::Output

fn _mul(self, rhs: f32x4) -> Self::Output

fn _rem(self, rhs: f32x4) -> Self::Output

fn _clamp(self, min: f32x4, max: f32x4) -> Self::Output

fn _max(self, rhs: f32x4) -> Self::Output

fn _min(self, rhs: f32x4) -> Self::Output

impl NormalOut<f32x4> for u16

type Output = <u16x8 as NormalOutPromote<f32x4>>::Output

fn _mul_add(self, a: f32x4, b: f32x4) -> Self::Output

fn _add(self, rhs: f32x4) -> Self::Output

fn _sub(self, rhs: f32x4) -> Self::Output

fn _mul(self, rhs: f32x4) -> Self::Output

fn _rem(self, rhs: f32x4) -> Self::Output

fn _clamp(self, min: f32x4, max: f32x4) -> Self::Output

fn _max(self, rhs: f32x4) -> Self::Output

fn _min(self, rhs: f32x4) -> Self::Output

impl NormalOut<f32x4> for u32

type Output = <u32x4 as NormalOutPromote<f32x4>>::Output

fn _add(self, rhs: f32x4) -> Self::Output

fn _sub(self, rhs: f32x4) -> Self::Output

fn _mul(self, rhs: f32x4) -> Self::Output

fn _max(self, rhs: f32x4) -> Self::Output

fn _min(self, rhs: f32x4) -> Self::Output

fn _rem(self, rhs: f32x4) -> Self::Output

fn _clamp(self, min: f32x4, max: f32x4) -> Self::Output

fn _mul_add(self, a: f32x4, b: f32x4) -> Self::Output

impl NormalOut<f32x4> for u64

type Output = <u64x2 as NormalOutPromote<f32x4>>::Output

fn _mul_add(self, a: f32x4, b: f32x4) -> Self::Output

fn _add(self, rhs: f32x4) -> Self::Output

fn _sub(self, rhs: f32x4) -> Self::Output

fn _mul(self, rhs: f32x4) -> Self::Output

fn _rem(self, rhs: f32x4) -> Self::Output

fn _clamp(self, min: f32x4, max: f32x4) -> Self::Output

fn _max(self, rhs: f32x4) -> Self::Output

fn _min(self, rhs: f32x4) -> Self::Output

impl NormalOut<f32x4> for usize

type Output = <usizex2 as NormalOutPromote<f32x4>>::Output

fn _mul_add(self, a: f32x4, b: f32x4) -> Self::Output

fn _add(self, rhs: f32x4) -> Self::Output

fn _sub(self, rhs: f32x4) -> Self::Output

fn _mul(self, rhs: f32x4) -> Self::Output

fn _rem(self, rhs: f32x4) -> Self::Output

fn _clamp(self, min: f32x4, max: f32x4) -> Self::Output

fn _max(self, rhs: f32x4) -> Self::Output

fn _min(self, rhs: f32x4) -> Self::Output

impl NormalOut<f32x4> for bf16

type Output = <bf16x8 as NormalOutPromote<f32x4>>::Output

fn _mul_add(self, a: f32x4, b: f32x4) -> Self::Output

fn _add(self, rhs: f32x4) -> Self::Output

fn _sub(self, rhs: f32x4) -> Self::Output

fn _mul(self, rhs: f32x4) -> Self::Output

fn _rem(self, rhs: f32x4) -> Self::Output

fn _clamp(self, min: f32x4, max: f32x4) -> Self::Output

fn _max(self, rhs: f32x4) -> Self::Output

fn _min(self, rhs: f32x4) -> Self::Output

impl NormalOut<f32x4> for f16

type Output = <f16x8 as NormalOutPromote<f32x4>>::Output

fn _mul_add(self, a: f32x4, b: f32x4) -> Self::Output

fn _add(self, rhs: f32x4) -> Self::Output

fn _sub(self, rhs: f32x4) -> Self::Output

fn _mul(self, rhs: f32x4) -> Self::Output

fn _rem(self, rhs: f32x4) -> Self::Output

fn _clamp(self, min: f32x4, max: f32x4) -> Self::Output

fn _max(self, rhs: f32x4) -> Self::Output

fn _min(self, rhs: f32x4) -> Self::Output

impl NormalOut<f32x4> for Complex32

type Output = <cplx32x2 as NormalOutPromote<f32x4>>::Output

fn _mul_add(self, a: f32x4, b: f32x4) -> Self::Output

fn _add(self, rhs: f32x4) -> Self::Output

fn _sub(self, rhs: f32x4) -> Self::Output

fn _mul(self, rhs: f32x4) -> Self::Output

fn _rem(self, rhs: f32x4) -> Self::Output

fn _clamp(self, min: f32x4, max: f32x4) -> Self::Output

fn _max(self, rhs: f32x4) -> Self::Output

fn _min(self, rhs: f32x4) -> Self::Output

impl NormalOut<f32x4> for Complex64

type Output = <cplx64x1 as NormalOutPromote<f32x4>>::Output

fn _mul_add(self, a: f32x4, b: f32x4) -> Self::Output

fn _add(self, rhs: f32x4) -> Self::Output

fn _sub(self, rhs: f32x4) -> Self::Output

fn _mul(self, rhs: f32x4) -> Self::Output

fn _rem(self, rhs: f32x4) -> Self::Output

fn _clamp(self, min: f32x4, max: f32x4) -> Self::Output

fn _max(self, rhs: f32x4) -> Self::Output

fn _min(self, rhs: f32x4) -> Self::Output

impl NormalOut<f64x2> for bool

type Output = <boolx16 as NormalOutPromote<f64x2>>::Output

fn _mul_add(self, a: f64x2, b: f64x2) -> Self::Output

fn _add(self, rhs: f64x2) -> Self::Output

fn _sub(self, rhs: f64x2) -> Self::Output

fn _mul(self, rhs: f64x2) -> Self::Output

fn _rem(self, rhs: f64x2) -> Self::Output

fn _clamp(self, min: f64x2, max: f64x2) -> Self::Output

fn _max(self, rhs: f64x2) -> Self::Output

fn _min(self, rhs: f64x2) -> Self::Output

impl NormalOut<f64x2> for f32

type Output = <f32x4 as NormalOutPromote<f64x2>>::Output

fn _mul_add(self, a: f64x2, b: f64x2) -> Self::Output

fn _add(self, rhs: f64x2) -> Self::Output

fn _sub(self, rhs: f64x2) -> Self::Output

fn _mul(self, rhs: f64x2) -> Self::Output

fn _rem(self, rhs: f64x2) -> Self::Output

fn _clamp(self, min: f64x2, max: f64x2) -> Self::Output

fn _max(self, rhs: f64x2) -> Self::Output

fn _min(self, rhs: f64x2) -> Self::Output

impl NormalOut<f64x2> for f64

type Output = <f64x2 as NormalOutPromote>::Output

fn _add(self, rhs: f64x2) -> Self::Output

fn _sub(self, rhs: f64x2) -> Self::Output

fn _mul(self, rhs: f64x2) -> Self::Output

fn _max(self, rhs: f64x2) -> Self::Output

fn _min(self, rhs: f64x2) -> Self::Output

fn _rem(self, rhs: f64x2) -> Self::Output

fn _clamp(self, min: f64x2, max: f64x2) -> Self::Output

fn _mul_add(self, a: f64x2, b: f64x2) -> Self::Output

impl NormalOut<f64x2> for i8

type Output = <i8x16 as NormalOutPromote<f64x2>>::Output

fn _mul_add(self, a: f64x2, b: f64x2) -> Self::Output

fn _add(self, rhs: f64x2) -> Self::Output

fn _sub(self, rhs: f64x2) -> Self::Output

fn _mul(self, rhs: f64x2) -> Self::Output

fn _rem(self, rhs: f64x2) -> Self::Output

fn _clamp(self, min: f64x2, max: f64x2) -> Self::Output

fn _max(self, rhs: f64x2) -> Self::Output

fn _min(self, rhs: f64x2) -> Self::Output

impl NormalOut<f64x2> for i16

type Output = <i16x8 as NormalOutPromote<f64x2>>::Output

fn _mul_add(self, a: f64x2, b: f64x2) -> Self::Output

fn _add(self, rhs: f64x2) -> Self::Output

fn _sub(self, rhs: f64x2) -> Self::Output

fn _mul(self, rhs: f64x2) -> Self::Output

fn _rem(self, rhs: f64x2) -> Self::Output

fn _clamp(self, min: f64x2, max: f64x2) -> Self::Output

fn _max(self, rhs: f64x2) -> Self::Output

fn _min(self, rhs: f64x2) -> Self::Output

impl NormalOut<f64x2> for i32

type Output = <i32x4 as NormalOutPromote<f64x2>>::Output

fn _mul_add(self, a: f64x2, b: f64x2) -> Self::Output

fn _add(self, rhs: f64x2) -> Self::Output

fn _sub(self, rhs: f64x2) -> Self::Output

fn _mul(self, rhs: f64x2) -> Self::Output

fn _rem(self, rhs: f64x2) -> Self::Output

fn _clamp(self, min: f64x2, max: f64x2) -> Self::Output

fn _max(self, rhs: f64x2) -> Self::Output

fn _min(self, rhs: f64x2) -> Self::Output

impl NormalOut<f64x2> for i64

type Output = <i64x2 as NormalOutPromote<f64x2>>::Output

fn _add(self, rhs: f64x2) -> Self::Output

fn _sub(self, rhs: f64x2) -> Self::Output

fn _mul(self, rhs: f64x2) -> Self::Output

fn _max(self, rhs: f64x2) -> Self::Output

fn _min(self, rhs: f64x2) -> Self::Output

fn _rem(self, rhs: f64x2) -> Self::Output

fn _clamp(self, min: f64x2, max: f64x2) -> Self::Output

fn _mul_add(self, a: f64x2, b: f64x2) -> Self::Output

impl NormalOut<f64x2> for isize

type Output = <isizex2 as NormalOutPromote<f64x2>>::Output

fn _add(self, rhs: f64x2) -> Self::Output

fn _sub(self, rhs: f64x2) -> Self::Output

fn _mul(self, rhs: f64x2) -> Self::Output

fn _max(self, rhs: f64x2) -> Self::Output

fn _min(self, rhs: f64x2) -> Self::Output

fn _rem(self, rhs: f64x2) -> Self::Output

fn _clamp(self, min: f64x2, max: f64x2) -> Self::Output

fn _mul_add(self, a: f64x2, b: f64x2) -> Self::Output

impl NormalOut<f64x2> for u8

type Output = <u8x16 as NormalOutPromote<f64x2>>::Output

fn _mul_add(self, a: f64x2, b: f64x2) -> Self::Output

fn _add(self, rhs: f64x2) -> Self::Output

fn _sub(self, rhs: f64x2) -> Self::Output

fn _mul(self, rhs: f64x2) -> Self::Output

fn _rem(self, rhs: f64x2) -> Self::Output

fn _clamp(self, min: f64x2, max: f64x2) -> Self::Output

fn _max(self, rhs: f64x2) -> Self::Output

fn _min(self, rhs: f64x2) -> Self::Output

impl NormalOut<f64x2> for u16

type Output = <u16x8 as NormalOutPromote<f64x2>>::Output

fn _mul_add(self, a: f64x2, b: f64x2) -> Self::Output

fn _add(self, rhs: f64x2) -> Self::Output

fn _sub(self, rhs: f64x2) -> Self::Output

fn _mul(self, rhs: f64x2) -> Self::Output

fn _rem(self, rhs: f64x2) -> Self::Output

fn _clamp(self, min: f64x2, max: f64x2) -> Self::Output

fn _max(self, rhs: f64x2) -> Self::Output

fn _min(self, rhs: f64x2) -> Self::Output

impl NormalOut<f64x2> for u32

type Output = <u32x4 as NormalOutPromote<f64x2>>::Output

fn _mul_add(self, a: f64x2, b: f64x2) -> Self::Output

fn _add(self, rhs: f64x2) -> Self::Output

fn _sub(self, rhs: f64x2) -> Self::Output

fn _mul(self, rhs: f64x2) -> Self::Output

fn _rem(self, rhs: f64x2) -> Self::Output

fn _clamp(self, min: f64x2, max: f64x2) -> Self::Output

fn _max(self, rhs: f64x2) -> Self::Output

fn _min(self, rhs: f64x2) -> Self::Output

impl NormalOut<f64x2> for u64

type Output = <u64x2 as NormalOutPromote<f64x2>>::Output

fn _add(self, rhs: f64x2) -> Self::Output

fn _sub(self, rhs: f64x2) -> Self::Output

fn _mul(self, rhs: f64x2) -> Self::Output

fn _max(self, rhs: f64x2) -> Self::Output

fn _min(self, rhs: f64x2) -> Self::Output

fn _rem(self, rhs: f64x2) -> Self::Output

fn _clamp(self, min: f64x2, max: f64x2) -> Self::Output

fn _mul_add(self, a: f64x2, b: f64x2) -> Self::Output

impl NormalOut<f64x2> for usize

type Output = <usizex2 as NormalOutPromote<f64x2>>::Output

fn _add(self, rhs: f64x2) -> Self::Output

fn _sub(self, rhs: f64x2) -> Self::Output

fn _mul(self, rhs: f64x2) -> Self::Output

fn _max(self, rhs: f64x2) -> Self::Output

fn _min(self, rhs: f64x2) -> Self::Output

fn _rem(self, rhs: f64x2) -> Self::Output

fn _clamp(self, min: f64x2, max: f64x2) -> Self::Output

fn _mul_add(self, a: f64x2, b: f64x2) -> Self::Output

impl NormalOut<f64x2> for bf16

type Output = <bf16x8 as NormalOutPromote<f64x2>>::Output

fn _mul_add(self, a: f64x2, b: f64x2) -> Self::Output

fn _add(self, rhs: f64x2) -> Self::Output

fn _sub(self, rhs: f64x2) -> Self::Output

fn _mul(self, rhs: f64x2) -> Self::Output

fn _rem(self, rhs: f64x2) -> Self::Output

fn _clamp(self, min: f64x2, max: f64x2) -> Self::Output

fn _max(self, rhs: f64x2) -> Self::Output

fn _min(self, rhs: f64x2) -> Self::Output

impl NormalOut<f64x2> for f16

type Output = <f16x8 as NormalOutPromote<f64x2>>::Output

fn _mul_add(self, a: f64x2, b: f64x2) -> Self::Output

fn _add(self, rhs: f64x2) -> Self::Output

fn _sub(self, rhs: f64x2) -> Self::Output

fn _mul(self, rhs: f64x2) -> Self::Output

fn _rem(self, rhs: f64x2) -> Self::Output

fn _clamp(self, min: f64x2, max: f64x2) -> Self::Output

fn _max(self, rhs: f64x2) -> Self::Output

fn _min(self, rhs: f64x2) -> Self::Output

impl NormalOut<f64x2> for Complex32

type Output = <cplx32x2 as NormalOutPromote<f64x2>>::Output

fn _add(self, rhs: f64x2) -> Self::Output

fn _sub(self, rhs: f64x2) -> Self::Output

fn _mul(self, rhs: f64x2) -> Self::Output

fn _max(self, rhs: f64x2) -> Self::Output

fn _min(self, rhs: f64x2) -> Self::Output

fn _rem(self, rhs: f64x2) -> Self::Output

fn _clamp(self, min: f64x2, max: f64x2) -> Self::Output

fn _mul_add(self, a: f64x2, b: f64x2) -> Self::Output

impl NormalOut<f64x2> for Complex64

type Output = <cplx64x1 as NormalOutPromote<f64x2>>::Output

fn _mul_add(self, a: f64x2, b: f64x2) -> Self::Output

fn _add(self, rhs: f64x2) -> Self::Output

fn _sub(self, rhs: f64x2) -> Self::Output

fn _mul(self, rhs: f64x2) -> Self::Output

fn _rem(self, rhs: f64x2) -> Self::Output

fn _clamp(self, min: f64x2, max: f64x2) -> Self::Output

fn _max(self, rhs: f64x2) -> Self::Output

fn _min(self, rhs: f64x2) -> Self::Output

impl NormalOut<i8x16> for bool

type Output = <boolx16 as NormalOutPromote<i8x16>>::Output

fn _add(self, rhs: i8x16) -> Self::Output

fn _sub(self, rhs: i8x16) -> Self::Output

fn _mul(self, rhs: i8x16) -> Self::Output

fn _max(self, rhs: i8x16) -> Self::Output

fn _min(self, rhs: i8x16) -> Self::Output

fn _rem(self, rhs: i8x16) -> Self::Output

fn _clamp(self, min: i8x16, max: i8x16) -> Self::Output

fn _mul_add(self, a: i8x16, b: i8x16) -> Self::Output

impl NormalOut<i8x16> for f32

type Output = <f32x4 as NormalOutPromote<i8x16>>::Output

fn _mul_add(self, a: i8x16, b: i8x16) -> Self::Output

fn _add(self, rhs: i8x16) -> Self::Output

fn _sub(self, rhs: i8x16) -> Self::Output

fn _mul(self, rhs: i8x16) -> Self::Output

fn _rem(self, rhs: i8x16) -> Self::Output

fn _clamp(self, min: i8x16, max: i8x16) -> Self::Output

fn _max(self, rhs: i8x16) -> Self::Output

fn _min(self, rhs: i8x16) -> Self::Output

impl NormalOut<i8x16> for f64

type Output = <f64x2 as NormalOutPromote<i8x16>>::Output

fn _mul_add(self, a: i8x16, b: i8x16) -> Self::Output

fn _add(self, rhs: i8x16) -> Self::Output

fn _sub(self, rhs: i8x16) -> Self::Output

fn _mul(self, rhs: i8x16) -> Self::Output

fn _rem(self, rhs: i8x16) -> Self::Output

fn _clamp(self, min: i8x16, max: i8x16) -> Self::Output

fn _max(self, rhs: i8x16) -> Self::Output

fn _min(self, rhs: i8x16) -> Self::Output

impl NormalOut<i8x16> for i8

type Output = <i8x16 as NormalOutPromote>::Output

fn _add(self, rhs: i8x16) -> Self::Output

fn _sub(self, rhs: i8x16) -> Self::Output

fn _mul(self, rhs: i8x16) -> Self::Output

fn _max(self, rhs: i8x16) -> Self::Output

fn _min(self, rhs: i8x16) -> Self::Output

fn _rem(self, rhs: i8x16) -> Self::Output

fn _clamp(self, min: i8x16, max: i8x16) -> Self::Output

fn _mul_add(self, a: i8x16, b: i8x16) -> Self::Output

impl NormalOut<i8x16> for i16

type Output = <i16x8 as NormalOutPromote<i8x16>>::Output

fn _mul_add(self, a: i8x16, b: i8x16) -> Self::Output

fn _add(self, rhs: i8x16) -> Self::Output

fn _sub(self, rhs: i8x16) -> Self::Output

fn _mul(self, rhs: i8x16) -> Self::Output

fn _rem(self, rhs: i8x16) -> Self::Output

fn _clamp(self, min: i8x16, max: i8x16) -> Self::Output

fn _max(self, rhs: i8x16) -> Self::Output

fn _min(self, rhs: i8x16) -> Self::Output

impl NormalOut<i8x16> for i32

type Output = <i32x4 as NormalOutPromote<i8x16>>::Output

fn _mul_add(self, a: i8x16, b: i8x16) -> Self::Output

fn _add(self, rhs: i8x16) -> Self::Output

fn _sub(self, rhs: i8x16) -> Self::Output

fn _mul(self, rhs: i8x16) -> Self::Output

fn _rem(self, rhs: i8x16) -> Self::Output

fn _clamp(self, min: i8x16, max: i8x16) -> Self::Output

fn _max(self, rhs: i8x16) -> Self::Output

fn _min(self, rhs: i8x16) -> Self::Output

impl NormalOut<i8x16> for i64

type Output = <i64x2 as NormalOutPromote<i8x16>>::Output

fn _mul_add(self, a: i8x16, b: i8x16) -> Self::Output

fn _add(self, rhs: i8x16) -> Self::Output

fn _sub(self, rhs: i8x16) -> Self::Output

fn _mul(self, rhs: i8x16) -> Self::Output

fn _rem(self, rhs: i8x16) -> Self::Output

fn _clamp(self, min: i8x16, max: i8x16) -> Self::Output

fn _max(self, rhs: i8x16) -> Self::Output

fn _min(self, rhs: i8x16) -> Self::Output

impl NormalOut<i8x16> for isize

type Output = <isizex2 as NormalOutPromote<i8x16>>::Output

fn _mul_add(self, a: i8x16, b: i8x16) -> Self::Output

fn _add(self, rhs: i8x16) -> Self::Output

fn _sub(self, rhs: i8x16) -> Self::Output

fn _mul(self, rhs: i8x16) -> Self::Output

fn _rem(self, rhs: i8x16) -> Self::Output

fn _clamp(self, min: i8x16, max: i8x16) -> Self::Output

fn _max(self, rhs: i8x16) -> Self::Output

fn _min(self, rhs: i8x16) -> Self::Output

impl NormalOut<i8x16> for u8

type Output = <u8x16 as NormalOutPromote<i8x16>>::Output

fn _add(self, rhs: i8x16) -> Self::Output

fn _sub(self, rhs: i8x16) -> Self::Output

fn _mul(self, rhs: i8x16) -> Self::Output

fn _max(self, rhs: i8x16) -> Self::Output

fn _min(self, rhs: i8x16) -> Self::Output

fn _rem(self, rhs: i8x16) -> Self::Output

fn _clamp(self, min: i8x16, max: i8x16) -> Self::Output

fn _mul_add(self, a: i8x16, b: i8x16) -> Self::Output

impl NormalOut<i8x16> for u16

type Output = <u16x8 as NormalOutPromote<i8x16>>::Output

fn _mul_add(self, a: i8x16, b: i8x16) -> Self::Output

fn _add(self, rhs: i8x16) -> Self::Output

fn _sub(self, rhs: i8x16) -> Self::Output

fn _mul(self, rhs: i8x16) -> Self::Output

fn _rem(self, rhs: i8x16) -> Self::Output

fn _clamp(self, min: i8x16, max: i8x16) -> Self::Output

fn _max(self, rhs: i8x16) -> Self::Output

fn _min(self, rhs: i8x16) -> Self::Output

impl NormalOut<i8x16> for u32

type Output = <u32x4 as NormalOutPromote<i8x16>>::Output

fn _mul_add(self, a: i8x16, b: i8x16) -> Self::Output

fn _add(self, rhs: i8x16) -> Self::Output

fn _sub(self, rhs: i8x16) -> Self::Output

fn _mul(self, rhs: i8x16) -> Self::Output

fn _rem(self, rhs: i8x16) -> Self::Output

fn _clamp(self, min: i8x16, max: i8x16) -> Self::Output

fn _max(self, rhs: i8x16) -> Self::Output

fn _min(self, rhs: i8x16) -> Self::Output

impl NormalOut<i8x16> for u64

type Output = <u64x2 as NormalOutPromote<i8x16>>::Output

fn _mul_add(self, a: i8x16, b: i8x16) -> Self::Output

fn _add(self, rhs: i8x16) -> Self::Output

fn _sub(self, rhs: i8x16) -> Self::Output

fn _mul(self, rhs: i8x16) -> Self::Output

fn _rem(self, rhs: i8x16) -> Self::Output

fn _clamp(self, min: i8x16, max: i8x16) -> Self::Output

fn _max(self, rhs: i8x16) -> Self::Output

fn _min(self, rhs: i8x16) -> Self::Output

impl NormalOut<i8x16> for usize

type Output = <usizex2 as NormalOutPromote<i8x16>>::Output

fn _mul_add(self, a: i8x16, b: i8x16) -> Self::Output

fn _add(self, rhs: i8x16) -> Self::Output

fn _sub(self, rhs: i8x16) -> Self::Output

fn _mul(self, rhs: i8x16) -> Self::Output

fn _rem(self, rhs: i8x16) -> Self::Output

fn _clamp(self, min: i8x16, max: i8x16) -> Self::Output

fn _max(self, rhs: i8x16) -> Self::Output

fn _min(self, rhs: i8x16) -> Self::Output

impl NormalOut<i8x16> for bf16

type Output = <bf16x8 as NormalOutPromote<i8x16>>::Output

fn _mul_add(self, a: i8x16, b: i8x16) -> Self::Output

fn _add(self, rhs: i8x16) -> Self::Output

fn _sub(self, rhs: i8x16) -> Self::Output

fn _mul(self, rhs: i8x16) -> Self::Output

fn _rem(self, rhs: i8x16) -> Self::Output

fn _clamp(self, min: i8x16, max: i8x16) -> Self::Output

fn _max(self, rhs: i8x16) -> Self::Output

fn _min(self, rhs: i8x16) -> Self::Output

impl NormalOut<i8x16> for f16

type Output = <f16x8 as NormalOutPromote<i8x16>>::Output

fn _mul_add(self, a: i8x16, b: i8x16) -> Self::Output

fn _add(self, rhs: i8x16) -> Self::Output

fn _sub(self, rhs: i8x16) -> Self::Output

fn _mul(self, rhs: i8x16) -> Self::Output

fn _rem(self, rhs: i8x16) -> Self::Output

fn _clamp(self, min: i8x16, max: i8x16) -> Self::Output

fn _max(self, rhs: i8x16) -> Self::Output

fn _min(self, rhs: i8x16) -> Self::Output

impl NormalOut<i8x16> for Complex32

type Output = <cplx32x2 as NormalOutPromote<i8x16>>::Output

fn _mul_add(self, a: i8x16, b: i8x16) -> Self::Output

fn _add(self, rhs: i8x16) -> Self::Output

fn _sub(self, rhs: i8x16) -> Self::Output

fn _mul(self, rhs: i8x16) -> Self::Output

fn _rem(self, rhs: i8x16) -> Self::Output

fn _clamp(self, min: i8x16, max: i8x16) -> Self::Output

fn _max(self, rhs: i8x16) -> Self::Output

fn _min(self, rhs: i8x16) -> Self::Output

impl NormalOut<i8x16> for Complex64

type Output = <cplx64x1 as NormalOutPromote<i8x16>>::Output

fn _mul_add(self, a: i8x16, b: i8x16) -> Self::Output

fn _add(self, rhs: i8x16) -> Self::Output

fn _sub(self, rhs: i8x16) -> Self::Output

fn _mul(self, rhs: i8x16) -> Self::Output

fn _rem(self, rhs: i8x16) -> Self::Output

fn _clamp(self, min: i8x16, max: i8x16) -> Self::Output

fn _max(self, rhs: i8x16) -> Self::Output

fn _min(self, rhs: i8x16) -> Self::Output

impl NormalOut<i16x8> for bool

type Output = <boolx16 as NormalOutPromote<i16x8>>::Output

fn _mul_add(self, a: i16x8, b: i16x8) -> Self::Output

fn _add(self, rhs: i16x8) -> Self::Output

fn _sub(self, rhs: i16x8) -> Self::Output

fn _mul(self, rhs: i16x8) -> Self::Output

fn _rem(self, rhs: i16x8) -> Self::Output

fn _clamp(self, min: i16x8, max: i16x8) -> Self::Output

fn _max(self, rhs: i16x8) -> Self::Output

fn _min(self, rhs: i16x8) -> Self::Output

impl NormalOut<i16x8> for f32

type Output = <f32x4 as NormalOutPromote<i16x8>>::Output

fn _mul_add(self, a: i16x8, b: i16x8) -> Self::Output

fn _add(self, rhs: i16x8) -> Self::Output

fn _sub(self, rhs: i16x8) -> Self::Output

fn _mul(self, rhs: i16x8) -> Self::Output

fn _rem(self, rhs: i16x8) -> Self::Output

fn _clamp(self, min: i16x8, max: i16x8) -> Self::Output

fn _max(self, rhs: i16x8) -> Self::Output

fn _min(self, rhs: i16x8) -> Self::Output

impl NormalOut<i16x8> for f64

type Output = <f64x2 as NormalOutPromote<i16x8>>::Output

fn _mul_add(self, a: i16x8, b: i16x8) -> Self::Output

fn _add(self, rhs: i16x8) -> Self::Output

fn _sub(self, rhs: i16x8) -> Self::Output

fn _mul(self, rhs: i16x8) -> Self::Output

fn _rem(self, rhs: i16x8) -> Self::Output

fn _clamp(self, min: i16x8, max: i16x8) -> Self::Output

fn _max(self, rhs: i16x8) -> Self::Output

fn _min(self, rhs: i16x8) -> Self::Output

impl NormalOut<i16x8> for i8

type Output = <i8x16 as NormalOutPromote<i16x8>>::Output

fn _mul_add(self, a: i16x8, b: i16x8) -> Self::Output

fn _add(self, rhs: i16x8) -> Self::Output

fn _sub(self, rhs: i16x8) -> Self::Output

fn _mul(self, rhs: i16x8) -> Self::Output

fn _rem(self, rhs: i16x8) -> Self::Output

fn _clamp(self, min: i16x8, max: i16x8) -> Self::Output

fn _max(self, rhs: i16x8) -> Self::Output

fn _min(self, rhs: i16x8) -> Self::Output

impl NormalOut<i16x8> for i16

type Output = <i16x8 as NormalOutPromote>::Output

fn _add(self, rhs: i16x8) -> Self::Output

fn _sub(self, rhs: i16x8) -> Self::Output

fn _mul(self, rhs: i16x8) -> Self::Output

fn _max(self, rhs: i16x8) -> Self::Output

fn _min(self, rhs: i16x8) -> Self::Output

fn _rem(self, rhs: i16x8) -> Self::Output

fn _clamp(self, min: i16x8, max: i16x8) -> Self::Output

fn _mul_add(self, a: i16x8, b: i16x8) -> Self::Output

impl NormalOut<i16x8> for i32

type Output = <i32x4 as NormalOutPromote<i16x8>>::Output

fn _mul_add(self, a: i16x8, b: i16x8) -> Self::Output

fn _add(self, rhs: i16x8) -> Self::Output

fn _sub(self, rhs: i16x8) -> Self::Output

fn _mul(self, rhs: i16x8) -> Self::Output

fn _rem(self, rhs: i16x8) -> Self::Output

fn _clamp(self, min: i16x8, max: i16x8) -> Self::Output

fn _max(self, rhs: i16x8) -> Self::Output

fn _min(self, rhs: i16x8) -> Self::Output

impl NormalOut<i16x8> for i64

type Output = <i64x2 as NormalOutPromote<i16x8>>::Output

fn _mul_add(self, a: i16x8, b: i16x8) -> Self::Output

fn _add(self, rhs: i16x8) -> Self::Output

fn _sub(self, rhs: i16x8) -> Self::Output

fn _mul(self, rhs: i16x8) -> Self::Output

fn _rem(self, rhs: i16x8) -> Self::Output

fn _clamp(self, min: i16x8, max: i16x8) -> Self::Output

fn _max(self, rhs: i16x8) -> Self::Output

fn _min(self, rhs: i16x8) -> Self::Output

impl NormalOut<i16x8> for isize

type Output = <isizex2 as NormalOutPromote<i16x8>>::Output

fn _mul_add(self, a: i16x8, b: i16x8) -> Self::Output

fn _add(self, rhs: i16x8) -> Self::Output

fn _sub(self, rhs: i16x8) -> Self::Output

fn _mul(self, rhs: i16x8) -> Self::Output

fn _rem(self, rhs: i16x8) -> Self::Output

fn _clamp(self, min: i16x8, max: i16x8) -> Self::Output

fn _max(self, rhs: i16x8) -> Self::Output

fn _min(self, rhs: i16x8) -> Self::Output

impl NormalOut<i16x8> for u8

type Output = <u8x16 as NormalOutPromote<i16x8>>::Output

fn _mul_add(self, a: i16x8, b: i16x8) -> Self::Output

fn _add(self, rhs: i16x8) -> Self::Output

fn _sub(self, rhs: i16x8) -> Self::Output

fn _mul(self, rhs: i16x8) -> Self::Output

fn _rem(self, rhs: i16x8) -> Self::Output

fn _clamp(self, min: i16x8, max: i16x8) -> Self::Output

fn _max(self, rhs: i16x8) -> Self::Output

fn _min(self, rhs: i16x8) -> Self::Output

impl NormalOut<i16x8> for u16

type Output = <u16x8 as NormalOutPromote<i16x8>>::Output

fn _add(self, rhs: i16x8) -> Self::Output

fn _sub(self, rhs: i16x8) -> Self::Output

fn _mul(self, rhs: i16x8) -> Self::Output

fn _max(self, rhs: i16x8) -> Self::Output

fn _min(self, rhs: i16x8) -> Self::Output

fn _rem(self, rhs: i16x8) -> Self::Output

fn _clamp(self, min: i16x8, max: i16x8) -> Self::Output

fn _mul_add(self, a: i16x8, b: i16x8) -> Self::Output

impl NormalOut<i16x8> for u32

type Output = <u32x4 as NormalOutPromote<i16x8>>::Output

fn _mul_add(self, a: i16x8, b: i16x8) -> Self::Output

fn _add(self, rhs: i16x8) -> Self::Output

fn _sub(self, rhs: i16x8) -> Self::Output

fn _mul(self, rhs: i16x8) -> Self::Output

fn _rem(self, rhs: i16x8) -> Self::Output

fn _clamp(self, min: i16x8, max: i16x8) -> Self::Output

fn _max(self, rhs: i16x8) -> Self::Output

fn _min(self, rhs: i16x8) -> Self::Output

impl NormalOut<i16x8> for u64

type Output = <u64x2 as NormalOutPromote<i16x8>>::Output

fn _mul_add(self, a: i16x8, b: i16x8) -> Self::Output

fn _add(self, rhs: i16x8) -> Self::Output

fn _sub(self, rhs: i16x8) -> Self::Output

fn _mul(self, rhs: i16x8) -> Self::Output

fn _rem(self, rhs: i16x8) -> Self::Output

fn _clamp(self, min: i16x8, max: i16x8) -> Self::Output

fn _max(self, rhs: i16x8) -> Self::Output

fn _min(self, rhs: i16x8) -> Self::Output

impl NormalOut<i16x8> for usize

type Output = <usizex2 as NormalOutPromote<i16x8>>::Output

fn _mul_add(self, a: i16x8, b: i16x8) -> Self::Output

fn _add(self, rhs: i16x8) -> Self::Output

fn _sub(self, rhs: i16x8) -> Self::Output

fn _mul(self, rhs: i16x8) -> Self::Output

fn _rem(self, rhs: i16x8) -> Self::Output

fn _clamp(self, min: i16x8, max: i16x8) -> Self::Output

fn _max(self, rhs: i16x8) -> Self::Output

fn _min(self, rhs: i16x8) -> Self::Output

impl NormalOut<i16x8> for bf16

type Output = <bf16x8 as NormalOutPromote<i16x8>>::Output

fn _add(self, rhs: i16x8) -> Self::Output

fn _sub(self, rhs: i16x8) -> Self::Output

fn _mul(self, rhs: i16x8) -> Self::Output

fn _max(self, rhs: i16x8) -> Self::Output

fn _min(self, rhs: i16x8) -> Self::Output

fn _rem(self, rhs: i16x8) -> Self::Output

fn _clamp(self, min: i16x8, max: i16x8) -> Self::Output

fn _mul_add(self, a: i16x8, b: i16x8) -> Self::Output

impl NormalOut<i16x8> for f16

type Output = <f16x8 as NormalOutPromote<i16x8>>::Output

fn _add(self, rhs: i16x8) -> Self::Output

fn _sub(self, rhs: i16x8) -> Self::Output

fn _mul(self, rhs: i16x8) -> Self::Output

fn _max(self, rhs: i16x8) -> Self::Output

fn _min(self, rhs: i16x8) -> Self::Output

fn _rem(self, rhs: i16x8) -> Self::Output

fn _clamp(self, min: i16x8, max: i16x8) -> Self::Output

fn _mul_add(self, a: i16x8, b: i16x8) -> Self::Output

impl NormalOut<i16x8> for Complex32

type Output = <cplx32x2 as NormalOutPromote<i16x8>>::Output

fn _mul_add(self, a: i16x8, b: i16x8) -> Self::Output

fn _add(self, rhs: i16x8) -> Self::Output

fn _sub(self, rhs: i16x8) -> Self::Output

fn _mul(self, rhs: i16x8) -> Self::Output

fn _rem(self, rhs: i16x8) -> Self::Output

fn _clamp(self, min: i16x8, max: i16x8) -> Self::Output

fn _max(self, rhs: i16x8) -> Self::Output

fn _min(self, rhs: i16x8) -> Self::Output

impl NormalOut<i16x8> for Complex64

type Output = <cplx64x1 as NormalOutPromote<i16x8>>::Output

fn _mul_add(self, a: i16x8, b: i16x8) -> Self::Output

fn _add(self, rhs: i16x8) -> Self::Output

fn _sub(self, rhs: i16x8) -> Self::Output

fn _mul(self, rhs: i16x8) -> Self::Output

fn _rem(self, rhs: i16x8) -> Self::Output

fn _clamp(self, min: i16x8, max: i16x8) -> Self::Output

fn _max(self, rhs: i16x8) -> Self::Output

fn _min(self, rhs: i16x8) -> Self::Output

impl NormalOut<i32x4> for bool

type Output = <boolx16 as NormalOutPromote<i32x4>>::Output

fn _mul_add(self, a: i32x4, b: i32x4) -> Self::Output

fn _add(self, rhs: i32x4) -> Self::Output

fn _sub(self, rhs: i32x4) -> Self::Output

fn _mul(self, rhs: i32x4) -> Self::Output

fn _rem(self, rhs: i32x4) -> Self::Output

fn _clamp(self, min: i32x4, max: i32x4) -> Self::Output

fn _max(self, rhs: i32x4) -> Self::Output

fn _min(self, rhs: i32x4) -> Self::Output

impl NormalOut<i32x4> for f32

type Output = <f32x4 as NormalOutPromote<i32x4>>::Output

fn _add(self, rhs: i32x4) -> Self::Output

fn _sub(self, rhs: i32x4) -> Self::Output

fn _mul(self, rhs: i32x4) -> Self::Output

fn _max(self, rhs: i32x4) -> Self::Output

fn _min(self, rhs: i32x4) -> Self::Output

fn _rem(self, rhs: i32x4) -> Self::Output

fn _clamp(self, min: i32x4, max: i32x4) -> Self::Output

fn _mul_add(self, a: i32x4, b: i32x4) -> Self::Output

impl NormalOut<i32x4> for f64

type Output = <f64x2 as NormalOutPromote<i32x4>>::Output

fn _mul_add(self, a: i32x4, b: i32x4) -> Self::Output

fn _add(self, rhs: i32x4) -> Self::Output

fn _sub(self, rhs: i32x4) -> Self::Output

fn _mul(self, rhs: i32x4) -> Self::Output

fn _rem(self, rhs: i32x4) -> Self::Output

fn _clamp(self, min: i32x4, max: i32x4) -> Self::Output

fn _max(self, rhs: i32x4) -> Self::Output

fn _min(self, rhs: i32x4) -> Self::Output

impl NormalOut<i32x4> for i8

type Output = <i8x16 as NormalOutPromote<i32x4>>::Output

fn _mul_add(self, a: i32x4, b: i32x4) -> Self::Output

fn _add(self, rhs: i32x4) -> Self::Output

fn _sub(self, rhs: i32x4) -> Self::Output

fn _mul(self, rhs: i32x4) -> Self::Output

fn _rem(self, rhs: i32x4) -> Self::Output

fn _clamp(self, min: i32x4, max: i32x4) -> Self::Output

fn _max(self, rhs: i32x4) -> Self::Output

fn _min(self, rhs: i32x4) -> Self::Output

impl NormalOut<i32x4> for i16

type Output = <i16x8 as NormalOutPromote<i32x4>>::Output

fn _mul_add(self, a: i32x4, b: i32x4) -> Self::Output

fn _add(self, rhs: i32x4) -> Self::Output

fn _sub(self, rhs: i32x4) -> Self::Output

fn _mul(self, rhs: i32x4) -> Self::Output

fn _rem(self, rhs: i32x4) -> Self::Output

fn _clamp(self, min: i32x4, max: i32x4) -> Self::Output

fn _max(self, rhs: i32x4) -> Self::Output

fn _min(self, rhs: i32x4) -> Self::Output

impl NormalOut<i32x4> for i32

type Output = <i32x4 as NormalOutPromote>::Output

fn _add(self, rhs: i32x4) -> Self::Output

fn _sub(self, rhs: i32x4) -> Self::Output

fn _mul(self, rhs: i32x4) -> Self::Output

fn _max(self, rhs: i32x4) -> Self::Output

fn _min(self, rhs: i32x4) -> Self::Output

fn _rem(self, rhs: i32x4) -> Self::Output

fn _clamp(self, min: i32x4, max: i32x4) -> Self::Output

fn _mul_add(self, a: i32x4, b: i32x4) -> Self::Output

impl NormalOut<i32x4> for i64

type Output = <i64x2 as NormalOutPromote<i32x4>>::Output

fn _mul_add(self, a: i32x4, b: i32x4) -> Self::Output

fn _add(self, rhs: i32x4) -> Self::Output

fn _sub(self, rhs: i32x4) -> Self::Output

fn _mul(self, rhs: i32x4) -> Self::Output

fn _rem(self, rhs: i32x4) -> Self::Output

fn _clamp(self, min: i32x4, max: i32x4) -> Self::Output

fn _max(self, rhs: i32x4) -> Self::Output

fn _min(self, rhs: i32x4) -> Self::Output

impl NormalOut<i32x4> for isize

type Output = <isizex2 as NormalOutPromote<i32x4>>::Output

fn _mul_add(self, a: i32x4, b: i32x4) -> Self::Output

fn _add(self, rhs: i32x4) -> Self::Output

fn _sub(self, rhs: i32x4) -> Self::Output

fn _mul(self, rhs: i32x4) -> Self::Output

fn _rem(self, rhs: i32x4) -> Self::Output

fn _clamp(self, min: i32x4, max: i32x4) -> Self::Output

fn _max(self, rhs: i32x4) -> Self::Output

fn _min(self, rhs: i32x4) -> Self::Output

impl NormalOut<i32x4> for u8

type Output = <u8x16 as NormalOutPromote<i32x4>>::Output

fn _mul_add(self, a: i32x4, b: i32x4) -> Self::Output

fn _add(self, rhs: i32x4) -> Self::Output

fn _sub(self, rhs: i32x4) -> Self::Output

fn _mul(self, rhs: i32x4) -> Self::Output

fn _rem(self, rhs: i32x4) -> Self::Output

fn _clamp(self, min: i32x4, max: i32x4) -> Self::Output

fn _max(self, rhs: i32x4) -> Self::Output

fn _min(self, rhs: i32x4) -> Self::Output

impl NormalOut<i32x4> for u16

type Output = <u16x8 as NormalOutPromote<i32x4>>::Output

fn _mul_add(self, a: i32x4, b: i32x4) -> Self::Output

fn _add(self, rhs: i32x4) -> Self::Output

fn _sub(self, rhs: i32x4) -> Self::Output

fn _mul(self, rhs: i32x4) -> Self::Output

fn _rem(self, rhs: i32x4) -> Self::Output

fn _clamp(self, min: i32x4, max: i32x4) -> Self::Output

fn _max(self, rhs: i32x4) -> Self::Output

fn _min(self, rhs: i32x4) -> Self::Output

impl NormalOut<i32x4> for u32

type Output = <u32x4 as NormalOutPromote<i32x4>>::Output

fn _add(self, rhs: i32x4) -> Self::Output

fn _sub(self, rhs: i32x4) -> Self::Output

fn _mul(self, rhs: i32x4) -> Self::Output

fn _max(self, rhs: i32x4) -> Self::Output

fn _min(self, rhs: i32x4) -> Self::Output

fn _rem(self, rhs: i32x4) -> Self::Output

fn _clamp(self, min: i32x4, max: i32x4) -> Self::Output

fn _mul_add(self, a: i32x4, b: i32x4) -> Self::Output

impl NormalOut<i32x4> for u64

type Output = <u64x2 as NormalOutPromote<i32x4>>::Output

fn _mul_add(self, a: i32x4, b: i32x4) -> Self::Output

fn _add(self, rhs: i32x4) -> Self::Output

fn _sub(self, rhs: i32x4) -> Self::Output

fn _mul(self, rhs: i32x4) -> Self::Output

fn _rem(self, rhs: i32x4) -> Self::Output

fn _clamp(self, min: i32x4, max: i32x4) -> Self::Output

fn _max(self, rhs: i32x4) -> Self::Output

fn _min(self, rhs: i32x4) -> Self::Output

impl NormalOut<i32x4> for usize

type Output = <usizex2 as NormalOutPromote<i32x4>>::Output

fn _mul_add(self, a: i32x4, b: i32x4) -> Self::Output

fn _add(self, rhs: i32x4) -> Self::Output

fn _sub(self, rhs: i32x4) -> Self::Output

fn _mul(self, rhs: i32x4) -> Self::Output

fn _rem(self, rhs: i32x4) -> Self::Output

fn _clamp(self, min: i32x4, max: i32x4) -> Self::Output

fn _max(self, rhs: i32x4) -> Self::Output

fn _min(self, rhs: i32x4) -> Self::Output

impl NormalOut<i32x4> for bf16

type Output = <bf16x8 as NormalOutPromote<i32x4>>::Output

fn _mul_add(self, a: i32x4, b: i32x4) -> Self::Output

fn _add(self, rhs: i32x4) -> Self::Output

fn _sub(self, rhs: i32x4) -> Self::Output

fn _mul(self, rhs: i32x4) -> Self::Output

fn _rem(self, rhs: i32x4) -> Self::Output

fn _clamp(self, min: i32x4, max: i32x4) -> Self::Output

fn _max(self, rhs: i32x4) -> Self::Output

fn _min(self, rhs: i32x4) -> Self::Output

impl NormalOut<i32x4> for f16

type Output = <f16x8 as NormalOutPromote<i32x4>>::Output

fn _mul_add(self, a: i32x4, b: i32x4) -> Self::Output

fn _add(self, rhs: i32x4) -> Self::Output

fn _sub(self, rhs: i32x4) -> Self::Output

fn _mul(self, rhs: i32x4) -> Self::Output

fn _rem(self, rhs: i32x4) -> Self::Output

fn _clamp(self, min: i32x4, max: i32x4) -> Self::Output

fn _max(self, rhs: i32x4) -> Self::Output

fn _min(self, rhs: i32x4) -> Self::Output

impl NormalOut<i32x4> for Complex32

type Output = <cplx32x2 as NormalOutPromote<i32x4>>::Output

fn _mul_add(self, a: i32x4, b: i32x4) -> Self::Output

fn _add(self, rhs: i32x4) -> Self::Output

fn _sub(self, rhs: i32x4) -> Self::Output

fn _mul(self, rhs: i32x4) -> Self::Output

fn _rem(self, rhs: i32x4) -> Self::Output

fn _clamp(self, min: i32x4, max: i32x4) -> Self::Output

fn _max(self, rhs: i32x4) -> Self::Output

fn _min(self, rhs: i32x4) -> Self::Output

impl NormalOut<i32x4> for Complex64

type Output = <cplx64x1 as NormalOutPromote<i32x4>>::Output

fn _mul_add(self, a: i32x4, b: i32x4) -> Self::Output

fn _add(self, rhs: i32x4) -> Self::Output

fn _sub(self, rhs: i32x4) -> Self::Output

fn _mul(self, rhs: i32x4) -> Self::Output

fn _rem(self, rhs: i32x4) -> Self::Output

fn _clamp(self, min: i32x4, max: i32x4) -> Self::Output

fn _max(self, rhs: i32x4) -> Self::Output

fn _min(self, rhs: i32x4) -> Self::Output

impl NormalOut<i64x2> for bool

type Output = <boolx16 as NormalOutPromote<i64x2>>::Output

fn _mul_add(self, a: i64x2, b: i64x2) -> Self::Output

fn _add(self, rhs: i64x2) -> Self::Output

fn _sub(self, rhs: i64x2) -> Self::Output

fn _mul(self, rhs: i64x2) -> Self::Output

fn _rem(self, rhs: i64x2) -> Self::Output

fn _clamp(self, min: i64x2, max: i64x2) -> Self::Output

fn _max(self, rhs: i64x2) -> Self::Output

fn _min(self, rhs: i64x2) -> Self::Output

impl NormalOut<i64x2> for f32

type Output = <f32x4 as NormalOutPromote<i64x2>>::Output

fn _mul_add(self, a: i64x2, b: i64x2) -> Self::Output

fn _add(self, rhs: i64x2) -> Self::Output

fn _sub(self, rhs: i64x2) -> Self::Output

fn _mul(self, rhs: i64x2) -> Self::Output

fn _rem(self, rhs: i64x2) -> Self::Output

fn _clamp(self, min: i64x2, max: i64x2) -> Self::Output

fn _max(self, rhs: i64x2) -> Self::Output

fn _min(self, rhs: i64x2) -> Self::Output

impl NormalOut<i64x2> for f64

type Output = <f64x2 as NormalOutPromote<i64x2>>::Output

fn _add(self, rhs: i64x2) -> Self::Output

fn _sub(self, rhs: i64x2) -> Self::Output

fn _mul(self, rhs: i64x2) -> Self::Output

fn _max(self, rhs: i64x2) -> Self::Output

fn _min(self, rhs: i64x2) -> Self::Output

fn _rem(self, rhs: i64x2) -> Self::Output

fn _clamp(self, min: i64x2, max: i64x2) -> Self::Output

fn _mul_add(self, a: i64x2, b: i64x2) -> Self::Output

impl NormalOut<i64x2> for i8

type Output = <i8x16 as NormalOutPromote<i64x2>>::Output

fn _mul_add(self, a: i64x2, b: i64x2) -> Self::Output

fn _add(self, rhs: i64x2) -> Self::Output

fn _sub(self, rhs: i64x2) -> Self::Output

fn _mul(self, rhs: i64x2) -> Self::Output

fn _rem(self, rhs: i64x2) -> Self::Output

fn _clamp(self, min: i64x2, max: i64x2) -> Self::Output

fn _max(self, rhs: i64x2) -> Self::Output

fn _min(self, rhs: i64x2) -> Self::Output

impl NormalOut<i64x2> for i16

type Output = <i16x8 as NormalOutPromote<i64x2>>::Output

fn _mul_add(self, a: i64x2, b: i64x2) -> Self::Output

fn _add(self, rhs: i64x2) -> Self::Output

fn _sub(self, rhs: i64x2) -> Self::Output

fn _mul(self, rhs: i64x2) -> Self::Output

fn _rem(self, rhs: i64x2) -> Self::Output

fn _clamp(self, min: i64x2, max: i64x2) -> Self::Output

fn _max(self, rhs: i64x2) -> Self::Output

fn _min(self, rhs: i64x2) -> Self::Output

impl NormalOut<i64x2> for i32

type Output = <i32x4 as NormalOutPromote<i64x2>>::Output

fn _mul_add(self, a: i64x2, b: i64x2) -> Self::Output

fn _add(self, rhs: i64x2) -> Self::Output

fn _sub(self, rhs: i64x2) -> Self::Output

fn _mul(self, rhs: i64x2) -> Self::Output

fn _rem(self, rhs: i64x2) -> Self::Output

fn _clamp(self, min: i64x2, max: i64x2) -> Self::Output

fn _max(self, rhs: i64x2) -> Self::Output

fn _min(self, rhs: i64x2) -> Self::Output

impl NormalOut<i64x2> for i64

type Output = <i64x2 as NormalOutPromote>::Output

fn _add(self, rhs: i64x2) -> Self::Output

fn _sub(self, rhs: i64x2) -> Self::Output

fn _mul(self, rhs: i64x2) -> Self::Output

fn _max(self, rhs: i64x2) -> Self::Output

fn _min(self, rhs: i64x2) -> Self::Output

fn _rem(self, rhs: i64x2) -> Self::Output

fn _clamp(self, min: i64x2, max: i64x2) -> Self::Output

fn _mul_add(self, a: i64x2, b: i64x2) -> Self::Output

impl NormalOut<i64x2> for isize

type Output = <isizex2 as NormalOutPromote<i64x2>>::Output

fn _add(self, rhs: i64x2) -> Self::Output

fn _sub(self, rhs: i64x2) -> Self::Output

fn _mul(self, rhs: i64x2) -> Self::Output

fn _max(self, rhs: i64x2) -> Self::Output

fn _min(self, rhs: i64x2) -> Self::Output

fn _rem(self, rhs: i64x2) -> Self::Output

fn _clamp(self, min: i64x2, max: i64x2) -> Self::Output

fn _mul_add(self, a: i64x2, b: i64x2) -> Self::Output

impl NormalOut<i64x2> for u8

type Output = <u8x16 as NormalOutPromote<i64x2>>::Output

fn _mul_add(self, a: i64x2, b: i64x2) -> Self::Output

fn _add(self, rhs: i64x2) -> Self::Output

fn _sub(self, rhs: i64x2) -> Self::Output

fn _mul(self, rhs: i64x2) -> Self::Output

fn _rem(self, rhs: i64x2) -> Self::Output

fn _clamp(self, min: i64x2, max: i64x2) -> Self::Output

fn _max(self, rhs: i64x2) -> Self::Output

fn _min(self, rhs: i64x2) -> Self::Output

impl NormalOut<i64x2> for u16

type Output = <u16x8 as NormalOutPromote<i64x2>>::Output

fn _mul_add(self, a: i64x2, b: i64x2) -> Self::Output

fn _add(self, rhs: i64x2) -> Self::Output

fn _sub(self, rhs: i64x2) -> Self::Output

fn _mul(self, rhs: i64x2) -> Self::Output

fn _rem(self, rhs: i64x2) -> Self::Output

fn _clamp(self, min: i64x2, max: i64x2) -> Self::Output

fn _max(self, rhs: i64x2) -> Self::Output

fn _min(self, rhs: i64x2) -> Self::Output

impl NormalOut<i64x2> for u32

type Output = <u32x4 as NormalOutPromote<i64x2>>::Output

fn _mul_add(self, a: i64x2, b: i64x2) -> Self::Output

fn _add(self, rhs: i64x2) -> Self::Output

fn _sub(self, rhs: i64x2) -> Self::Output

fn _mul(self, rhs: i64x2) -> Self::Output

fn _rem(self, rhs: i64x2) -> Self::Output

fn _clamp(self, min: i64x2, max: i64x2) -> Self::Output

fn _max(self, rhs: i64x2) -> Self::Output

fn _min(self, rhs: i64x2) -> Self::Output

impl NormalOut<i64x2> for u64

type Output = <u64x2 as NormalOutPromote<i64x2>>::Output

fn _add(self, rhs: i64x2) -> Self::Output

fn _sub(self, rhs: i64x2) -> Self::Output

fn _mul(self, rhs: i64x2) -> Self::Output

fn _max(self, rhs: i64x2) -> Self::Output

fn _min(self, rhs: i64x2) -> Self::Output

fn _rem(self, rhs: i64x2) -> Self::Output

fn _clamp(self, min: i64x2, max: i64x2) -> Self::Output

fn _mul_add(self, a: i64x2, b: i64x2) -> Self::Output

impl NormalOut<i64x2> for usize

type Output = <usizex2 as NormalOutPromote<i64x2>>::Output

fn _add(self, rhs: i64x2) -> Self::Output

fn _sub(self, rhs: i64x2) -> Self::Output

fn _mul(self, rhs: i64x2) -> Self::Output

fn _max(self, rhs: i64x2) -> Self::Output

fn _min(self, rhs: i64x2) -> Self::Output

fn _rem(self, rhs: i64x2) -> Self::Output

fn _clamp(self, min: i64x2, max: i64x2) -> Self::Output

fn _mul_add(self, a: i64x2, b: i64x2) -> Self::Output

impl NormalOut<i64x2> for bf16

type Output = <bf16x8 as NormalOutPromote<i64x2>>::Output

fn _mul_add(self, a: i64x2, b: i64x2) -> Self::Output

fn _add(self, rhs: i64x2) -> Self::Output

fn _sub(self, rhs: i64x2) -> Self::Output

fn _mul(self, rhs: i64x2) -> Self::Output

fn _rem(self, rhs: i64x2) -> Self::Output

fn _clamp(self, min: i64x2, max: i64x2) -> Self::Output

fn _max(self, rhs: i64x2) -> Self::Output

fn _min(self, rhs: i64x2) -> Self::Output

impl NormalOut<i64x2> for f16

type Output = <f16x8 as NormalOutPromote<i64x2>>::Output

fn _mul_add(self, a: i64x2, b: i64x2) -> Self::Output

fn _add(self, rhs: i64x2) -> Self::Output

fn _sub(self, rhs: i64x2) -> Self::Output

fn _mul(self, rhs: i64x2) -> Self::Output

fn _rem(self, rhs: i64x2) -> Self::Output

fn _clamp(self, min: i64x2, max: i64x2) -> Self::Output

fn _max(self, rhs: i64x2) -> Self::Output

fn _min(self, rhs: i64x2) -> Self::Output

impl NormalOut<i64x2> for Complex32

type Output = <cplx32x2 as NormalOutPromote<i64x2>>::Output

fn _add(self, rhs: i64x2) -> Self::Output

fn _sub(self, rhs: i64x2) -> Self::Output

fn _mul(self, rhs: i64x2) -> Self::Output

fn _max(self, rhs: i64x2) -> Self::Output

fn _min(self, rhs: i64x2) -> Self::Output

fn _rem(self, rhs: i64x2) -> Self::Output

fn _clamp(self, min: i64x2, max: i64x2) -> Self::Output

fn _mul_add(self, a: i64x2, b: i64x2) -> Self::Output

impl NormalOut<i64x2> for Complex64

type Output = <cplx64x1 as NormalOutPromote<i64x2>>::Output

fn _mul_add(self, a: i64x2, b: i64x2) -> Self::Output

fn _add(self, rhs: i64x2) -> Self::Output

fn _sub(self, rhs: i64x2) -> Self::Output

fn _mul(self, rhs: i64x2) -> Self::Output

fn _rem(self, rhs: i64x2) -> Self::Output

fn _clamp(self, min: i64x2, max: i64x2) -> Self::Output

fn _max(self, rhs: i64x2) -> Self::Output

fn _min(self, rhs: i64x2) -> Self::Output

impl NormalOut<isizex2> for bool

type Output = <boolx16 as NormalOutPromote<isizex2>>::Output

fn _mul_add(self, a: isizex2, b: isizex2) -> Self::Output

fn _add(self, rhs: isizex2) -> Self::Output

fn _sub(self, rhs: isizex2) -> Self::Output

fn _mul(self, rhs: isizex2) -> Self::Output

fn _rem(self, rhs: isizex2) -> Self::Output

fn _clamp(self, min: isizex2, max: isizex2) -> Self::Output

fn _max(self, rhs: isizex2) -> Self::Output

fn _min(self, rhs: isizex2) -> Self::Output

impl NormalOut<isizex2> for f32

type Output = <f32x4 as NormalOutPromote<isizex2>>::Output

fn _mul_add(self, a: isizex2, b: isizex2) -> Self::Output

fn _add(self, rhs: isizex2) -> Self::Output

fn _sub(self, rhs: isizex2) -> Self::Output

fn _mul(self, rhs: isizex2) -> Self::Output

fn _rem(self, rhs: isizex2) -> Self::Output

fn _clamp(self, min: isizex2, max: isizex2) -> Self::Output

fn _max(self, rhs: isizex2) -> Self::Output

fn _min(self, rhs: isizex2) -> Self::Output

impl NormalOut<isizex2> for f64

type Output = <f64x2 as NormalOutPromote<isizex2>>::Output

fn _add(self, rhs: isizex2) -> Self::Output

fn _sub(self, rhs: isizex2) -> Self::Output

fn _mul(self, rhs: isizex2) -> Self::Output

fn _max(self, rhs: isizex2) -> Self::Output

fn _min(self, rhs: isizex2) -> Self::Output

fn _rem(self, rhs: isizex2) -> Self::Output

fn _clamp(self, min: isizex2, max: isizex2) -> Self::Output

fn _mul_add(self, a: isizex2, b: isizex2) -> Self::Output

impl NormalOut<isizex2> for i8

type Output = <i8x16 as NormalOutPromote<isizex2>>::Output

fn _mul_add(self, a: isizex2, b: isizex2) -> Self::Output

fn _add(self, rhs: isizex2) -> Self::Output

fn _sub(self, rhs: isizex2) -> Self::Output

fn _mul(self, rhs: isizex2) -> Self::Output

fn _rem(self, rhs: isizex2) -> Self::Output

fn _clamp(self, min: isizex2, max: isizex2) -> Self::Output

fn _max(self, rhs: isizex2) -> Self::Output

fn _min(self, rhs: isizex2) -> Self::Output

impl NormalOut<isizex2> for i16

type Output = <i16x8 as NormalOutPromote<isizex2>>::Output

fn _mul_add(self, a: isizex2, b: isizex2) -> Self::Output

fn _add(self, rhs: isizex2) -> Self::Output

fn _sub(self, rhs: isizex2) -> Self::Output

fn _mul(self, rhs: isizex2) -> Self::Output

fn _rem(self, rhs: isizex2) -> Self::Output

fn _clamp(self, min: isizex2, max: isizex2) -> Self::Output

fn _max(self, rhs: isizex2) -> Self::Output

fn _min(self, rhs: isizex2) -> Self::Output

impl NormalOut<isizex2> for i32

type Output = <i32x4 as NormalOutPromote<isizex2>>::Output

fn _mul_add(self, a: isizex2, b: isizex2) -> Self::Output

fn _add(self, rhs: isizex2) -> Self::Output

fn _sub(self, rhs: isizex2) -> Self::Output

fn _mul(self, rhs: isizex2) -> Self::Output

fn _rem(self, rhs: isizex2) -> Self::Output

fn _clamp(self, min: isizex2, max: isizex2) -> Self::Output

fn _max(self, rhs: isizex2) -> Self::Output

fn _min(self, rhs: isizex2) -> Self::Output

impl NormalOut<isizex2> for i64

type Output = <i64x2 as NormalOutPromote<isizex2>>::Output

fn _add(self, rhs: isizex2) -> Self::Output

fn _sub(self, rhs: isizex2) -> Self::Output

fn _mul(self, rhs: isizex2) -> Self::Output

fn _max(self, rhs: isizex2) -> Self::Output

fn _min(self, rhs: isizex2) -> Self::Output

fn _rem(self, rhs: isizex2) -> Self::Output

fn _clamp(self, min: isizex2, max: isizex2) -> Self::Output

fn _mul_add(self, a: isizex2, b: isizex2) -> Self::Output

impl NormalOut<isizex2> for isize

type Output = <isizex2 as NormalOutPromote>::Output

fn _add(self, rhs: isizex2) -> Self::Output

fn _sub(self, rhs: isizex2) -> Self::Output

fn _mul(self, rhs: isizex2) -> Self::Output

fn _max(self, rhs: isizex2) -> Self::Output

fn _min(self, rhs: isizex2) -> Self::Output

fn _rem(self, rhs: isizex2) -> Self::Output

fn _clamp(self, min: isizex2, max: isizex2) -> Self::Output

fn _mul_add(self, a: isizex2, b: isizex2) -> Self::Output

impl NormalOut<isizex2> for u8

type Output = <u8x16 as NormalOutPromote<isizex2>>::Output

fn _mul_add(self, a: isizex2, b: isizex2) -> Self::Output

fn _add(self, rhs: isizex2) -> Self::Output

fn _sub(self, rhs: isizex2) -> Self::Output

fn _mul(self, rhs: isizex2) -> Self::Output

fn _rem(self, rhs: isizex2) -> Self::Output

fn _clamp(self, min: isizex2, max: isizex2) -> Self::Output

fn _max(self, rhs: isizex2) -> Self::Output

fn _min(self, rhs: isizex2) -> Self::Output

impl NormalOut<isizex2> for u16

type Output = <u16x8 as NormalOutPromote<isizex2>>::Output

fn _mul_add(self, a: isizex2, b: isizex2) -> Self::Output

fn _add(self, rhs: isizex2) -> Self::Output

fn _sub(self, rhs: isizex2) -> Self::Output

fn _mul(self, rhs: isizex2) -> Self::Output

fn _rem(self, rhs: isizex2) -> Self::Output

fn _clamp(self, min: isizex2, max: isizex2) -> Self::Output

fn _max(self, rhs: isizex2) -> Self::Output

fn _min(self, rhs: isizex2) -> Self::Output

impl NormalOut<isizex2> for u32

type Output = <u32x4 as NormalOutPromote<isizex2>>::Output

fn _mul_add(self, a: isizex2, b: isizex2) -> Self::Output

fn _add(self, rhs: isizex2) -> Self::Output

fn _sub(self, rhs: isizex2) -> Self::Output

fn _mul(self, rhs: isizex2) -> Self::Output

fn _rem(self, rhs: isizex2) -> Self::Output

fn _clamp(self, min: isizex2, max: isizex2) -> Self::Output

fn _max(self, rhs: isizex2) -> Self::Output

fn _min(self, rhs: isizex2) -> Self::Output

impl NormalOut<isizex2> for u64

type Output = <u64x2 as NormalOutPromote<isizex2>>::Output

fn _add(self, rhs: isizex2) -> Self::Output

fn _sub(self, rhs: isizex2) -> Self::Output

fn _mul(self, rhs: isizex2) -> Self::Output

fn _max(self, rhs: isizex2) -> Self::Output

fn _min(self, rhs: isizex2) -> Self::Output

fn _rem(self, rhs: isizex2) -> Self::Output

fn _clamp(self, min: isizex2, max: isizex2) -> Self::Output

fn _mul_add(self, a: isizex2, b: isizex2) -> Self::Output

impl NormalOut<isizex2> for usize

type Output = <usizex2 as NormalOutPromote<isizex2>>::Output

fn _add(self, rhs: isizex2) -> Self::Output

fn _sub(self, rhs: isizex2) -> Self::Output

fn _mul(self, rhs: isizex2) -> Self::Output

fn _max(self, rhs: isizex2) -> Self::Output

fn _min(self, rhs: isizex2) -> Self::Output

fn _rem(self, rhs: isizex2) -> Self::Output

fn _clamp(self, min: isizex2, max: isizex2) -> Self::Output

fn _mul_add(self, a: isizex2, b: isizex2) -> Self::Output

impl NormalOut<isizex2> for bf16

type Output = <bf16x8 as NormalOutPromote<isizex2>>::Output

fn _mul_add(self, a: isizex2, b: isizex2) -> Self::Output

fn _add(self, rhs: isizex2) -> Self::Output

fn _sub(self, rhs: isizex2) -> Self::Output

fn _mul(self, rhs: isizex2) -> Self::Output

fn _rem(self, rhs: isizex2) -> Self::Output

fn _clamp(self, min: isizex2, max: isizex2) -> Self::Output

fn _max(self, rhs: isizex2) -> Self::Output

fn _min(self, rhs: isizex2) -> Self::Output

impl NormalOut<isizex2> for f16

type Output = <f16x8 as NormalOutPromote<isizex2>>::Output

fn _mul_add(self, a: isizex2, b: isizex2) -> Self::Output

fn _add(self, rhs: isizex2) -> Self::Output

fn _sub(self, rhs: isizex2) -> Self::Output

fn _mul(self, rhs: isizex2) -> Self::Output

fn _rem(self, rhs: isizex2) -> Self::Output

fn _clamp(self, min: isizex2, max: isizex2) -> Self::Output

fn _max(self, rhs: isizex2) -> Self::Output

fn _min(self, rhs: isizex2) -> Self::Output

impl NormalOut<isizex2> for Complex32

type Output = <cplx32x2 as NormalOutPromote<isizex2>>::Output

fn _add(self, rhs: isizex2) -> Self::Output

fn _sub(self, rhs: isizex2) -> Self::Output

fn _mul(self, rhs: isizex2) -> Self::Output

fn _max(self, rhs: isizex2) -> Self::Output

fn _min(self, rhs: isizex2) -> Self::Output

fn _rem(self, rhs: isizex2) -> Self::Output

fn _clamp(self, min: isizex2, max: isizex2) -> Self::Output

fn _mul_add(self, a: isizex2, b: isizex2) -> Self::Output

impl NormalOut<isizex2> for Complex64

type Output = <cplx64x1 as NormalOutPromote<isizex2>>::Output

fn _mul_add(self, a: isizex2, b: isizex2) -> Self::Output

fn _add(self, rhs: isizex2) -> Self::Output

fn _sub(self, rhs: isizex2) -> Self::Output

fn _mul(self, rhs: isizex2) -> Self::Output

fn _rem(self, rhs: isizex2) -> Self::Output

fn _clamp(self, min: isizex2, max: isizex2) -> Self::Output

fn _max(self, rhs: isizex2) -> Self::Output

fn _min(self, rhs: isizex2) -> Self::Output

impl NormalOut<u8x16> for bool

type Output = <boolx16 as NormalOutPromote<u8x16>>::Output

fn _add(self, rhs: u8x16) -> Self::Output

fn _sub(self, rhs: u8x16) -> Self::Output

fn _mul(self, rhs: u8x16) -> Self::Output

fn _max(self, rhs: u8x16) -> Self::Output

fn _min(self, rhs: u8x16) -> Self::Output

fn _rem(self, rhs: u8x16) -> Self::Output

fn _clamp(self, min: u8x16, max: u8x16) -> Self::Output

fn _mul_add(self, a: u8x16, b: u8x16) -> Self::Output

impl NormalOut<u8x16> for f32

type Output = <f32x4 as NormalOutPromote<u8x16>>::Output

fn _mul_add(self, a: u8x16, b: u8x16) -> Self::Output

fn _add(self, rhs: u8x16) -> Self::Output

fn _sub(self, rhs: u8x16) -> Self::Output

fn _mul(self, rhs: u8x16) -> Self::Output

fn _rem(self, rhs: u8x16) -> Self::Output

fn _clamp(self, min: u8x16, max: u8x16) -> Self::Output

fn _max(self, rhs: u8x16) -> Self::Output

fn _min(self, rhs: u8x16) -> Self::Output

impl NormalOut<u8x16> for f64

type Output = <f64x2 as NormalOutPromote<u8x16>>::Output

fn _mul_add(self, a: u8x16, b: u8x16) -> Self::Output

fn _add(self, rhs: u8x16) -> Self::Output

fn _sub(self, rhs: u8x16) -> Self::Output

fn _mul(self, rhs: u8x16) -> Self::Output

fn _rem(self, rhs: u8x16) -> Self::Output

fn _clamp(self, min: u8x16, max: u8x16) -> Self::Output

fn _max(self, rhs: u8x16) -> Self::Output

fn _min(self, rhs: u8x16) -> Self::Output

impl NormalOut<u8x16> for i8

type Output = <i8x16 as NormalOutPromote<u8x16>>::Output

fn _add(self, rhs: u8x16) -> Self::Output

fn _sub(self, rhs: u8x16) -> Self::Output

fn _mul(self, rhs: u8x16) -> Self::Output

fn _max(self, rhs: u8x16) -> Self::Output

fn _min(self, rhs: u8x16) -> Self::Output

fn _rem(self, rhs: u8x16) -> Self::Output

fn _clamp(self, min: u8x16, max: u8x16) -> Self::Output

fn _mul_add(self, a: u8x16, b: u8x16) -> Self::Output

impl NormalOut<u8x16> for i16

type Output = <i16x8 as NormalOutPromote<u8x16>>::Output

fn _mul_add(self, a: u8x16, b: u8x16) -> Self::Output

fn _add(self, rhs: u8x16) -> Self::Output

fn _sub(self, rhs: u8x16) -> Self::Output

fn _mul(self, rhs: u8x16) -> Self::Output

fn _rem(self, rhs: u8x16) -> Self::Output

fn _clamp(self, min: u8x16, max: u8x16) -> Self::Output

fn _max(self, rhs: u8x16) -> Self::Output

fn _min(self, rhs: u8x16) -> Self::Output

impl NormalOut<u8x16> for i32

type Output = <i32x4 as NormalOutPromote<u8x16>>::Output

fn _mul_add(self, a: u8x16, b: u8x16) -> Self::Output

fn _add(self, rhs: u8x16) -> Self::Output

fn _sub(self, rhs: u8x16) -> Self::Output

fn _mul(self, rhs: u8x16) -> Self::Output

fn _rem(self, rhs: u8x16) -> Self::Output

fn _clamp(self, min: u8x16, max: u8x16) -> Self::Output

fn _max(self, rhs: u8x16) -> Self::Output

fn _min(self, rhs: u8x16) -> Self::Output

impl NormalOut<u8x16> for i64

type Output = <i64x2 as NormalOutPromote<u8x16>>::Output

fn _mul_add(self, a: u8x16, b: u8x16) -> Self::Output

fn _add(self, rhs: u8x16) -> Self::Output

fn _sub(self, rhs: u8x16) -> Self::Output

fn _mul(self, rhs: u8x16) -> Self::Output

fn _rem(self, rhs: u8x16) -> Self::Output

fn _clamp(self, min: u8x16, max: u8x16) -> Self::Output

fn _max(self, rhs: u8x16) -> Self::Output

fn _min(self, rhs: u8x16) -> Self::Output

impl NormalOut<u8x16> for isize

type Output = <isizex2 as NormalOutPromote<u8x16>>::Output

fn _mul_add(self, a: u8x16, b: u8x16) -> Self::Output

fn _add(self, rhs: u8x16) -> Self::Output

fn _sub(self, rhs: u8x16) -> Self::Output

fn _mul(self, rhs: u8x16) -> Self::Output

fn _rem(self, rhs: u8x16) -> Self::Output

fn _clamp(self, min: u8x16, max: u8x16) -> Self::Output

fn _max(self, rhs: u8x16) -> Self::Output

fn _min(self, rhs: u8x16) -> Self::Output

impl NormalOut<u8x16> for u8

type Output = <u8x16 as NormalOutPromote>::Output

fn _add(self, rhs: u8x16) -> Self::Output

fn _sub(self, rhs: u8x16) -> Self::Output

fn _mul(self, rhs: u8x16) -> Self::Output

fn _max(self, rhs: u8x16) -> Self::Output

fn _min(self, rhs: u8x16) -> Self::Output

fn _rem(self, rhs: u8x16) -> Self::Output

fn _clamp(self, min: u8x16, max: u8x16) -> Self::Output

fn _mul_add(self, a: u8x16, b: u8x16) -> Self::Output

impl NormalOut<u8x16> for u16

type Output = <u16x8 as NormalOutPromote<u8x16>>::Output

fn _mul_add(self, a: u8x16, b: u8x16) -> Self::Output

fn _add(self, rhs: u8x16) -> Self::Output

fn _sub(self, rhs: u8x16) -> Self::Output

fn _mul(self, rhs: u8x16) -> Self::Output

fn _rem(self, rhs: u8x16) -> Self::Output

fn _clamp(self, min: u8x16, max: u8x16) -> Self::Output

fn _max(self, rhs: u8x16) -> Self::Output

fn _min(self, rhs: u8x16) -> Self::Output

impl NormalOut<u8x16> for u32

type Output = <u32x4 as NormalOutPromote<u8x16>>::Output

fn _mul_add(self, a: u8x16, b: u8x16) -> Self::Output

fn _add(self, rhs: u8x16) -> Self::Output

fn _sub(self, rhs: u8x16) -> Self::Output

fn _mul(self, rhs: u8x16) -> Self::Output

fn _rem(self, rhs: u8x16) -> Self::Output

fn _clamp(self, min: u8x16, max: u8x16) -> Self::Output

fn _max(self, rhs: u8x16) -> Self::Output

fn _min(self, rhs: u8x16) -> Self::Output

impl NormalOut<u8x16> for u64

type Output = <u64x2 as NormalOutPromote<u8x16>>::Output

fn _mul_add(self, a: u8x16, b: u8x16) -> Self::Output

fn _add(self, rhs: u8x16) -> Self::Output

fn _sub(self, rhs: u8x16) -> Self::Output

fn _mul(self, rhs: u8x16) -> Self::Output

fn _rem(self, rhs: u8x16) -> Self::Output

fn _clamp(self, min: u8x16, max: u8x16) -> Self::Output

fn _max(self, rhs: u8x16) -> Self::Output

fn _min(self, rhs: u8x16) -> Self::Output

impl NormalOut<u8x16> for usize

type Output = <usizex2 as NormalOutPromote<u8x16>>::Output

fn _mul_add(self, a: u8x16, b: u8x16) -> Self::Output

fn _add(self, rhs: u8x16) -> Self::Output

fn _sub(self, rhs: u8x16) -> Self::Output

fn _mul(self, rhs: u8x16) -> Self::Output

fn _rem(self, rhs: u8x16) -> Self::Output

fn _clamp(self, min: u8x16, max: u8x16) -> Self::Output

fn _max(self, rhs: u8x16) -> Self::Output

fn _min(self, rhs: u8x16) -> Self::Output

impl NormalOut<u8x16> for bf16

type Output = <bf16x8 as NormalOutPromote<u8x16>>::Output

fn _mul_add(self, a: u8x16, b: u8x16) -> Self::Output

fn _add(self, rhs: u8x16) -> Self::Output

fn _sub(self, rhs: u8x16) -> Self::Output

fn _mul(self, rhs: u8x16) -> Self::Output

fn _rem(self, rhs: u8x16) -> Self::Output

fn _clamp(self, min: u8x16, max: u8x16) -> Self::Output

fn _max(self, rhs: u8x16) -> Self::Output

fn _min(self, rhs: u8x16) -> Self::Output

impl NormalOut<u8x16> for f16

type Output = <f16x8 as NormalOutPromote<u8x16>>::Output

fn _mul_add(self, a: u8x16, b: u8x16) -> Self::Output

fn _add(self, rhs: u8x16) -> Self::Output

fn _sub(self, rhs: u8x16) -> Self::Output

fn _mul(self, rhs: u8x16) -> Self::Output

fn _rem(self, rhs: u8x16) -> Self::Output

fn _clamp(self, min: u8x16, max: u8x16) -> Self::Output

fn _max(self, rhs: u8x16) -> Self::Output

fn _min(self, rhs: u8x16) -> Self::Output

impl NormalOut<u8x16> for Complex32

type Output = <cplx32x2 as NormalOutPromote<u8x16>>::Output

fn _mul_add(self, a: u8x16, b: u8x16) -> Self::Output

fn _add(self, rhs: u8x16) -> Self::Output

fn _sub(self, rhs: u8x16) -> Self::Output

fn _mul(self, rhs: u8x16) -> Self::Output

fn _rem(self, rhs: u8x16) -> Self::Output

fn _clamp(self, min: u8x16, max: u8x16) -> Self::Output

fn _max(self, rhs: u8x16) -> Self::Output

fn _min(self, rhs: u8x16) -> Self::Output

impl NormalOut<u8x16> for Complex64

type Output = <cplx64x1 as NormalOutPromote<u8x16>>::Output

fn _mul_add(self, a: u8x16, b: u8x16) -> Self::Output

fn _add(self, rhs: u8x16) -> Self::Output

fn _sub(self, rhs: u8x16) -> Self::Output

fn _mul(self, rhs: u8x16) -> Self::Output

fn _rem(self, rhs: u8x16) -> Self::Output

fn _clamp(self, min: u8x16, max: u8x16) -> Self::Output

fn _max(self, rhs: u8x16) -> Self::Output

fn _min(self, rhs: u8x16) -> Self::Output

impl NormalOut<u16x8> for bool

type Output = <boolx16 as NormalOutPromote<u16x8>>::Output

fn _mul_add(self, a: u16x8, b: u16x8) -> Self::Output

fn _add(self, rhs: u16x8) -> Self::Output

fn _sub(self, rhs: u16x8) -> Self::Output

fn _mul(self, rhs: u16x8) -> Self::Output

fn _rem(self, rhs: u16x8) -> Self::Output

fn _clamp(self, min: u16x8, max: u16x8) -> Self::Output

fn _max(self, rhs: u16x8) -> Self::Output

fn _min(self, rhs: u16x8) -> Self::Output

impl NormalOut<u16x8> for f32

type Output = <f32x4 as NormalOutPromote<u16x8>>::Output

fn _mul_add(self, a: u16x8, b: u16x8) -> Self::Output

fn _add(self, rhs: u16x8) -> Self::Output

fn _sub(self, rhs: u16x8) -> Self::Output

fn _mul(self, rhs: u16x8) -> Self::Output

fn _rem(self, rhs: u16x8) -> Self::Output

fn _clamp(self, min: u16x8, max: u16x8) -> Self::Output

fn _max(self, rhs: u16x8) -> Self::Output

fn _min(self, rhs: u16x8) -> Self::Output

impl NormalOut<u16x8> for f64

type Output = <f64x2 as NormalOutPromote<u16x8>>::Output

fn _mul_add(self, a: u16x8, b: u16x8) -> Self::Output

fn _add(self, rhs: u16x8) -> Self::Output

fn _sub(self, rhs: u16x8) -> Self::Output

fn _mul(self, rhs: u16x8) -> Self::Output

fn _rem(self, rhs: u16x8) -> Self::Output

fn _clamp(self, min: u16x8, max: u16x8) -> Self::Output

fn _max(self, rhs: u16x8) -> Self::Output

fn _min(self, rhs: u16x8) -> Self::Output

impl NormalOut<u16x8> for i8

type Output = <i8x16 as NormalOutPromote<u16x8>>::Output

fn _mul_add(self, a: u16x8, b: u16x8) -> Self::Output

fn _add(self, rhs: u16x8) -> Self::Output

fn _sub(self, rhs: u16x8) -> Self::Output

fn _mul(self, rhs: u16x8) -> Self::Output

fn _rem(self, rhs: u16x8) -> Self::Output

fn _clamp(self, min: u16x8, max: u16x8) -> Self::Output

fn _max(self, rhs: u16x8) -> Self::Output

fn _min(self, rhs: u16x8) -> Self::Output

impl NormalOut<u16x8> for i16

type Output = <i16x8 as NormalOutPromote<u16x8>>::Output

fn _add(self, rhs: u16x8) -> Self::Output

fn _sub(self, rhs: u16x8) -> Self::Output

fn _mul(self, rhs: u16x8) -> Self::Output

fn _max(self, rhs: u16x8) -> Self::Output

fn _min(self, rhs: u16x8) -> Self::Output

fn _rem(self, rhs: u16x8) -> Self::Output

fn _clamp(self, min: u16x8, max: u16x8) -> Self::Output

fn _mul_add(self, a: u16x8, b: u16x8) -> Self::Output

impl NormalOut<u16x8> for i32

type Output = <i32x4 as NormalOutPromote<u16x8>>::Output

fn _mul_add(self, a: u16x8, b: u16x8) -> Self::Output

fn _add(self, rhs: u16x8) -> Self::Output

fn _sub(self, rhs: u16x8) -> Self::Output

fn _mul(self, rhs: u16x8) -> Self::Output

fn _rem(self, rhs: u16x8) -> Self::Output

fn _clamp(self, min: u16x8, max: u16x8) -> Self::Output

fn _max(self, rhs: u16x8) -> Self::Output

fn _min(self, rhs: u16x8) -> Self::Output

impl NormalOut<u16x8> for i64

type Output = <i64x2 as NormalOutPromote<u16x8>>::Output

fn _mul_add(self, a: u16x8, b: u16x8) -> Self::Output

fn _add(self, rhs: u16x8) -> Self::Output

fn _sub(self, rhs: u16x8) -> Self::Output

fn _mul(self, rhs: u16x8) -> Self::Output

fn _rem(self, rhs: u16x8) -> Self::Output

fn _clamp(self, min: u16x8, max: u16x8) -> Self::Output

fn _max(self, rhs: u16x8) -> Self::Output

fn _min(self, rhs: u16x8) -> Self::Output

impl NormalOut<u16x8> for isize

type Output = <isizex2 as NormalOutPromote<u16x8>>::Output

fn _mul_add(self, a: u16x8, b: u16x8) -> Self::Output

fn _add(self, rhs: u16x8) -> Self::Output

fn _sub(self, rhs: u16x8) -> Self::Output

fn _mul(self, rhs: u16x8) -> Self::Output

fn _rem(self, rhs: u16x8) -> Self::Output

fn _clamp(self, min: u16x8, max: u16x8) -> Self::Output

fn _max(self, rhs: u16x8) -> Self::Output

fn _min(self, rhs: u16x8) -> Self::Output

impl NormalOut<u16x8> for u8

type Output = <u8x16 as NormalOutPromote<u16x8>>::Output

fn _mul_add(self, a: u16x8, b: u16x8) -> Self::Output

fn _add(self, rhs: u16x8) -> Self::Output

fn _sub(self, rhs: u16x8) -> Self::Output

fn _mul(self, rhs: u16x8) -> Self::Output

fn _rem(self, rhs: u16x8) -> Self::Output

fn _clamp(self, min: u16x8, max: u16x8) -> Self::Output

fn _max(self, rhs: u16x8) -> Self::Output

fn _min(self, rhs: u16x8) -> Self::Output

impl NormalOut<u16x8> for u16

type Output = <u16x8 as NormalOutPromote>::Output

fn _add(self, rhs: u16x8) -> Self::Output

fn _sub(self, rhs: u16x8) -> Self::Output

fn _mul(self, rhs: u16x8) -> Self::Output

fn _max(self, rhs: u16x8) -> Self::Output

fn _min(self, rhs: u16x8) -> Self::Output

fn _rem(self, rhs: u16x8) -> Self::Output

fn _clamp(self, min: u16x8, max: u16x8) -> Self::Output

fn _mul_add(self, a: u16x8, b: u16x8) -> Self::Output

impl NormalOut<u16x8> for u32

type Output = <u32x4 as NormalOutPromote<u16x8>>::Output

fn _mul_add(self, a: u16x8, b: u16x8) -> Self::Output

fn _add(self, rhs: u16x8) -> Self::Output

fn _sub(self, rhs: u16x8) -> Self::Output

fn _mul(self, rhs: u16x8) -> Self::Output

fn _rem(self, rhs: u16x8) -> Self::Output

fn _clamp(self, min: u16x8, max: u16x8) -> Self::Output

fn _max(self, rhs: u16x8) -> Self::Output

fn _min(self, rhs: u16x8) -> Self::Output

impl NormalOut<u16x8> for u64

type Output = <u64x2 as NormalOutPromote<u16x8>>::Output

fn _mul_add(self, a: u16x8, b: u16x8) -> Self::Output

fn _add(self, rhs: u16x8) -> Self::Output

fn _sub(self, rhs: u16x8) -> Self::Output

fn _mul(self, rhs: u16x8) -> Self::Output

fn _rem(self, rhs: u16x8) -> Self::Output

fn _clamp(self, min: u16x8, max: u16x8) -> Self::Output

fn _max(self, rhs: u16x8) -> Self::Output

fn _min(self, rhs: u16x8) -> Self::Output

impl NormalOut<u16x8> for usize

type Output = <usizex2 as NormalOutPromote<u16x8>>::Output

fn _mul_add(self, a: u16x8, b: u16x8) -> Self::Output

fn _add(self, rhs: u16x8) -> Self::Output

fn _sub(self, rhs: u16x8) -> Self::Output

fn _mul(self, rhs: u16x8) -> Self::Output

fn _rem(self, rhs: u16x8) -> Self::Output

fn _clamp(self, min: u16x8, max: u16x8) -> Self::Output

fn _max(self, rhs: u16x8) -> Self::Output

fn _min(self, rhs: u16x8) -> Self::Output

impl NormalOut<u16x8> for bf16

type Output = <bf16x8 as NormalOutPromote<u16x8>>::Output

fn _add(self, rhs: u16x8) -> Self::Output

fn _sub(self, rhs: u16x8) -> Self::Output

fn _mul(self, rhs: u16x8) -> Self::Output

fn _max(self, rhs: u16x8) -> Self::Output

fn _min(self, rhs: u16x8) -> Self::Output

fn _rem(self, rhs: u16x8) -> Self::Output

fn _clamp(self, min: u16x8, max: u16x8) -> Self::Output

fn _mul_add(self, a: u16x8, b: u16x8) -> Self::Output

impl NormalOut<u16x8> for f16

type Output = <f16x8 as NormalOutPromote<u16x8>>::Output

fn _add(self, rhs: u16x8) -> Self::Output

fn _sub(self, rhs: u16x8) -> Self::Output

fn _mul(self, rhs: u16x8) -> Self::Output

fn _max(self, rhs: u16x8) -> Self::Output

fn _min(self, rhs: u16x8) -> Self::Output

fn _rem(self, rhs: u16x8) -> Self::Output

fn _clamp(self, min: u16x8, max: u16x8) -> Self::Output

fn _mul_add(self, a: u16x8, b: u16x8) -> Self::Output

impl NormalOut<u16x8> for Complex32

type Output = <cplx32x2 as NormalOutPromote<u16x8>>::Output

fn _mul_add(self, a: u16x8, b: u16x8) -> Self::Output

fn _add(self, rhs: u16x8) -> Self::Output

fn _sub(self, rhs: u16x8) -> Self::Output

fn _mul(self, rhs: u16x8) -> Self::Output

fn _rem(self, rhs: u16x8) -> Self::Output

fn _clamp(self, min: u16x8, max: u16x8) -> Self::Output

fn _max(self, rhs: u16x8) -> Self::Output

fn _min(self, rhs: u16x8) -> Self::Output

impl NormalOut<u16x8> for Complex64

type Output = <cplx64x1 as NormalOutPromote<u16x8>>::Output

fn _mul_add(self, a: u16x8, b: u16x8) -> Self::Output

fn _add(self, rhs: u16x8) -> Self::Output

fn _sub(self, rhs: u16x8) -> Self::Output

fn _mul(self, rhs: u16x8) -> Self::Output

fn _rem(self, rhs: u16x8) -> Self::Output

fn _clamp(self, min: u16x8, max: u16x8) -> Self::Output

fn _max(self, rhs: u16x8) -> Self::Output

fn _min(self, rhs: u16x8) -> Self::Output

impl NormalOut<u32x4> for bool

type Output = <boolx16 as NormalOutPromote<u32x4>>::Output

fn _mul_add(self, a: u32x4, b: u32x4) -> Self::Output

fn _add(self, rhs: u32x4) -> Self::Output

fn _sub(self, rhs: u32x4) -> Self::Output

fn _mul(self, rhs: u32x4) -> Self::Output

fn _rem(self, rhs: u32x4) -> Self::Output

fn _clamp(self, min: u32x4, max: u32x4) -> Self::Output

fn _max(self, rhs: u32x4) -> Self::Output

fn _min(self, rhs: u32x4) -> Self::Output

impl NormalOut<u32x4> for f32

type Output = <f32x4 as NormalOutPromote<u32x4>>::Output

fn _add(self, rhs: u32x4) -> Self::Output

fn _sub(self, rhs: u32x4) -> Self::Output

fn _mul(self, rhs: u32x4) -> Self::Output

fn _max(self, rhs: u32x4) -> Self::Output

fn _min(self, rhs: u32x4) -> Self::Output

fn _rem(self, rhs: u32x4) -> Self::Output

fn _clamp(self, min: u32x4, max: u32x4) -> Self::Output

fn _mul_add(self, a: u32x4, b: u32x4) -> Self::Output

impl NormalOut<u32x4> for f64

type Output = <f64x2 as NormalOutPromote<u32x4>>::Output

fn _mul_add(self, a: u32x4, b: u32x4) -> Self::Output

fn _add(self, rhs: u32x4) -> Self::Output

fn _sub(self, rhs: u32x4) -> Self::Output

fn _mul(self, rhs: u32x4) -> Self::Output

fn _rem(self, rhs: u32x4) -> Self::Output

fn _clamp(self, min: u32x4, max: u32x4) -> Self::Output

fn _max(self, rhs: u32x4) -> Self::Output

fn _min(self, rhs: u32x4) -> Self::Output

impl NormalOut<u32x4> for i8

type Output = <i8x16 as NormalOutPromote<u32x4>>::Output

fn _mul_add(self, a: u32x4, b: u32x4) -> Self::Output

fn _add(self, rhs: u32x4) -> Self::Output

fn _sub(self, rhs: u32x4) -> Self::Output

fn _mul(self, rhs: u32x4) -> Self::Output

fn _rem(self, rhs: u32x4) -> Self::Output

fn _clamp(self, min: u32x4, max: u32x4) -> Self::Output

fn _max(self, rhs: u32x4) -> Self::Output

fn _min(self, rhs: u32x4) -> Self::Output

impl NormalOut<u32x4> for i16

type Output = <i16x8 as NormalOutPromote<u32x4>>::Output

fn _mul_add(self, a: u32x4, b: u32x4) -> Self::Output

fn _add(self, rhs: u32x4) -> Self::Output

fn _sub(self, rhs: u32x4) -> Self::Output

fn _mul(self, rhs: u32x4) -> Self::Output

fn _rem(self, rhs: u32x4) -> Self::Output

fn _clamp(self, min: u32x4, max: u32x4) -> Self::Output

fn _max(self, rhs: u32x4) -> Self::Output

fn _min(self, rhs: u32x4) -> Self::Output

impl NormalOut<u32x4> for i32

type Output = <i32x4 as NormalOutPromote<u32x4>>::Output

fn _add(self, rhs: u32x4) -> Self::Output

fn _sub(self, rhs: u32x4) -> Self::Output

fn _mul(self, rhs: u32x4) -> Self::Output

fn _max(self, rhs: u32x4) -> Self::Output

fn _min(self, rhs: u32x4) -> Self::Output

fn _rem(self, rhs: u32x4) -> Self::Output

fn _clamp(self, min: u32x4, max: u32x4) -> Self::Output

fn _mul_add(self, a: u32x4, b: u32x4) -> Self::Output

impl NormalOut<u32x4> for i64

type Output = <i64x2 as NormalOutPromote<u32x4>>::Output

fn _mul_add(self, a: u32x4, b: u32x4) -> Self::Output

fn _add(self, rhs: u32x4) -> Self::Output

fn _sub(self, rhs: u32x4) -> Self::Output

fn _mul(self, rhs: u32x4) -> Self::Output

fn _rem(self, rhs: u32x4) -> Self::Output

fn _clamp(self, min: u32x4, max: u32x4) -> Self::Output

fn _max(self, rhs: u32x4) -> Self::Output

fn _min(self, rhs: u32x4) -> Self::Output

impl NormalOut<u32x4> for isize

type Output = <isizex2 as NormalOutPromote<u32x4>>::Output

fn _mul_add(self, a: u32x4, b: u32x4) -> Self::Output

fn _add(self, rhs: u32x4) -> Self::Output

fn _sub(self, rhs: u32x4) -> Self::Output

fn _mul(self, rhs: u32x4) -> Self::Output

fn _rem(self, rhs: u32x4) -> Self::Output

fn _clamp(self, min: u32x4, max: u32x4) -> Self::Output

fn _max(self, rhs: u32x4) -> Self::Output

fn _min(self, rhs: u32x4) -> Self::Output

impl NormalOut<u32x4> for u8

type Output = <u8x16 as NormalOutPromote<u32x4>>::Output

fn _mul_add(self, a: u32x4, b: u32x4) -> Self::Output

fn _add(self, rhs: u32x4) -> Self::Output

fn _sub(self, rhs: u32x4) -> Self::Output

fn _mul(self, rhs: u32x4) -> Self::Output

fn _rem(self, rhs: u32x4) -> Self::Output

fn _clamp(self, min: u32x4, max: u32x4) -> Self::Output

fn _max(self, rhs: u32x4) -> Self::Output

fn _min(self, rhs: u32x4) -> Self::Output

impl NormalOut<u32x4> for u16

type Output = <u16x8 as NormalOutPromote<u32x4>>::Output

fn _mul_add(self, a: u32x4, b: u32x4) -> Self::Output

fn _add(self, rhs: u32x4) -> Self::Output

fn _sub(self, rhs: u32x4) -> Self::Output

fn _mul(self, rhs: u32x4) -> Self::Output

fn _rem(self, rhs: u32x4) -> Self::Output

fn _clamp(self, min: u32x4, max: u32x4) -> Self::Output

fn _max(self, rhs: u32x4) -> Self::Output

fn _min(self, rhs: u32x4) -> Self::Output

impl NormalOut<u32x4> for u32

type Output = <u32x4 as NormalOutPromote>::Output

fn _add(self, rhs: u32x4) -> Self::Output

fn _sub(self, rhs: u32x4) -> Self::Output

fn _mul(self, rhs: u32x4) -> Self::Output

fn _max(self, rhs: u32x4) -> Self::Output

fn _min(self, rhs: u32x4) -> Self::Output

fn _rem(self, rhs: u32x4) -> Self::Output

fn _clamp(self, min: u32x4, max: u32x4) -> Self::Output

fn _mul_add(self, a: u32x4, b: u32x4) -> Self::Output

impl NormalOut<u32x4> for u64

type Output = <u64x2 as NormalOutPromote<u32x4>>::Output

fn _mul_add(self, a: u32x4, b: u32x4) -> Self::Output

fn _add(self, rhs: u32x4) -> Self::Output

fn _sub(self, rhs: u32x4) -> Self::Output

fn _mul(self, rhs: u32x4) -> Self::Output

fn _rem(self, rhs: u32x4) -> Self::Output

fn _clamp(self, min: u32x4, max: u32x4) -> Self::Output

fn _max(self, rhs: u32x4) -> Self::Output

fn _min(self, rhs: u32x4) -> Self::Output

impl NormalOut<u32x4> for usize

type Output = <usizex2 as NormalOutPromote<u32x4>>::Output

fn _mul_add(self, a: u32x4, b: u32x4) -> Self::Output

fn _add(self, rhs: u32x4) -> Self::Output

fn _sub(self, rhs: u32x4) -> Self::Output

fn _mul(self, rhs: u32x4) -> Self::Output

fn _rem(self, rhs: u32x4) -> Self::Output

fn _clamp(self, min: u32x4, max: u32x4) -> Self::Output

fn _max(self, rhs: u32x4) -> Self::Output

fn _min(self, rhs: u32x4) -> Self::Output

impl NormalOut<u32x4> for bf16

type Output = <bf16x8 as NormalOutPromote<u32x4>>::Output

fn _mul_add(self, a: u32x4, b: u32x4) -> Self::Output

fn _add(self, rhs: u32x4) -> Self::Output

fn _sub(self, rhs: u32x4) -> Self::Output

fn _mul(self, rhs: u32x4) -> Self::Output

fn _rem(self, rhs: u32x4) -> Self::Output

fn _clamp(self, min: u32x4, max: u32x4) -> Self::Output

fn _max(self, rhs: u32x4) -> Self::Output

fn _min(self, rhs: u32x4) -> Self::Output

impl NormalOut<u32x4> for f16

type Output = <f16x8 as NormalOutPromote<u32x4>>::Output

fn _mul_add(self, a: u32x4, b: u32x4) -> Self::Output

fn _add(self, rhs: u32x4) -> Self::Output

fn _sub(self, rhs: u32x4) -> Self::Output

fn _mul(self, rhs: u32x4) -> Self::Output

fn _rem(self, rhs: u32x4) -> Self::Output

fn _clamp(self, min: u32x4, max: u32x4) -> Self::Output

fn _max(self, rhs: u32x4) -> Self::Output

fn _min(self, rhs: u32x4) -> Self::Output

impl NormalOut<u32x4> for Complex32

type Output = <cplx32x2 as NormalOutPromote<u32x4>>::Output

fn _mul_add(self, a: u32x4, b: u32x4) -> Self::Output

fn _add(self, rhs: u32x4) -> Self::Output

fn _sub(self, rhs: u32x4) -> Self::Output

fn _mul(self, rhs: u32x4) -> Self::Output

fn _rem(self, rhs: u32x4) -> Self::Output

fn _clamp(self, min: u32x4, max: u32x4) -> Self::Output

fn _max(self, rhs: u32x4) -> Self::Output

fn _min(self, rhs: u32x4) -> Self::Output

impl NormalOut<u32x4> for Complex64

type Output = <cplx64x1 as NormalOutPromote<u32x4>>::Output

fn _mul_add(self, a: u32x4, b: u32x4) -> Self::Output

fn _add(self, rhs: u32x4) -> Self::Output

fn _sub(self, rhs: u32x4) -> Self::Output

fn _mul(self, rhs: u32x4) -> Self::Output

fn _rem(self, rhs: u32x4) -> Self::Output

fn _clamp(self, min: u32x4, max: u32x4) -> Self::Output

fn _max(self, rhs: u32x4) -> Self::Output

fn _min(self, rhs: u32x4) -> Self::Output

impl NormalOut<u64x2> for bool

type Output = <boolx16 as NormalOutPromote<u64x2>>::Output

fn _mul_add(self, a: u64x2, b: u64x2) -> Self::Output

fn _add(self, rhs: u64x2) -> Self::Output

fn _sub(self, rhs: u64x2) -> Self::Output

fn _mul(self, rhs: u64x2) -> Self::Output

fn _rem(self, rhs: u64x2) -> Self::Output

fn _clamp(self, min: u64x2, max: u64x2) -> Self::Output

fn _max(self, rhs: u64x2) -> Self::Output

fn _min(self, rhs: u64x2) -> Self::Output

impl NormalOut<u64x2> for f32

type Output = <f32x4 as NormalOutPromote<u64x2>>::Output

fn _mul_add(self, a: u64x2, b: u64x2) -> Self::Output

fn _add(self, rhs: u64x2) -> Self::Output

fn _sub(self, rhs: u64x2) -> Self::Output

fn _mul(self, rhs: u64x2) -> Self::Output

fn _rem(self, rhs: u64x2) -> Self::Output

fn _clamp(self, min: u64x2, max: u64x2) -> Self::Output

fn _max(self, rhs: u64x2) -> Self::Output

fn _min(self, rhs: u64x2) -> Self::Output

impl NormalOut<u64x2> for f64

type Output = <f64x2 as NormalOutPromote<u64x2>>::Output

fn _add(self, rhs: u64x2) -> Self::Output

fn _sub(self, rhs: u64x2) -> Self::Output

fn _mul(self, rhs: u64x2) -> Self::Output

fn _max(self, rhs: u64x2) -> Self::Output

fn _min(self, rhs: u64x2) -> Self::Output

fn _rem(self, rhs: u64x2) -> Self::Output

fn _clamp(self, min: u64x2, max: u64x2) -> Self::Output

fn _mul_add(self, a: u64x2, b: u64x2) -> Self::Output

impl NormalOut<u64x2> for i8

type Output = <i8x16 as NormalOutPromote<u64x2>>::Output

fn _mul_add(self, a: u64x2, b: u64x2) -> Self::Output

fn _add(self, rhs: u64x2) -> Self::Output

fn _sub(self, rhs: u64x2) -> Self::Output

fn _mul(self, rhs: u64x2) -> Self::Output

fn _rem(self, rhs: u64x2) -> Self::Output

fn _clamp(self, min: u64x2, max: u64x2) -> Self::Output

fn _max(self, rhs: u64x2) -> Self::Output

fn _min(self, rhs: u64x2) -> Self::Output

impl NormalOut<u64x2> for i16

type Output = <i16x8 as NormalOutPromote<u64x2>>::Output

fn _mul_add(self, a: u64x2, b: u64x2) -> Self::Output

fn _add(self, rhs: u64x2) -> Self::Output

fn _sub(self, rhs: u64x2) -> Self::Output

fn _mul(self, rhs: u64x2) -> Self::Output

fn _rem(self, rhs: u64x2) -> Self::Output

fn _clamp(self, min: u64x2, max: u64x2) -> Self::Output

fn _max(self, rhs: u64x2) -> Self::Output

fn _min(self, rhs: u64x2) -> Self::Output

impl NormalOut<u64x2> for i32

type Output = <i32x4 as NormalOutPromote<u64x2>>::Output

fn _mul_add(self, a: u64x2, b: u64x2) -> Self::Output

fn _add(self, rhs: u64x2) -> Self::Output

fn _sub(self, rhs: u64x2) -> Self::Output

fn _mul(self, rhs: u64x2) -> Self::Output

fn _rem(self, rhs: u64x2) -> Self::Output

fn _clamp(self, min: u64x2, max: u64x2) -> Self::Output

fn _max(self, rhs: u64x2) -> Self::Output

fn _min(self, rhs: u64x2) -> Self::Output

impl NormalOut<u64x2> for i64

type Output = <i64x2 as NormalOutPromote<u64x2>>::Output

fn _add(self, rhs: u64x2) -> Self::Output

fn _sub(self, rhs: u64x2) -> Self::Output

fn _mul(self, rhs: u64x2) -> Self::Output

fn _max(self, rhs: u64x2) -> Self::Output

fn _min(self, rhs: u64x2) -> Self::Output

fn _rem(self, rhs: u64x2) -> Self::Output

fn _clamp(self, min: u64x2, max: u64x2) -> Self::Output

fn _mul_add(self, a: u64x2, b: u64x2) -> Self::Output

impl NormalOut<u64x2> for isize

type Output = <isizex2 as NormalOutPromote<u64x2>>::Output

fn _add(self, rhs: u64x2) -> Self::Output

fn _sub(self, rhs: u64x2) -> Self::Output

fn _mul(self, rhs: u64x2) -> Self::Output

fn _max(self, rhs: u64x2) -> Self::Output

fn _min(self, rhs: u64x2) -> Self::Output

fn _rem(self, rhs: u64x2) -> Self::Output

fn _clamp(self, min: u64x2, max: u64x2) -> Self::Output

fn _mul_add(self, a: u64x2, b: u64x2) -> Self::Output

impl NormalOut<u64x2> for u8

type Output = <u8x16 as NormalOutPromote<u64x2>>::Output

fn _mul_add(self, a: u64x2, b: u64x2) -> Self::Output

fn _add(self, rhs: u64x2) -> Self::Output

fn _sub(self, rhs: u64x2) -> Self::Output

fn _mul(self, rhs: u64x2) -> Self::Output

fn _rem(self, rhs: u64x2) -> Self::Output

fn _clamp(self, min: u64x2, max: u64x2) -> Self::Output

fn _max(self, rhs: u64x2) -> Self::Output

fn _min(self, rhs: u64x2) -> Self::Output

impl NormalOut<u64x2> for u16

type Output = <u16x8 as NormalOutPromote<u64x2>>::Output

fn _mul_add(self, a: u64x2, b: u64x2) -> Self::Output

fn _add(self, rhs: u64x2) -> Self::Output

fn _sub(self, rhs: u64x2) -> Self::Output

fn _mul(self, rhs: u64x2) -> Self::Output

fn _rem(self, rhs: u64x2) -> Self::Output

fn _clamp(self, min: u64x2, max: u64x2) -> Self::Output

fn _max(self, rhs: u64x2) -> Self::Output

fn _min(self, rhs: u64x2) -> Self::Output

impl NormalOut<u64x2> for u32

type Output = <u32x4 as NormalOutPromote<u64x2>>::Output

fn _mul_add(self, a: u64x2, b: u64x2) -> Self::Output

fn _add(self, rhs: u64x2) -> Self::Output

fn _sub(self, rhs: u64x2) -> Self::Output

fn _mul(self, rhs: u64x2) -> Self::Output

fn _rem(self, rhs: u64x2) -> Self::Output

fn _clamp(self, min: u64x2, max: u64x2) -> Self::Output

fn _max(self, rhs: u64x2) -> Self::Output

fn _min(self, rhs: u64x2) -> Self::Output

impl NormalOut<u64x2> for u64

type Output = <u64x2 as NormalOutPromote>::Output

fn _add(self, rhs: u64x2) -> Self::Output

fn _sub(self, rhs: u64x2) -> Self::Output

fn _mul(self, rhs: u64x2) -> Self::Output

fn _max(self, rhs: u64x2) -> Self::Output

fn _min(self, rhs: u64x2) -> Self::Output

fn _rem(self, rhs: u64x2) -> Self::Output

fn _clamp(self, min: u64x2, max: u64x2) -> Self::Output

fn _mul_add(self, a: u64x2, b: u64x2) -> Self::Output

impl NormalOut<u64x2> for usize

type Output = <usizex2 as NormalOutPromote<u64x2>>::Output

fn _add(self, rhs: u64x2) -> Self::Output

fn _sub(self, rhs: u64x2) -> Self::Output

fn _mul(self, rhs: u64x2) -> Self::Output

fn _max(self, rhs: u64x2) -> Self::Output

fn _min(self, rhs: u64x2) -> Self::Output

fn _rem(self, rhs: u64x2) -> Self::Output

fn _clamp(self, min: u64x2, max: u64x2) -> Self::Output

fn _mul_add(self, a: u64x2, b: u64x2) -> Self::Output

impl NormalOut<u64x2> for bf16

type Output = <bf16x8 as NormalOutPromote<u64x2>>::Output

fn _mul_add(self, a: u64x2, b: u64x2) -> Self::Output

fn _add(self, rhs: u64x2) -> Self::Output

fn _sub(self, rhs: u64x2) -> Self::Output

fn _mul(self, rhs: u64x2) -> Self::Output

fn _rem(self, rhs: u64x2) -> Self::Output

fn _clamp(self, min: u64x2, max: u64x2) -> Self::Output

fn _max(self, rhs: u64x2) -> Self::Output

fn _min(self, rhs: u64x2) -> Self::Output

impl NormalOut<u64x2> for f16

type Output = <f16x8 as NormalOutPromote<u64x2>>::Output

fn _mul_add(self, a: u64x2, b: u64x2) -> Self::Output

fn _add(self, rhs: u64x2) -> Self::Output

fn _sub(self, rhs: u64x2) -> Self::Output

fn _mul(self, rhs: u64x2) -> Self::Output

fn _rem(self, rhs: u64x2) -> Self::Output

fn _clamp(self, min: u64x2, max: u64x2) -> Self::Output

fn _max(self, rhs: u64x2) -> Self::Output

fn _min(self, rhs: u64x2) -> Self::Output

impl NormalOut<u64x2> for Complex32

type Output = <cplx32x2 as NormalOutPromote<u64x2>>::Output

fn _add(self, rhs: u64x2) -> Self::Output

fn _sub(self, rhs: u64x2) -> Self::Output

fn _mul(self, rhs: u64x2) -> Self::Output

fn _max(self, rhs: u64x2) -> Self::Output

fn _min(self, rhs: u64x2) -> Self::Output

fn _rem(self, rhs: u64x2) -> Self::Output

fn _clamp(self, min: u64x2, max: u64x2) -> Self::Output

fn _mul_add(self, a: u64x2, b: u64x2) -> Self::Output

impl NormalOut<u64x2> for Complex64

type Output = <cplx64x1 as NormalOutPromote<u64x2>>::Output

fn _mul_add(self, a: u64x2, b: u64x2) -> Self::Output

fn _add(self, rhs: u64x2) -> Self::Output

fn _sub(self, rhs: u64x2) -> Self::Output

fn _mul(self, rhs: u64x2) -> Self::Output

fn _rem(self, rhs: u64x2) -> Self::Output

fn _clamp(self, min: u64x2, max: u64x2) -> Self::Output

fn _max(self, rhs: u64x2) -> Self::Output

fn _min(self, rhs: u64x2) -> Self::Output

impl NormalOut<usizex2> for bool

type Output = <boolx16 as NormalOutPromote<usizex2>>::Output

fn _mul_add(self, a: usizex2, b: usizex2) -> Self::Output

fn _add(self, rhs: usizex2) -> Self::Output

fn _sub(self, rhs: usizex2) -> Self::Output

fn _mul(self, rhs: usizex2) -> Self::Output

fn _rem(self, rhs: usizex2) -> Self::Output

fn _clamp(self, min: usizex2, max: usizex2) -> Self::Output

fn _max(self, rhs: usizex2) -> Self::Output

fn _min(self, rhs: usizex2) -> Self::Output

impl NormalOut<usizex2> for f32

type Output = <f32x4 as NormalOutPromote<usizex2>>::Output

fn _mul_add(self, a: usizex2, b: usizex2) -> Self::Output

fn _add(self, rhs: usizex2) -> Self::Output

fn _sub(self, rhs: usizex2) -> Self::Output

fn _mul(self, rhs: usizex2) -> Self::Output

fn _rem(self, rhs: usizex2) -> Self::Output

fn _clamp(self, min: usizex2, max: usizex2) -> Self::Output

fn _max(self, rhs: usizex2) -> Self::Output

fn _min(self, rhs: usizex2) -> Self::Output

impl NormalOut<usizex2> for f64

type Output = <f64x2 as NormalOutPromote<usizex2>>::Output

fn _add(self, rhs: usizex2) -> Self::Output

fn _sub(self, rhs: usizex2) -> Self::Output

fn _mul(self, rhs: usizex2) -> Self::Output

fn _max(self, rhs: usizex2) -> Self::Output

fn _min(self, rhs: usizex2) -> Self::Output

fn _rem(self, rhs: usizex2) -> Self::Output

fn _clamp(self, min: usizex2, max: usizex2) -> Self::Output

fn _mul_add(self, a: usizex2, b: usizex2) -> Self::Output

impl NormalOut<usizex2> for i8

type Output = <i8x16 as NormalOutPromote<usizex2>>::Output

fn _mul_add(self, a: usizex2, b: usizex2) -> Self::Output

fn _add(self, rhs: usizex2) -> Self::Output

fn _sub(self, rhs: usizex2) -> Self::Output

fn _mul(self, rhs: usizex2) -> Self::Output

fn _rem(self, rhs: usizex2) -> Self::Output

fn _clamp(self, min: usizex2, max: usizex2) -> Self::Output

fn _max(self, rhs: usizex2) -> Self::Output

fn _min(self, rhs: usizex2) -> Self::Output

impl NormalOut<usizex2> for i16

type Output = <i16x8 as NormalOutPromote<usizex2>>::Output

fn _mul_add(self, a: usizex2, b: usizex2) -> Self::Output

fn _add(self, rhs: usizex2) -> Self::Output

fn _sub(self, rhs: usizex2) -> Self::Output

fn _mul(self, rhs: usizex2) -> Self::Output

fn _rem(self, rhs: usizex2) -> Self::Output

fn _clamp(self, min: usizex2, max: usizex2) -> Self::Output

fn _max(self, rhs: usizex2) -> Self::Output

fn _min(self, rhs: usizex2) -> Self::Output

impl NormalOut<usizex2> for i32

type Output = <i32x4 as NormalOutPromote<usizex2>>::Output

fn _mul_add(self, a: usizex2, b: usizex2) -> Self::Output

fn _add(self, rhs: usizex2) -> Self::Output

fn _sub(self, rhs: usizex2) -> Self::Output

fn _mul(self, rhs: usizex2) -> Self::Output

fn _rem(self, rhs: usizex2) -> Self::Output

fn _clamp(self, min: usizex2, max: usizex2) -> Self::Output

fn _max(self, rhs: usizex2) -> Self::Output

fn _min(self, rhs: usizex2) -> Self::Output

impl NormalOut<usizex2> for i64

type Output = <i64x2 as NormalOutPromote<usizex2>>::Output

fn _add(self, rhs: usizex2) -> Self::Output

fn _sub(self, rhs: usizex2) -> Self::Output

fn _mul(self, rhs: usizex2) -> Self::Output

fn _max(self, rhs: usizex2) -> Self::Output

fn _min(self, rhs: usizex2) -> Self::Output

fn _rem(self, rhs: usizex2) -> Self::Output

fn _clamp(self, min: usizex2, max: usizex2) -> Self::Output

fn _mul_add(self, a: usizex2, b: usizex2) -> Self::Output

impl NormalOut<usizex2> for isize

type Output = <isizex2 as NormalOutPromote<usizex2>>::Output

fn _add(self, rhs: usizex2) -> Self::Output

fn _sub(self, rhs: usizex2) -> Self::Output

fn _mul(self, rhs: usizex2) -> Self::Output

fn _max(self, rhs: usizex2) -> Self::Output

fn _min(self, rhs: usizex2) -> Self::Output

fn _rem(self, rhs: usizex2) -> Self::Output

fn _clamp(self, min: usizex2, max: usizex2) -> Self::Output

fn _mul_add(self, a: usizex2, b: usizex2) -> Self::Output

impl NormalOut<usizex2> for u8

type Output = <u8x16 as NormalOutPromote<usizex2>>::Output

fn _mul_add(self, a: usizex2, b: usizex2) -> Self::Output

fn _add(self, rhs: usizex2) -> Self::Output

fn _sub(self, rhs: usizex2) -> Self::Output

fn _mul(self, rhs: usizex2) -> Self::Output

fn _rem(self, rhs: usizex2) -> Self::Output

fn _clamp(self, min: usizex2, max: usizex2) -> Self::Output

fn _max(self, rhs: usizex2) -> Self::Output

fn _min(self, rhs: usizex2) -> Self::Output

impl NormalOut<usizex2> for u16

type Output = <u16x8 as NormalOutPromote<usizex2>>::Output

fn _mul_add(self, a: usizex2, b: usizex2) -> Self::Output

fn _add(self, rhs: usizex2) -> Self::Output

fn _sub(self, rhs: usizex2) -> Self::Output

fn _mul(self, rhs: usizex2) -> Self::Output

fn _rem(self, rhs: usizex2) -> Self::Output

fn _clamp(self, min: usizex2, max: usizex2) -> Self::Output

fn _max(self, rhs: usizex2) -> Self::Output

fn _min(self, rhs: usizex2) -> Self::Output

impl NormalOut<usizex2> for u32

type Output = <u32x4 as NormalOutPromote<usizex2>>::Output

fn _mul_add(self, a: usizex2, b: usizex2) -> Self::Output

fn _add(self, rhs: usizex2) -> Self::Output

fn _sub(self, rhs: usizex2) -> Self::Output

fn _mul(self, rhs: usizex2) -> Self::Output

fn _rem(self, rhs: usizex2) -> Self::Output

fn _clamp(self, min: usizex2, max: usizex2) -> Self::Output

fn _max(self, rhs: usizex2) -> Self::Output

fn _min(self, rhs: usizex2) -> Self::Output

impl NormalOut<usizex2> for u64

type Output = <u64x2 as NormalOutPromote<usizex2>>::Output

fn _add(self, rhs: usizex2) -> Self::Output

fn _sub(self, rhs: usizex2) -> Self::Output

fn _mul(self, rhs: usizex2) -> Self::Output

fn _max(self, rhs: usizex2) -> Self::Output

fn _min(self, rhs: usizex2) -> Self::Output

fn _rem(self, rhs: usizex2) -> Self::Output

fn _clamp(self, min: usizex2, max: usizex2) -> Self::Output

fn _mul_add(self, a: usizex2, b: usizex2) -> Self::Output

impl NormalOut<usizex2> for usize

type Output = <usizex2 as NormalOutPromote>::Output

fn _add(self, rhs: usizex2) -> Self::Output

fn _sub(self, rhs: usizex2) -> Self::Output

fn _mul(self, rhs: usizex2) -> Self::Output

fn _max(self, rhs: usizex2) -> Self::Output

fn _min(self, rhs: usizex2) -> Self::Output

fn _rem(self, rhs: usizex2) -> Self::Output

fn _clamp(self, min: usizex2, max: usizex2) -> Self::Output

fn _mul_add(self, a: usizex2, b: usizex2) -> Self::Output

impl NormalOut<usizex2> for bf16

type Output = <bf16x8 as NormalOutPromote<usizex2>>::Output

fn _mul_add(self, a: usizex2, b: usizex2) -> Self::Output

fn _add(self, rhs: usizex2) -> Self::Output

fn _sub(self, rhs: usizex2) -> Self::Output

fn _mul(self, rhs: usizex2) -> Self::Output

fn _rem(self, rhs: usizex2) -> Self::Output

fn _clamp(self, min: usizex2, max: usizex2) -> Self::Output

fn _max(self, rhs: usizex2) -> Self::Output

fn _min(self, rhs: usizex2) -> Self::Output

impl NormalOut<usizex2> for f16

type Output = <f16x8 as NormalOutPromote<usizex2>>::Output

fn _mul_add(self, a: usizex2, b: usizex2) -> Self::Output

fn _add(self, rhs: usizex2) -> Self::Output

fn _sub(self, rhs: usizex2) -> Self::Output

fn _mul(self, rhs: usizex2) -> Self::Output

fn _rem(self, rhs: usizex2) -> Self::Output

fn _clamp(self, min: usizex2, max: usizex2) -> Self::Output

fn _max(self, rhs: usizex2) -> Self::Output

fn _min(self, rhs: usizex2) -> Self::Output

impl NormalOut<usizex2> for Complex32

type Output = <cplx32x2 as NormalOutPromote<usizex2>>::Output

fn _add(self, rhs: usizex2) -> Self::Output

fn _sub(self, rhs: usizex2) -> Self::Output

fn _mul(self, rhs: usizex2) -> Self::Output

fn _max(self, rhs: usizex2) -> Self::Output

fn _min(self, rhs: usizex2) -> Self::Output

fn _rem(self, rhs: usizex2) -> Self::Output

fn _clamp(self, min: usizex2, max: usizex2) -> Self::Output

fn _mul_add(self, a: usizex2, b: usizex2) -> Self::Output

impl NormalOut<usizex2> for Complex64

type Output = <cplx64x1 as NormalOutPromote<usizex2>>::Output

fn _mul_add(self, a: usizex2, b: usizex2) -> Self::Output

fn _add(self, rhs: usizex2) -> Self::Output

fn _sub(self, rhs: usizex2) -> Self::Output

fn _mul(self, rhs: usizex2) -> Self::Output

fn _rem(self, rhs: usizex2) -> Self::Output

fn _clamp(self, min: usizex2, max: usizex2) -> Self::Output

fn _max(self, rhs: usizex2) -> Self::Output

fn _min(self, rhs: usizex2) -> Self::Output

impl NormalOut<bf16> for bool

type Output = <bool as NormalOutPromote<bf16>>::Output

fn _clamp(self, min: bf16, max: bf16) -> Self::Output

fn _mul_add(self, a: bf16, b: bf16) -> Self::Output

fn _add(self, rhs: bf16) -> Self::Output

fn _sub(self, rhs: bf16) -> Self::Output

fn _mul(self, rhs: bf16) -> Self::Output

fn _rem(self, rhs: bf16) -> Self::Output

fn _max(self, rhs: bf16) -> Self::Output

fn _min(self, rhs: bf16) -> Self::Output

impl NormalOut<bf16> for f32

type Output = <f32 as NormalOutPromote<bf16>>::Output

fn _clamp(self, min: bf16, max: bf16) -> Self::Output

fn _mul_add(self, a: bf16, b: bf16) -> Self::Output

fn _add(self, rhs: bf16) -> Self::Output

fn _sub(self, rhs: bf16) -> Self::Output

fn _mul(self, rhs: bf16) -> Self::Output

fn _rem(self, rhs: bf16) -> Self::Output

fn _max(self, rhs: bf16) -> Self::Output

fn _min(self, rhs: bf16) -> Self::Output

impl NormalOut<bf16> for f64

type Output = <f64 as NormalOutPromote<bf16>>::Output

fn _clamp(self, min: bf16, max: bf16) -> Self::Output

fn _mul_add(self, a: bf16, b: bf16) -> Self::Output

fn _add(self, rhs: bf16) -> Self::Output

fn _sub(self, rhs: bf16) -> Self::Output

fn _mul(self, rhs: bf16) -> Self::Output

fn _rem(self, rhs: bf16) -> Self::Output

fn _max(self, rhs: bf16) -> Self::Output

fn _min(self, rhs: bf16) -> Self::Output

impl NormalOut<bf16> for i8

type Output = <i8 as NormalOutPromote<bf16>>::Output

fn _clamp(self, min: bf16, max: bf16) -> Self::Output

fn _mul_add(self, a: bf16, b: bf16) -> Self::Output

fn _add(self, rhs: bf16) -> Self::Output

fn _sub(self, rhs: bf16) -> Self::Output

fn _mul(self, rhs: bf16) -> Self::Output

fn _rem(self, rhs: bf16) -> Self::Output

fn _max(self, rhs: bf16) -> Self::Output

fn _min(self, rhs: bf16) -> Self::Output

impl NormalOut<bf16> for i16

type Output = <i16 as NormalOutPromote<bf16>>::Output

fn _clamp(self, min: bf16, max: bf16) -> Self::Output

fn _mul_add(self, a: bf16, b: bf16) -> Self::Output

fn _add(self, rhs: bf16) -> Self::Output

fn _sub(self, rhs: bf16) -> Self::Output

fn _mul(self, rhs: bf16) -> Self::Output

fn _rem(self, rhs: bf16) -> Self::Output

fn _max(self, rhs: bf16) -> Self::Output

fn _min(self, rhs: bf16) -> Self::Output

impl NormalOut<bf16> for i32

type Output = <i32 as NormalOutPromote<bf16>>::Output

fn _clamp(self, min: bf16, max: bf16) -> Self::Output

fn _mul_add(self, a: bf16, b: bf16) -> Self::Output

fn _add(self, rhs: bf16) -> Self::Output

fn _sub(self, rhs: bf16) -> Self::Output

fn _mul(self, rhs: bf16) -> Self::Output

fn _rem(self, rhs: bf16) -> Self::Output

fn _max(self, rhs: bf16) -> Self::Output

fn _min(self, rhs: bf16) -> Self::Output

impl NormalOut<bf16> for i64

type Output = <i64 as NormalOutPromote<bf16>>::Output

fn _clamp(self, min: bf16, max: bf16) -> Self::Output

fn _mul_add(self, a: bf16, b: bf16) -> Self::Output

fn _add(self, rhs: bf16) -> Self::Output

fn _sub(self, rhs: bf16) -> Self::Output

fn _mul(self, rhs: bf16) -> Self::Output

fn _rem(self, rhs: bf16) -> Self::Output

fn _max(self, rhs: bf16) -> Self::Output

fn _min(self, rhs: bf16) -> Self::Output

impl NormalOut<bf16> for isize

type Output = <isize as NormalOutPromote<bf16>>::Output

fn _clamp(self, min: bf16, max: bf16) -> Self::Output

fn _mul_add(self, a: bf16, b: bf16) -> Self::Output

fn _add(self, rhs: bf16) -> Self::Output

fn _sub(self, rhs: bf16) -> Self::Output

fn _mul(self, rhs: bf16) -> Self::Output

fn _rem(self, rhs: bf16) -> Self::Output

fn _max(self, rhs: bf16) -> Self::Output

fn _min(self, rhs: bf16) -> Self::Output

impl NormalOut<bf16> for u8

type Output = <u8 as NormalOutPromote<bf16>>::Output

fn _clamp(self, min: bf16, max: bf16) -> Self::Output

fn _mul_add(self, a: bf16, b: bf16) -> Self::Output

fn _add(self, rhs: bf16) -> Self::Output

fn _sub(self, rhs: bf16) -> Self::Output

fn _mul(self, rhs: bf16) -> Self::Output

fn _rem(self, rhs: bf16) -> Self::Output

fn _max(self, rhs: bf16) -> Self::Output

fn _min(self, rhs: bf16) -> Self::Output

impl NormalOut<bf16> for u16

type Output = <u16 as NormalOutPromote<bf16>>::Output

fn _clamp(self, min: bf16, max: bf16) -> Self::Output

fn _mul_add(self, a: bf16, b: bf16) -> Self::Output

fn _add(self, rhs: bf16) -> Self::Output

fn _sub(self, rhs: bf16) -> Self::Output

fn _mul(self, rhs: bf16) -> Self::Output

fn _rem(self, rhs: bf16) -> Self::Output

fn _max(self, rhs: bf16) -> Self::Output

fn _min(self, rhs: bf16) -> Self::Output

impl NormalOut<bf16> for u32

type Output = <u32 as NormalOutPromote<bf16>>::Output

fn _clamp(self, min: bf16, max: bf16) -> Self::Output

fn _mul_add(self, a: bf16, b: bf16) -> Self::Output

fn _add(self, rhs: bf16) -> Self::Output

fn _sub(self, rhs: bf16) -> Self::Output

fn _mul(self, rhs: bf16) -> Self::Output

fn _rem(self, rhs: bf16) -> Self::Output

fn _max(self, rhs: bf16) -> Self::Output

fn _min(self, rhs: bf16) -> Self::Output

impl NormalOut<bf16> for u64

type Output = <u64 as NormalOutPromote<bf16>>::Output

fn _clamp(self, min: bf16, max: bf16) -> Self::Output

fn _mul_add(self, a: bf16, b: bf16) -> Self::Output

fn _add(self, rhs: bf16) -> Self::Output

fn _sub(self, rhs: bf16) -> Self::Output

fn _mul(self, rhs: bf16) -> Self::Output

fn _rem(self, rhs: bf16) -> Self::Output

fn _max(self, rhs: bf16) -> Self::Output

fn _min(self, rhs: bf16) -> Self::Output

impl NormalOut<bf16> for usize

type Output = <usize as NormalOutPromote<bf16>>::Output

fn _clamp(self, min: bf16, max: bf16) -> Self::Output

fn _mul_add(self, a: bf16, b: bf16) -> Self::Output

fn _add(self, rhs: bf16) -> Self::Output

fn _sub(self, rhs: bf16) -> Self::Output

fn _mul(self, rhs: bf16) -> Self::Output

fn _rem(self, rhs: bf16) -> Self::Output

fn _max(self, rhs: bf16) -> Self::Output

fn _min(self, rhs: bf16) -> Self::Output

impl NormalOut<bf16> for f16

type Output = <f16 as NormalOutPromote<bf16>>::Output

fn _clamp(self, min: bf16, max: bf16) -> Self::Output

fn _mul_add(self, a: bf16, b: bf16) -> Self::Output

fn _add(self, rhs: bf16) -> Self::Output

fn _sub(self, rhs: bf16) -> Self::Output

fn _mul(self, rhs: bf16) -> Self::Output

fn _rem(self, rhs: bf16) -> Self::Output

fn _max(self, rhs: bf16) -> Self::Output

fn _min(self, rhs: bf16) -> Self::Output

impl NormalOut<bf16> for Complex32

type Output = <Complex<f32> as NormalOutPromote<bf16>>::Output

fn _clamp(self, min: bf16, max: bf16) -> Self::Output

fn _mul_add(self, a: bf16, b: bf16) -> Self::Output

fn _add(self, rhs: bf16) -> Self::Output

fn _sub(self, rhs: bf16) -> Self::Output

fn _mul(self, rhs: bf16) -> Self::Output

fn _rem(self, rhs: bf16) -> Self::Output

fn _max(self, rhs: bf16) -> Self::Output

fn _min(self, rhs: bf16) -> Self::Output

impl NormalOut<bf16> for Complex64

type Output = <Complex<f64> as NormalOutPromote<bf16>>::Output

fn _clamp(self, min: bf16, max: bf16) -> Self::Output

fn _mul_add(self, a: bf16, b: bf16) -> Self::Output

fn _add(self, rhs: bf16) -> Self::Output

fn _sub(self, rhs: bf16) -> Self::Output

fn _mul(self, rhs: bf16) -> Self::Output

fn _rem(self, rhs: bf16) -> Self::Output

fn _max(self, rhs: bf16) -> Self::Output

fn _min(self, rhs: bf16) -> Self::Output

impl NormalOut<f16> for bool

type Output = <bool as NormalOutPromote<f16>>::Output

fn _clamp(self, min: f16, max: f16) -> Self::Output

fn _mul_add(self, a: f16, b: f16) -> Self::Output

fn _add(self, rhs: f16) -> Self::Output

fn _sub(self, rhs: f16) -> Self::Output

fn _mul(self, rhs: f16) -> Self::Output

fn _rem(self, rhs: f16) -> Self::Output

fn _max(self, rhs: f16) -> Self::Output

fn _min(self, rhs: f16) -> Self::Output

impl NormalOut<f16> for f32

type Output = <f32 as NormalOutPromote<f16>>::Output

fn _clamp(self, min: f16, max: f16) -> Self::Output

fn _mul_add(self, a: f16, b: f16) -> Self::Output

fn _add(self, rhs: f16) -> Self::Output

fn _sub(self, rhs: f16) -> Self::Output

fn _mul(self, rhs: f16) -> Self::Output

fn _rem(self, rhs: f16) -> Self::Output

fn _max(self, rhs: f16) -> Self::Output

fn _min(self, rhs: f16) -> Self::Output

impl NormalOut<f16> for f64

type Output = <f64 as NormalOutPromote<f16>>::Output

fn _clamp(self, min: f16, max: f16) -> Self::Output

fn _mul_add(self, a: f16, b: f16) -> Self::Output

fn _add(self, rhs: f16) -> Self::Output

fn _sub(self, rhs: f16) -> Self::Output

fn _mul(self, rhs: f16) -> Self::Output

fn _rem(self, rhs: f16) -> Self::Output

fn _max(self, rhs: f16) -> Self::Output

fn _min(self, rhs: f16) -> Self::Output

impl NormalOut<f16> for i8

type Output = <i8 as NormalOutPromote<f16>>::Output

fn _clamp(self, min: f16, max: f16) -> Self::Output

fn _mul_add(self, a: f16, b: f16) -> Self::Output

fn _add(self, rhs: f16) -> Self::Output

fn _sub(self, rhs: f16) -> Self::Output

fn _mul(self, rhs: f16) -> Self::Output

fn _rem(self, rhs: f16) -> Self::Output

fn _max(self, rhs: f16) -> Self::Output

fn _min(self, rhs: f16) -> Self::Output

impl NormalOut<f16> for i16

type Output = <i16 as NormalOutPromote<f16>>::Output

fn _clamp(self, min: f16, max: f16) -> Self::Output

fn _mul_add(self, a: f16, b: f16) -> Self::Output

fn _add(self, rhs: f16) -> Self::Output

fn _sub(self, rhs: f16) -> Self::Output

fn _mul(self, rhs: f16) -> Self::Output

fn _rem(self, rhs: f16) -> Self::Output

fn _max(self, rhs: f16) -> Self::Output

fn _min(self, rhs: f16) -> Self::Output

impl NormalOut<f16> for i32

type Output = <i32 as NormalOutPromote<f16>>::Output

fn _clamp(self, min: f16, max: f16) -> Self::Output

fn _mul_add(self, a: f16, b: f16) -> Self::Output

fn _add(self, rhs: f16) -> Self::Output

fn _sub(self, rhs: f16) -> Self::Output

fn _mul(self, rhs: f16) -> Self::Output

fn _rem(self, rhs: f16) -> Self::Output

fn _max(self, rhs: f16) -> Self::Output

fn _min(self, rhs: f16) -> Self::Output

impl NormalOut<f16> for i64

type Output = <i64 as NormalOutPromote<f16>>::Output

fn _clamp(self, min: f16, max: f16) -> Self::Output

fn _mul_add(self, a: f16, b: f16) -> Self::Output

fn _add(self, rhs: f16) -> Self::Output

fn _sub(self, rhs: f16) -> Self::Output

fn _mul(self, rhs: f16) -> Self::Output

fn _rem(self, rhs: f16) -> Self::Output

fn _max(self, rhs: f16) -> Self::Output

fn _min(self, rhs: f16) -> Self::Output

impl NormalOut<f16> for isize

type Output = <isize as NormalOutPromote<f16>>::Output

fn _clamp(self, min: f16, max: f16) -> Self::Output

fn _mul_add(self, a: f16, b: f16) -> Self::Output

fn _add(self, rhs: f16) -> Self::Output

fn _sub(self, rhs: f16) -> Self::Output

fn _mul(self, rhs: f16) -> Self::Output

fn _rem(self, rhs: f16) -> Self::Output

fn _max(self, rhs: f16) -> Self::Output

fn _min(self, rhs: f16) -> Self::Output

impl NormalOut<f16> for u8

type Output = <u8 as NormalOutPromote<f16>>::Output

fn _clamp(self, min: f16, max: f16) -> Self::Output

fn _mul_add(self, a: f16, b: f16) -> Self::Output

fn _add(self, rhs: f16) -> Self::Output

fn _sub(self, rhs: f16) -> Self::Output

fn _mul(self, rhs: f16) -> Self::Output

fn _rem(self, rhs: f16) -> Self::Output

fn _max(self, rhs: f16) -> Self::Output

fn _min(self, rhs: f16) -> Self::Output

impl NormalOut<f16> for u16

type Output = <u16 as NormalOutPromote<f16>>::Output

fn _clamp(self, min: f16, max: f16) -> Self::Output

fn _mul_add(self, a: f16, b: f16) -> Self::Output

fn _add(self, rhs: f16) -> Self::Output

fn _sub(self, rhs: f16) -> Self::Output

fn _mul(self, rhs: f16) -> Self::Output

fn _rem(self, rhs: f16) -> Self::Output

fn _max(self, rhs: f16) -> Self::Output

fn _min(self, rhs: f16) -> Self::Output

impl NormalOut<f16> for u32

type Output = <u32 as NormalOutPromote<f16>>::Output

fn _clamp(self, min: f16, max: f16) -> Self::Output

fn _mul_add(self, a: f16, b: f16) -> Self::Output

fn _add(self, rhs: f16) -> Self::Output

fn _sub(self, rhs: f16) -> Self::Output

fn _mul(self, rhs: f16) -> Self::Output

fn _rem(self, rhs: f16) -> Self::Output

fn _max(self, rhs: f16) -> Self::Output

fn _min(self, rhs: f16) -> Self::Output

impl NormalOut<f16> for u64

type Output = <u64 as NormalOutPromote<f16>>::Output

fn _clamp(self, min: f16, max: f16) -> Self::Output

fn _mul_add(self, a: f16, b: f16) -> Self::Output

fn _add(self, rhs: f16) -> Self::Output

fn _sub(self, rhs: f16) -> Self::Output

fn _mul(self, rhs: f16) -> Self::Output

fn _rem(self, rhs: f16) -> Self::Output

fn _max(self, rhs: f16) -> Self::Output

fn _min(self, rhs: f16) -> Self::Output

impl NormalOut<f16> for usize

type Output = <usize as NormalOutPromote<f16>>::Output

fn _clamp(self, min: f16, max: f16) -> Self::Output

fn _mul_add(self, a: f16, b: f16) -> Self::Output

fn _add(self, rhs: f16) -> Self::Output

fn _sub(self, rhs: f16) -> Self::Output

fn _mul(self, rhs: f16) -> Self::Output

fn _rem(self, rhs: f16) -> Self::Output

fn _max(self, rhs: f16) -> Self::Output

fn _min(self, rhs: f16) -> Self::Output

impl NormalOut<f16> for bf16

type Output = <bf16 as NormalOutPromote<f16>>::Output

fn _clamp(self, min: f16, max: f16) -> Self::Output

fn _mul_add(self, a: f16, b: f16) -> Self::Output

fn _add(self, rhs: f16) -> Self::Output

fn _sub(self, rhs: f16) -> Self::Output

fn _mul(self, rhs: f16) -> Self::Output

fn _rem(self, rhs: f16) -> Self::Output

fn _max(self, rhs: f16) -> Self::Output

fn _min(self, rhs: f16) -> Self::Output

impl NormalOut<f16> for Complex32

type Output = <Complex<f32> as NormalOutPromote<f16>>::Output

fn _clamp(self, min: f16, max: f16) -> Self::Output

fn _mul_add(self, a: f16, b: f16) -> Self::Output

fn _add(self, rhs: f16) -> Self::Output

fn _sub(self, rhs: f16) -> Self::Output

fn _mul(self, rhs: f16) -> Self::Output

fn _rem(self, rhs: f16) -> Self::Output

fn _max(self, rhs: f16) -> Self::Output

fn _min(self, rhs: f16) -> Self::Output

impl NormalOut<f16> for Complex64

type Output = <Complex<f64> as NormalOutPromote<f16>>::Output

fn _clamp(self, min: f16, max: f16) -> Self::Output

fn _mul_add(self, a: f16, b: f16) -> Self::Output

fn _add(self, rhs: f16) -> Self::Output

fn _sub(self, rhs: f16) -> Self::Output

fn _mul(self, rhs: f16) -> Self::Output

fn _rem(self, rhs: f16) -> Self::Output

fn _max(self, rhs: f16) -> Self::Output

fn _min(self, rhs: f16) -> Self::Output

impl NormalOut<Complex<f32>> for bool

type Output = <bool as NormalOutPromote<Complex<f32>>>::Output

fn _clamp(self, min: Complex32, max: Complex32) -> Self::Output

fn _mul_add(self, a: Complex32, b: Complex32) -> Self::Output

fn _add(self, rhs: Complex32) -> Self::Output

fn _sub(self, rhs: Complex32) -> Self::Output

fn _mul(self, rhs: Complex32) -> Self::Output

fn _rem(self, rhs: Complex32) -> Self::Output

fn _max(self, rhs: Complex32) -> Self::Output

fn _min(self, rhs: Complex32) -> Self::Output

impl NormalOut<Complex<f32>> for f32

type Output = <f32 as NormalOutPromote<Complex<f32>>>::Output

fn _clamp(self, min: Complex32, max: Complex32) -> Self::Output

fn _mul_add(self, a: Complex32, b: Complex32) -> Self::Output

fn _add(self, rhs: Complex32) -> Self::Output

fn _sub(self, rhs: Complex32) -> Self::Output

fn _mul(self, rhs: Complex32) -> Self::Output

fn _rem(self, rhs: Complex32) -> Self::Output

fn _max(self, rhs: Complex32) -> Self::Output

fn _min(self, rhs: Complex32) -> Self::Output

impl NormalOut<Complex<f32>> for f64

type Output = <f64 as NormalOutPromote<Complex<f32>>>::Output

fn _clamp(self, min: Complex32, max: Complex32) -> Self::Output

fn _mul_add(self, a: Complex32, b: Complex32) -> Self::Output

fn _add(self, rhs: Complex32) -> Self::Output

fn _sub(self, rhs: Complex32) -> Self::Output

fn _mul(self, rhs: Complex32) -> Self::Output

fn _rem(self, rhs: Complex32) -> Self::Output

fn _max(self, rhs: Complex32) -> Self::Output

fn _min(self, rhs: Complex32) -> Self::Output

impl NormalOut<Complex<f32>> for i8

type Output = <i8 as NormalOutPromote<Complex<f32>>>::Output

fn _clamp(self, min: Complex32, max: Complex32) -> Self::Output

fn _mul_add(self, a: Complex32, b: Complex32) -> Self::Output

fn _add(self, rhs: Complex32) -> Self::Output

fn _sub(self, rhs: Complex32) -> Self::Output

fn _mul(self, rhs: Complex32) -> Self::Output

fn _rem(self, rhs: Complex32) -> Self::Output

fn _max(self, rhs: Complex32) -> Self::Output

fn _min(self, rhs: Complex32) -> Self::Output

impl NormalOut<Complex<f32>> for i16

type Output = <i16 as NormalOutPromote<Complex<f32>>>::Output

fn _clamp(self, min: Complex32, max: Complex32) -> Self::Output

fn _mul_add(self, a: Complex32, b: Complex32) -> Self::Output

fn _add(self, rhs: Complex32) -> Self::Output

fn _sub(self, rhs: Complex32) -> Self::Output

fn _mul(self, rhs: Complex32) -> Self::Output

fn _rem(self, rhs: Complex32) -> Self::Output

fn _max(self, rhs: Complex32) -> Self::Output

fn _min(self, rhs: Complex32) -> Self::Output

impl NormalOut<Complex<f32>> for i32

type Output = <i32 as NormalOutPromote<Complex<f32>>>::Output

fn _clamp(self, min: Complex32, max: Complex32) -> Self::Output

fn _mul_add(self, a: Complex32, b: Complex32) -> Self::Output

fn _add(self, rhs: Complex32) -> Self::Output

fn _sub(self, rhs: Complex32) -> Self::Output

fn _mul(self, rhs: Complex32) -> Self::Output

fn _rem(self, rhs: Complex32) -> Self::Output

fn _max(self, rhs: Complex32) -> Self::Output

fn _min(self, rhs: Complex32) -> Self::Output

impl NormalOut<Complex<f32>> for i64

type Output = <i64 as NormalOutPromote<Complex<f32>>>::Output

fn _clamp(self, min: Complex32, max: Complex32) -> Self::Output

fn _mul_add(self, a: Complex32, b: Complex32) -> Self::Output

fn _add(self, rhs: Complex32) -> Self::Output

fn _sub(self, rhs: Complex32) -> Self::Output

fn _mul(self, rhs: Complex32) -> Self::Output

fn _rem(self, rhs: Complex32) -> Self::Output

fn _max(self, rhs: Complex32) -> Self::Output

fn _min(self, rhs: Complex32) -> Self::Output

impl NormalOut<Complex<f32>> for isize

type Output = <isize as NormalOutPromote<Complex<f32>>>::Output

fn _clamp(self, min: Complex32, max: Complex32) -> Self::Output

fn _mul_add(self, a: Complex32, b: Complex32) -> Self::Output

fn _add(self, rhs: Complex32) -> Self::Output

fn _sub(self, rhs: Complex32) -> Self::Output

fn _mul(self, rhs: Complex32) -> Self::Output

fn _rem(self, rhs: Complex32) -> Self::Output

fn _max(self, rhs: Complex32) -> Self::Output

fn _min(self, rhs: Complex32) -> Self::Output

impl NormalOut<Complex<f32>> for u8

type Output = <u8 as NormalOutPromote<Complex<f32>>>::Output

fn _clamp(self, min: Complex32, max: Complex32) -> Self::Output

fn _mul_add(self, a: Complex32, b: Complex32) -> Self::Output

fn _add(self, rhs: Complex32) -> Self::Output

fn _sub(self, rhs: Complex32) -> Self::Output

fn _mul(self, rhs: Complex32) -> Self::Output

fn _rem(self, rhs: Complex32) -> Self::Output

fn _max(self, rhs: Complex32) -> Self::Output

fn _min(self, rhs: Complex32) -> Self::Output

impl NormalOut<Complex<f32>> for u16

type Output = <u16 as NormalOutPromote<Complex<f32>>>::Output

fn _clamp(self, min: Complex32, max: Complex32) -> Self::Output

fn _mul_add(self, a: Complex32, b: Complex32) -> Self::Output

fn _add(self, rhs: Complex32) -> Self::Output

fn _sub(self, rhs: Complex32) -> Self::Output

fn _mul(self, rhs: Complex32) -> Self::Output

fn _rem(self, rhs: Complex32) -> Self::Output

fn _max(self, rhs: Complex32) -> Self::Output

fn _min(self, rhs: Complex32) -> Self::Output

impl NormalOut<Complex<f32>> for u32

type Output = <u32 as NormalOutPromote<Complex<f32>>>::Output

fn _clamp(self, min: Complex32, max: Complex32) -> Self::Output

fn _mul_add(self, a: Complex32, b: Complex32) -> Self::Output

fn _add(self, rhs: Complex32) -> Self::Output

fn _sub(self, rhs: Complex32) -> Self::Output

fn _mul(self, rhs: Complex32) -> Self::Output

fn _rem(self, rhs: Complex32) -> Self::Output

fn _max(self, rhs: Complex32) -> Self::Output

fn _min(self, rhs: Complex32) -> Self::Output

impl NormalOut<Complex<f32>> for u64

type Output = <u64 as NormalOutPromote<Complex<f32>>>::Output

fn _clamp(self, min: Complex32, max: Complex32) -> Self::Output

fn _mul_add(self, a: Complex32, b: Complex32) -> Self::Output

fn _add(self, rhs: Complex32) -> Self::Output

fn _sub(self, rhs: Complex32) -> Self::Output

fn _mul(self, rhs: Complex32) -> Self::Output

fn _rem(self, rhs: Complex32) -> Self::Output

fn _max(self, rhs: Complex32) -> Self::Output

fn _min(self, rhs: Complex32) -> Self::Output

impl NormalOut<Complex<f32>> for usize

type Output = <usize as NormalOutPromote<Complex<f32>>>::Output

fn _clamp(self, min: Complex32, max: Complex32) -> Self::Output

fn _mul_add(self, a: Complex32, b: Complex32) -> Self::Output

fn _add(self, rhs: Complex32) -> Self::Output

fn _sub(self, rhs: Complex32) -> Self::Output

fn _mul(self, rhs: Complex32) -> Self::Output

fn _rem(self, rhs: Complex32) -> Self::Output

fn _max(self, rhs: Complex32) -> Self::Output

fn _min(self, rhs: Complex32) -> Self::Output

impl NormalOut<Complex<f32>> for bf16

type Output = <bf16 as NormalOutPromote<Complex<f32>>>::Output

fn _clamp(self, min: Complex32, max: Complex32) -> Self::Output

fn _mul_add(self, a: Complex32, b: Complex32) -> Self::Output

fn _add(self, rhs: Complex32) -> Self::Output

fn _sub(self, rhs: Complex32) -> Self::Output

fn _mul(self, rhs: Complex32) -> Self::Output

fn _rem(self, rhs: Complex32) -> Self::Output

fn _max(self, rhs: Complex32) -> Self::Output

fn _min(self, rhs: Complex32) -> Self::Output

impl NormalOut<Complex<f32>> for f16

type Output = <f16 as NormalOutPromote<Complex<f32>>>::Output

fn _clamp(self, min: Complex32, max: Complex32) -> Self::Output

fn _mul_add(self, a: Complex32, b: Complex32) -> Self::Output

fn _add(self, rhs: Complex32) -> Self::Output

fn _sub(self, rhs: Complex32) -> Self::Output

fn _mul(self, rhs: Complex32) -> Self::Output

fn _rem(self, rhs: Complex32) -> Self::Output

fn _max(self, rhs: Complex32) -> Self::Output

fn _min(self, rhs: Complex32) -> Self::Output

impl NormalOut<Complex<f32>> for Complex64

type Output = <Complex<f64> as NormalOutPromote<Complex<f32>>>::Output

fn _clamp(self, min: Complex32, max: Complex32) -> Self::Output

fn _mul_add(self, a: Complex32, b: Complex32) -> Self::Output

fn _add(self, rhs: Complex32) -> Self::Output

fn _sub(self, rhs: Complex32) -> Self::Output

fn _mul(self, rhs: Complex32) -> Self::Output

fn _rem(self, rhs: Complex32) -> Self::Output

fn _max(self, rhs: Complex32) -> Self::Output

fn _min(self, rhs: Complex32) -> Self::Output

impl NormalOut<Complex<f64>> for bool

type Output = <bool as NormalOutPromote<Complex<f64>>>::Output

fn _clamp(self, min: Complex64, max: Complex64) -> Self::Output

fn _mul_add(self, a: Complex64, b: Complex64) -> Self::Output

fn _add(self, rhs: Complex64) -> Self::Output

fn _sub(self, rhs: Complex64) -> Self::Output

fn _mul(self, rhs: Complex64) -> Self::Output

fn _rem(self, rhs: Complex64) -> Self::Output

fn _max(self, rhs: Complex64) -> Self::Output

fn _min(self, rhs: Complex64) -> Self::Output

impl NormalOut<Complex<f64>> for f32

type Output = <f32 as NormalOutPromote<Complex<f64>>>::Output

fn _clamp(self, min: Complex64, max: Complex64) -> Self::Output

fn _mul_add(self, a: Complex64, b: Complex64) -> Self::Output

fn _add(self, rhs: Complex64) -> Self::Output

fn _sub(self, rhs: Complex64) -> Self::Output

fn _mul(self, rhs: Complex64) -> Self::Output

fn _rem(self, rhs: Complex64) -> Self::Output

fn _max(self, rhs: Complex64) -> Self::Output

fn _min(self, rhs: Complex64) -> Self::Output

impl NormalOut<Complex<f64>> for f64

type Output = <f64 as NormalOutPromote<Complex<f64>>>::Output

fn _clamp(self, min: Complex64, max: Complex64) -> Self::Output

fn _mul_add(self, a: Complex64, b: Complex64) -> Self::Output

fn _add(self, rhs: Complex64) -> Self::Output

fn _sub(self, rhs: Complex64) -> Self::Output

fn _mul(self, rhs: Complex64) -> Self::Output

fn _rem(self, rhs: Complex64) -> Self::Output

fn _max(self, rhs: Complex64) -> Self::Output

fn _min(self, rhs: Complex64) -> Self::Output

impl NormalOut<Complex<f64>> for i8

type Output = <i8 as NormalOutPromote<Complex<f64>>>::Output

fn _clamp(self, min: Complex64, max: Complex64) -> Self::Output

fn _mul_add(self, a: Complex64, b: Complex64) -> Self::Output

fn _add(self, rhs: Complex64) -> Self::Output

fn _sub(self, rhs: Complex64) -> Self::Output

fn _mul(self, rhs: Complex64) -> Self::Output

fn _rem(self, rhs: Complex64) -> Self::Output

fn _max(self, rhs: Complex64) -> Self::Output

fn _min(self, rhs: Complex64) -> Self::Output

impl NormalOut<Complex<f64>> for i16

type Output = <i16 as NormalOutPromote<Complex<f64>>>::Output

fn _clamp(self, min: Complex64, max: Complex64) -> Self::Output

fn _mul_add(self, a: Complex64, b: Complex64) -> Self::Output

fn _add(self, rhs: Complex64) -> Self::Output

fn _sub(self, rhs: Complex64) -> Self::Output

fn _mul(self, rhs: Complex64) -> Self::Output

fn _rem(self, rhs: Complex64) -> Self::Output

fn _max(self, rhs: Complex64) -> Self::Output

fn _min(self, rhs: Complex64) -> Self::Output

impl NormalOut<Complex<f64>> for i32

type Output = <i32 as NormalOutPromote<Complex<f64>>>::Output

fn _clamp(self, min: Complex64, max: Complex64) -> Self::Output

fn _mul_add(self, a: Complex64, b: Complex64) -> Self::Output

fn _add(self, rhs: Complex64) -> Self::Output

fn _sub(self, rhs: Complex64) -> Self::Output

fn _mul(self, rhs: Complex64) -> Self::Output

fn _rem(self, rhs: Complex64) -> Self::Output

fn _max(self, rhs: Complex64) -> Self::Output

fn _min(self, rhs: Complex64) -> Self::Output

impl NormalOut<Complex<f64>> for i64

type Output = <i64 as NormalOutPromote<Complex<f64>>>::Output

fn _clamp(self, min: Complex64, max: Complex64) -> Self::Output

fn _mul_add(self, a: Complex64, b: Complex64) -> Self::Output

fn _add(self, rhs: Complex64) -> Self::Output

fn _sub(self, rhs: Complex64) -> Self::Output

fn _mul(self, rhs: Complex64) -> Self::Output

fn _rem(self, rhs: Complex64) -> Self::Output

fn _max(self, rhs: Complex64) -> Self::Output

fn _min(self, rhs: Complex64) -> Self::Output

impl NormalOut<Complex<f64>> for isize

type Output = <isize as NormalOutPromote<Complex<f64>>>::Output

fn _clamp(self, min: Complex64, max: Complex64) -> Self::Output

fn _mul_add(self, a: Complex64, b: Complex64) -> Self::Output

fn _add(self, rhs: Complex64) -> Self::Output

fn _sub(self, rhs: Complex64) -> Self::Output

fn _mul(self, rhs: Complex64) -> Self::Output

fn _rem(self, rhs: Complex64) -> Self::Output

fn _max(self, rhs: Complex64) -> Self::Output

fn _min(self, rhs: Complex64) -> Self::Output

impl NormalOut<Complex<f64>> for u8

type Output = <u8 as NormalOutPromote<Complex<f64>>>::Output

fn _clamp(self, min: Complex64, max: Complex64) -> Self::Output

fn _mul_add(self, a: Complex64, b: Complex64) -> Self::Output

fn _add(self, rhs: Complex64) -> Self::Output

fn _sub(self, rhs: Complex64) -> Self::Output

fn _mul(self, rhs: Complex64) -> Self::Output

fn _rem(self, rhs: Complex64) -> Self::Output

fn _max(self, rhs: Complex64) -> Self::Output

fn _min(self, rhs: Complex64) -> Self::Output

impl NormalOut<Complex<f64>> for u16

type Output = <u16 as NormalOutPromote<Complex<f64>>>::Output

fn _clamp(self, min: Complex64, max: Complex64) -> Self::Output

fn _mul_add(self, a: Complex64, b: Complex64) -> Self::Output

fn _add(self, rhs: Complex64) -> Self::Output

fn _sub(self, rhs: Complex64) -> Self::Output

fn _mul(self, rhs: Complex64) -> Self::Output

fn _rem(self, rhs: Complex64) -> Self::Output

fn _max(self, rhs: Complex64) -> Self::Output

fn _min(self, rhs: Complex64) -> Self::Output

impl NormalOut<Complex<f64>> for u32

type Output = <u32 as NormalOutPromote<Complex<f64>>>::Output

fn _clamp(self, min: Complex64, max: Complex64) -> Self::Output

fn _mul_add(self, a: Complex64, b: Complex64) -> Self::Output

fn _add(self, rhs: Complex64) -> Self::Output

fn _sub(self, rhs: Complex64) -> Self::Output

fn _mul(self, rhs: Complex64) -> Self::Output

fn _rem(self, rhs: Complex64) -> Self::Output

fn _max(self, rhs: Complex64) -> Self::Output

fn _min(self, rhs: Complex64) -> Self::Output

impl NormalOut<Complex<f64>> for u64

type Output = <u64 as NormalOutPromote<Complex<f64>>>::Output

fn _clamp(self, min: Complex64, max: Complex64) -> Self::Output

fn _mul_add(self, a: Complex64, b: Complex64) -> Self::Output

fn _add(self, rhs: Complex64) -> Self::Output

fn _sub(self, rhs: Complex64) -> Self::Output

fn _mul(self, rhs: Complex64) -> Self::Output

fn _rem(self, rhs: Complex64) -> Self::Output

fn _max(self, rhs: Complex64) -> Self::Output

fn _min(self, rhs: Complex64) -> Self::Output

impl NormalOut<Complex<f64>> for usize

type Output = <usize as NormalOutPromote<Complex<f64>>>::Output

fn _clamp(self, min: Complex64, max: Complex64) -> Self::Output

fn _mul_add(self, a: Complex64, b: Complex64) -> Self::Output

fn _add(self, rhs: Complex64) -> Self::Output

fn _sub(self, rhs: Complex64) -> Self::Output

fn _mul(self, rhs: Complex64) -> Self::Output

fn _rem(self, rhs: Complex64) -> Self::Output

fn _max(self, rhs: Complex64) -> Self::Output

fn _min(self, rhs: Complex64) -> Self::Output

impl NormalOut<Complex<f64>> for bf16

type Output = <bf16 as NormalOutPromote<Complex<f64>>>::Output

fn _clamp(self, min: Complex64, max: Complex64) -> Self::Output

fn _mul_add(self, a: Complex64, b: Complex64) -> Self::Output

fn _add(self, rhs: Complex64) -> Self::Output

fn _sub(self, rhs: Complex64) -> Self::Output

fn _mul(self, rhs: Complex64) -> Self::Output

fn _rem(self, rhs: Complex64) -> Self::Output

fn _max(self, rhs: Complex64) -> Self::Output

fn _min(self, rhs: Complex64) -> Self::Output

impl NormalOut<Complex<f64>> for f16

type Output = <f16 as NormalOutPromote<Complex<f64>>>::Output

fn _clamp(self, min: Complex64, max: Complex64) -> Self::Output

fn _mul_add(self, a: Complex64, b: Complex64) -> Self::Output

fn _add(self, rhs: Complex64) -> Self::Output

fn _sub(self, rhs: Complex64) -> Self::Output

fn _mul(self, rhs: Complex64) -> Self::Output

fn _rem(self, rhs: Complex64) -> Self::Output

fn _max(self, rhs: Complex64) -> Self::Output

fn _min(self, rhs: Complex64) -> Self::Output

impl NormalOut<Complex<f64>> for Complex32

type Output = <Complex<f32> as NormalOutPromote<Complex<f64>>>::Output

fn _clamp(self, min: Complex64, max: Complex64) -> Self::Output

fn _mul_add(self, a: Complex64, b: Complex64) -> Self::Output

fn _add(self, rhs: Complex64) -> Self::Output

fn _sub(self, rhs: Complex64) -> Self::Output

fn _mul(self, rhs: Complex64) -> Self::Output

fn _rem(self, rhs: Complex64) -> Self::Output

fn _max(self, rhs: Complex64) -> Self::Output

fn _min(self, rhs: Complex64) -> Self::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