Trait FloatOutBinary

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

    // Required methods
    fn _div(self, rhs: RHS) -> Self::Output;
    fn _log(self, base: RHS) -> Self::Output;
    fn _hypot(self, rhs: RHS) -> Self::Output;
}

this trait is used to perform type promotion in dynamic graph

Required Associated Types

type Output

the output type

Required Methods

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

perform a / b

fn _log(self, base: RHS) -> Self::Output

perform log_b(x)

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

perform hypot(x, y)

Implementations on Foreign Types

impl FloatOutBinary for bool

type Output = <bool as FloatOutBinaryPromote>::Output

fn _div(self, rhs: bool) -> <bool as FloatOutBinary>::Output

fn _log(self, base: bool) -> <bool as FloatOutBinary>::Output

fn _hypot(self, rhs: bool) -> <bool as FloatOutBinary>::Output

impl FloatOutBinary for f32

type Output = <f32 as FloatOutBinaryPromote>::Output

fn _div(self, rhs: f32) -> <f32 as FloatOutBinary>::Output

fn _log(self, base: f32) -> <f32 as FloatOutBinary>::Output

fn _hypot(self, rhs: f32) -> <f32 as FloatOutBinary>::Output

impl FloatOutBinary for f64

type Output = <f64 as FloatOutBinaryPromote>::Output

fn _div(self, rhs: f64) -> <f64 as FloatOutBinary>::Output

fn _log(self, base: f64) -> <f64 as FloatOutBinary>::Output

fn _hypot(self, rhs: f64) -> <f64 as FloatOutBinary>::Output

impl FloatOutBinary for i8

type Output = <i8 as FloatOutBinaryPromote>::Output

fn _div(self, rhs: i8) -> <i8 as FloatOutBinary>::Output

fn _log(self, base: i8) -> <i8 as FloatOutBinary>::Output

fn _hypot(self, rhs: i8) -> <i8 as FloatOutBinary>::Output

impl FloatOutBinary for i16

type Output = <i16 as FloatOutBinaryPromote>::Output

fn _div(self, rhs: i16) -> <i16 as FloatOutBinary>::Output

fn _log(self, base: i16) -> <i16 as FloatOutBinary>::Output

fn _hypot(self, rhs: i16) -> <i16 as FloatOutBinary>::Output

impl FloatOutBinary for i32

type Output = <i32 as FloatOutBinaryPromote>::Output

fn _div(self, rhs: i32) -> <i32 as FloatOutBinary>::Output

fn _log(self, base: i32) -> <i32 as FloatOutBinary>::Output

fn _hypot(self, rhs: i32) -> <i32 as FloatOutBinary>::Output

impl FloatOutBinary for i64

type Output = <i64 as FloatOutBinaryPromote>::Output

fn _div(self, rhs: i64) -> <i64 as FloatOutBinary>::Output

fn _log(self, base: i64) -> <i64 as FloatOutBinary>::Output

fn _hypot(self, rhs: i64) -> <i64 as FloatOutBinary>::Output

impl FloatOutBinary for isize

type Output = <isize as FloatOutBinaryPromote>::Output

fn _div(self, rhs: isize) -> <isize as FloatOutBinary>::Output

fn _log(self, base: isize) -> <isize as FloatOutBinary>::Output

fn _hypot(self, rhs: isize) -> <isize as FloatOutBinary>::Output

impl FloatOutBinary for u8

type Output = <u8 as FloatOutBinaryPromote>::Output

fn _div(self, rhs: u8) -> <u8 as FloatOutBinary>::Output

fn _log(self, base: u8) -> <u8 as FloatOutBinary>::Output

fn _hypot(self, rhs: u8) -> <u8 as FloatOutBinary>::Output

impl FloatOutBinary for u16

type Output = <u16 as FloatOutBinaryPromote>::Output

fn _div(self, rhs: u16) -> <u16 as FloatOutBinary>::Output

fn _log(self, base: u16) -> <u16 as FloatOutBinary>::Output

fn _hypot(self, rhs: u16) -> <u16 as FloatOutBinary>::Output

impl FloatOutBinary for u32

type Output = <u32 as FloatOutBinaryPromote>::Output

fn _div(self, rhs: u32) -> <u32 as FloatOutBinary>::Output

fn _log(self, base: u32) -> <u32 as FloatOutBinary>::Output

fn _hypot(self, rhs: u32) -> <u32 as FloatOutBinary>::Output

impl FloatOutBinary for u64

type Output = <u64 as FloatOutBinaryPromote>::Output

fn _div(self, rhs: u64) -> <u64 as FloatOutBinary>::Output

fn _log(self, base: u64) -> <u64 as FloatOutBinary>::Output

fn _hypot(self, rhs: u64) -> <u64 as FloatOutBinary>::Output

impl FloatOutBinary for usize

type Output = <usize as FloatOutBinaryPromote>::Output

fn _div(self, rhs: usize) -> <usize as FloatOutBinary>::Output

fn _log(self, base: usize) -> <usize as FloatOutBinary>::Output

fn _hypot(self, rhs: usize) -> <usize as FloatOutBinary>::Output

impl FloatOutBinary for bf16

type Output = <bf16 as FloatOutBinaryPromote>::Output

fn _div(self, rhs: bf16) -> <bf16 as FloatOutBinary>::Output

fn _log(self, base: bf16) -> <bf16 as FloatOutBinary>::Output

fn _hypot(self, rhs: bf16) -> <bf16 as FloatOutBinary>::Output

impl FloatOutBinary for f16

type Output = <f16 as FloatOutBinaryPromote>::Output

fn _div(self, rhs: f16) -> <f16 as FloatOutBinary>::Output

fn _log(self, base: f16) -> <f16 as FloatOutBinary>::Output

fn _hypot(self, rhs: f16) -> <f16 as FloatOutBinary>::Output

impl FloatOutBinary for Complex<f32>

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

fn _div(self, rhs: Complex<f32>) -> <Complex<f32> as FloatOutBinary>::Output

fn _log(self, base: Complex<f32>) -> <Complex<f32> as FloatOutBinary>::Output

fn _hypot(self, rhs: Complex<f32>) -> <Complex<f32> as FloatOutBinary>::Output

impl FloatOutBinary for Complex<f64>

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

fn _div(self, rhs: Complex<f64>) -> <Complex<f64> as FloatOutBinary>::Output

fn _log(self, base: Complex<f64>) -> <Complex<f64> as FloatOutBinary>::Output

fn _hypot(self, rhs: Complex<f64>) -> <Complex<f64> as FloatOutBinary>::Output

impl FloatOutBinary<bool> for f32

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

fn _div(self, rhs: bool) -> <f32 as FloatOutBinary<bool>>::Output

fn _log(self, base: bool) -> <f32 as FloatOutBinary<bool>>::Output

fn _hypot(self, rhs: bool) -> <f32 as FloatOutBinary<bool>>::Output

impl FloatOutBinary<bool> for f64

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

fn _div(self, rhs: bool) -> <f64 as FloatOutBinary<bool>>::Output

fn _log(self, base: bool) -> <f64 as FloatOutBinary<bool>>::Output

fn _hypot(self, rhs: bool) -> <f64 as FloatOutBinary<bool>>::Output

impl FloatOutBinary<bool> for i8

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

fn _div(self, rhs: bool) -> <i8 as FloatOutBinary<bool>>::Output

fn _log(self, base: bool) -> <i8 as FloatOutBinary<bool>>::Output

fn _hypot(self, rhs: bool) -> <i8 as FloatOutBinary<bool>>::Output

impl FloatOutBinary<bool> for i16

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

fn _div(self, rhs: bool) -> <i16 as FloatOutBinary<bool>>::Output

fn _log(self, base: bool) -> <i16 as FloatOutBinary<bool>>::Output

fn _hypot(self, rhs: bool) -> <i16 as FloatOutBinary<bool>>::Output

impl FloatOutBinary<bool> for i32

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

fn _div(self, rhs: bool) -> <i32 as FloatOutBinary<bool>>::Output

fn _log(self, base: bool) -> <i32 as FloatOutBinary<bool>>::Output

fn _hypot(self, rhs: bool) -> <i32 as FloatOutBinary<bool>>::Output

impl FloatOutBinary<bool> for i64

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

fn _div(self, rhs: bool) -> <i64 as FloatOutBinary<bool>>::Output

fn _log(self, base: bool) -> <i64 as FloatOutBinary<bool>>::Output

fn _hypot(self, rhs: bool) -> <i64 as FloatOutBinary<bool>>::Output

impl FloatOutBinary<bool> for isize

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

fn _div(self, rhs: bool) -> <isize as FloatOutBinary<bool>>::Output

fn _log(self, base: bool) -> <isize as FloatOutBinary<bool>>::Output

fn _hypot(self, rhs: bool) -> <isize as FloatOutBinary<bool>>::Output

impl FloatOutBinary<bool> for u8

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

fn _div(self, rhs: bool) -> <u8 as FloatOutBinary<bool>>::Output

fn _log(self, base: bool) -> <u8 as FloatOutBinary<bool>>::Output

fn _hypot(self, rhs: bool) -> <u8 as FloatOutBinary<bool>>::Output

impl FloatOutBinary<bool> for u16

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

fn _div(self, rhs: bool) -> <u16 as FloatOutBinary<bool>>::Output

fn _log(self, base: bool) -> <u16 as FloatOutBinary<bool>>::Output

fn _hypot(self, rhs: bool) -> <u16 as FloatOutBinary<bool>>::Output

impl FloatOutBinary<bool> for u32

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

fn _div(self, rhs: bool) -> <u32 as FloatOutBinary<bool>>::Output

fn _log(self, base: bool) -> <u32 as FloatOutBinary<bool>>::Output

fn _hypot(self, rhs: bool) -> <u32 as FloatOutBinary<bool>>::Output

impl FloatOutBinary<bool> for u64

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

fn _div(self, rhs: bool) -> <u64 as FloatOutBinary<bool>>::Output

fn _log(self, base: bool) -> <u64 as FloatOutBinary<bool>>::Output

fn _hypot(self, rhs: bool) -> <u64 as FloatOutBinary<bool>>::Output

impl FloatOutBinary<bool> for usize

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

fn _div(self, rhs: bool) -> <usize as FloatOutBinary<bool>>::Output

fn _log(self, base: bool) -> <usize as FloatOutBinary<bool>>::Output

fn _hypot(self, rhs: bool) -> <usize as FloatOutBinary<bool>>::Output

impl FloatOutBinary<bool> for bf16

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

fn _div(self, rhs: bool) -> <bf16 as FloatOutBinary<bool>>::Output

fn _log(self, base: bool) -> <bf16 as FloatOutBinary<bool>>::Output

fn _hypot(self, rhs: bool) -> <bf16 as FloatOutBinary<bool>>::Output

impl FloatOutBinary<bool> for f16

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

fn _div(self, rhs: bool) -> <f16 as FloatOutBinary<bool>>::Output

fn _log(self, base: bool) -> <f16 as FloatOutBinary<bool>>::Output

fn _hypot(self, rhs: bool) -> <f16 as FloatOutBinary<bool>>::Output

impl FloatOutBinary<bool> for Complex<f32>

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

fn _div(self, rhs: bool) -> <Complex<f32> as FloatOutBinary<bool>>::Output

fn _log(self, base: bool) -> <Complex<f32> as FloatOutBinary<bool>>::Output

fn _hypot(self, rhs: bool) -> <Complex<f32> as FloatOutBinary<bool>>::Output

impl FloatOutBinary<bool> for Complex<f64>

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

fn _div(self, rhs: bool) -> <Complex<f64> as FloatOutBinary<bool>>::Output

fn _log(self, base: bool) -> <Complex<f64> as FloatOutBinary<bool>>::Output

fn _hypot(self, rhs: bool) -> <Complex<f64> as FloatOutBinary<bool>>::Output

impl FloatOutBinary<f32> for bool

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

fn _div(self, rhs: f32) -> <bool as FloatOutBinary<f32>>::Output

fn _log(self, base: f32) -> <bool as FloatOutBinary<f32>>::Output

fn _hypot(self, rhs: f32) -> <bool as FloatOutBinary<f32>>::Output

impl FloatOutBinary<f32> for f64

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

fn _div(self, rhs: f32) -> <f64 as FloatOutBinary<f32>>::Output

fn _log(self, base: f32) -> <f64 as FloatOutBinary<f32>>::Output

fn _hypot(self, rhs: f32) -> <f64 as FloatOutBinary<f32>>::Output

impl FloatOutBinary<f32> for i8

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

fn _div(self, rhs: f32) -> <i8 as FloatOutBinary<f32>>::Output

fn _log(self, base: f32) -> <i8 as FloatOutBinary<f32>>::Output

fn _hypot(self, rhs: f32) -> <i8 as FloatOutBinary<f32>>::Output

impl FloatOutBinary<f32> for i16

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

fn _div(self, rhs: f32) -> <i16 as FloatOutBinary<f32>>::Output

fn _log(self, base: f32) -> <i16 as FloatOutBinary<f32>>::Output

fn _hypot(self, rhs: f32) -> <i16 as FloatOutBinary<f32>>::Output

impl FloatOutBinary<f32> for i32

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

fn _div(self, rhs: f32) -> <i32 as FloatOutBinary<f32>>::Output

fn _log(self, base: f32) -> <i32 as FloatOutBinary<f32>>::Output

fn _hypot(self, rhs: f32) -> <i32 as FloatOutBinary<f32>>::Output

impl FloatOutBinary<f32> for i64

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

fn _div(self, rhs: f32) -> <i64 as FloatOutBinary<f32>>::Output

fn _log(self, base: f32) -> <i64 as FloatOutBinary<f32>>::Output

fn _hypot(self, rhs: f32) -> <i64 as FloatOutBinary<f32>>::Output

impl FloatOutBinary<f32> for isize

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

fn _div(self, rhs: f32) -> <isize as FloatOutBinary<f32>>::Output

fn _log(self, base: f32) -> <isize as FloatOutBinary<f32>>::Output

fn _hypot(self, rhs: f32) -> <isize as FloatOutBinary<f32>>::Output

impl FloatOutBinary<f32> for u8

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

fn _div(self, rhs: f32) -> <u8 as FloatOutBinary<f32>>::Output

fn _log(self, base: f32) -> <u8 as FloatOutBinary<f32>>::Output

fn _hypot(self, rhs: f32) -> <u8 as FloatOutBinary<f32>>::Output

impl FloatOutBinary<f32> for u16

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

fn _div(self, rhs: f32) -> <u16 as FloatOutBinary<f32>>::Output

fn _log(self, base: f32) -> <u16 as FloatOutBinary<f32>>::Output

fn _hypot(self, rhs: f32) -> <u16 as FloatOutBinary<f32>>::Output

impl FloatOutBinary<f32> for u32

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

fn _div(self, rhs: f32) -> <u32 as FloatOutBinary<f32>>::Output

fn _log(self, base: f32) -> <u32 as FloatOutBinary<f32>>::Output

fn _hypot(self, rhs: f32) -> <u32 as FloatOutBinary<f32>>::Output

impl FloatOutBinary<f32> for u64

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

fn _div(self, rhs: f32) -> <u64 as FloatOutBinary<f32>>::Output

fn _log(self, base: f32) -> <u64 as FloatOutBinary<f32>>::Output

fn _hypot(self, rhs: f32) -> <u64 as FloatOutBinary<f32>>::Output

impl FloatOutBinary<f32> for usize

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

fn _div(self, rhs: f32) -> <usize as FloatOutBinary<f32>>::Output

fn _log(self, base: f32) -> <usize as FloatOutBinary<f32>>::Output

fn _hypot(self, rhs: f32) -> <usize as FloatOutBinary<f32>>::Output

impl FloatOutBinary<f32> for bf16

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

fn _div(self, rhs: f32) -> <bf16 as FloatOutBinary<f32>>::Output

fn _log(self, base: f32) -> <bf16 as FloatOutBinary<f32>>::Output

fn _hypot(self, rhs: f32) -> <bf16 as FloatOutBinary<f32>>::Output

impl FloatOutBinary<f32> for f16

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

fn _div(self, rhs: f32) -> <f16 as FloatOutBinary<f32>>::Output

fn _log(self, base: f32) -> <f16 as FloatOutBinary<f32>>::Output

fn _hypot(self, rhs: f32) -> <f16 as FloatOutBinary<f32>>::Output

impl FloatOutBinary<f32> for Complex<f32>

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

fn _div(self, rhs: f32) -> <Complex<f32> as FloatOutBinary<f32>>::Output

fn _log(self, base: f32) -> <Complex<f32> as FloatOutBinary<f32>>::Output

fn _hypot(self, rhs: f32) -> <Complex<f32> as FloatOutBinary<f32>>::Output

impl FloatOutBinary<f32> for Complex<f64>

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

fn _div(self, rhs: f32) -> <Complex<f64> as FloatOutBinary<f32>>::Output

fn _log(self, base: f32) -> <Complex<f64> as FloatOutBinary<f32>>::Output

fn _hypot(self, rhs: f32) -> <Complex<f64> as FloatOutBinary<f32>>::Output

impl FloatOutBinary<f64> for bool

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

fn _div(self, rhs: f64) -> <bool as FloatOutBinary<f64>>::Output

fn _log(self, base: f64) -> <bool as FloatOutBinary<f64>>::Output

fn _hypot(self, rhs: f64) -> <bool as FloatOutBinary<f64>>::Output

impl FloatOutBinary<f64> for f32

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

fn _div(self, rhs: f64) -> <f32 as FloatOutBinary<f64>>::Output

fn _log(self, base: f64) -> <f32 as FloatOutBinary<f64>>::Output

fn _hypot(self, rhs: f64) -> <f32 as FloatOutBinary<f64>>::Output

impl FloatOutBinary<f64> for i8

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

fn _div(self, rhs: f64) -> <i8 as FloatOutBinary<f64>>::Output

fn _log(self, base: f64) -> <i8 as FloatOutBinary<f64>>::Output

fn _hypot(self, rhs: f64) -> <i8 as FloatOutBinary<f64>>::Output

impl FloatOutBinary<f64> for i16

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

fn _div(self, rhs: f64) -> <i16 as FloatOutBinary<f64>>::Output

fn _log(self, base: f64) -> <i16 as FloatOutBinary<f64>>::Output

fn _hypot(self, rhs: f64) -> <i16 as FloatOutBinary<f64>>::Output

impl FloatOutBinary<f64> for i32

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

fn _div(self, rhs: f64) -> <i32 as FloatOutBinary<f64>>::Output

fn _log(self, base: f64) -> <i32 as FloatOutBinary<f64>>::Output

fn _hypot(self, rhs: f64) -> <i32 as FloatOutBinary<f64>>::Output

impl FloatOutBinary<f64> for i64

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

fn _div(self, rhs: f64) -> <i64 as FloatOutBinary<f64>>::Output

fn _log(self, base: f64) -> <i64 as FloatOutBinary<f64>>::Output

fn _hypot(self, rhs: f64) -> <i64 as FloatOutBinary<f64>>::Output

impl FloatOutBinary<f64> for isize

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

fn _div(self, rhs: f64) -> <isize as FloatOutBinary<f64>>::Output

fn _log(self, base: f64) -> <isize as FloatOutBinary<f64>>::Output

fn _hypot(self, rhs: f64) -> <isize as FloatOutBinary<f64>>::Output

impl FloatOutBinary<f64> for u8

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

fn _div(self, rhs: f64) -> <u8 as FloatOutBinary<f64>>::Output

fn _log(self, base: f64) -> <u8 as FloatOutBinary<f64>>::Output

fn _hypot(self, rhs: f64) -> <u8 as FloatOutBinary<f64>>::Output

impl FloatOutBinary<f64> for u16

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

fn _div(self, rhs: f64) -> <u16 as FloatOutBinary<f64>>::Output

fn _log(self, base: f64) -> <u16 as FloatOutBinary<f64>>::Output

fn _hypot(self, rhs: f64) -> <u16 as FloatOutBinary<f64>>::Output

impl FloatOutBinary<f64> for u32

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

fn _div(self, rhs: f64) -> <u32 as FloatOutBinary<f64>>::Output

fn _log(self, base: f64) -> <u32 as FloatOutBinary<f64>>::Output

fn _hypot(self, rhs: f64) -> <u32 as FloatOutBinary<f64>>::Output

impl FloatOutBinary<f64> for u64

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

fn _div(self, rhs: f64) -> <u64 as FloatOutBinary<f64>>::Output

fn _log(self, base: f64) -> <u64 as FloatOutBinary<f64>>::Output

fn _hypot(self, rhs: f64) -> <u64 as FloatOutBinary<f64>>::Output

impl FloatOutBinary<f64> for usize

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

fn _div(self, rhs: f64) -> <usize as FloatOutBinary<f64>>::Output

fn _log(self, base: f64) -> <usize as FloatOutBinary<f64>>::Output

fn _hypot(self, rhs: f64) -> <usize as FloatOutBinary<f64>>::Output

impl FloatOutBinary<f64> for bf16

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

fn _div(self, rhs: f64) -> <bf16 as FloatOutBinary<f64>>::Output

fn _log(self, base: f64) -> <bf16 as FloatOutBinary<f64>>::Output

fn _hypot(self, rhs: f64) -> <bf16 as FloatOutBinary<f64>>::Output

impl FloatOutBinary<f64> for f16

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

fn _div(self, rhs: f64) -> <f16 as FloatOutBinary<f64>>::Output

fn _log(self, base: f64) -> <f16 as FloatOutBinary<f64>>::Output

fn _hypot(self, rhs: f64) -> <f16 as FloatOutBinary<f64>>::Output

impl FloatOutBinary<f64> for Complex<f32>

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

fn _div(self, rhs: f64) -> <Complex<f32> as FloatOutBinary<f64>>::Output

fn _log(self, base: f64) -> <Complex<f32> as FloatOutBinary<f64>>::Output

fn _hypot(self, rhs: f64) -> <Complex<f32> as FloatOutBinary<f64>>::Output

impl FloatOutBinary<f64> for Complex<f64>

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

fn _div(self, rhs: f64) -> <Complex<f64> as FloatOutBinary<f64>>::Output

fn _log(self, base: f64) -> <Complex<f64> as FloatOutBinary<f64>>::Output

fn _hypot(self, rhs: f64) -> <Complex<f64> as FloatOutBinary<f64>>::Output

impl FloatOutBinary<i8> for bool

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

fn _div(self, rhs: i8) -> <bool as FloatOutBinary<i8>>::Output

fn _log(self, base: i8) -> <bool as FloatOutBinary<i8>>::Output

fn _hypot(self, rhs: i8) -> <bool as FloatOutBinary<i8>>::Output

impl FloatOutBinary<i8> for f32

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

fn _div(self, rhs: i8) -> <f32 as FloatOutBinary<i8>>::Output

fn _log(self, base: i8) -> <f32 as FloatOutBinary<i8>>::Output

fn _hypot(self, rhs: i8) -> <f32 as FloatOutBinary<i8>>::Output

impl FloatOutBinary<i8> for f64

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

fn _div(self, rhs: i8) -> <f64 as FloatOutBinary<i8>>::Output

fn _log(self, base: i8) -> <f64 as FloatOutBinary<i8>>::Output

fn _hypot(self, rhs: i8) -> <f64 as FloatOutBinary<i8>>::Output

impl FloatOutBinary<i8> for i16

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

fn _div(self, rhs: i8) -> <i16 as FloatOutBinary<i8>>::Output

fn _log(self, base: i8) -> <i16 as FloatOutBinary<i8>>::Output

fn _hypot(self, rhs: i8) -> <i16 as FloatOutBinary<i8>>::Output

impl FloatOutBinary<i8> for i32

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

fn _div(self, rhs: i8) -> <i32 as FloatOutBinary<i8>>::Output

fn _log(self, base: i8) -> <i32 as FloatOutBinary<i8>>::Output

fn _hypot(self, rhs: i8) -> <i32 as FloatOutBinary<i8>>::Output

impl FloatOutBinary<i8> for i64

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

fn _div(self, rhs: i8) -> <i64 as FloatOutBinary<i8>>::Output

fn _log(self, base: i8) -> <i64 as FloatOutBinary<i8>>::Output

fn _hypot(self, rhs: i8) -> <i64 as FloatOutBinary<i8>>::Output

impl FloatOutBinary<i8> for isize

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

fn _div(self, rhs: i8) -> <isize as FloatOutBinary<i8>>::Output

fn _log(self, base: i8) -> <isize as FloatOutBinary<i8>>::Output

fn _hypot(self, rhs: i8) -> <isize as FloatOutBinary<i8>>::Output

impl FloatOutBinary<i8> for u8

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

fn _div(self, rhs: i8) -> <u8 as FloatOutBinary<i8>>::Output

fn _log(self, base: i8) -> <u8 as FloatOutBinary<i8>>::Output

fn _hypot(self, rhs: i8) -> <u8 as FloatOutBinary<i8>>::Output

impl FloatOutBinary<i8> for u16

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

fn _div(self, rhs: i8) -> <u16 as FloatOutBinary<i8>>::Output

fn _log(self, base: i8) -> <u16 as FloatOutBinary<i8>>::Output

fn _hypot(self, rhs: i8) -> <u16 as FloatOutBinary<i8>>::Output

impl FloatOutBinary<i8> for u32

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

fn _div(self, rhs: i8) -> <u32 as FloatOutBinary<i8>>::Output

fn _log(self, base: i8) -> <u32 as FloatOutBinary<i8>>::Output

fn _hypot(self, rhs: i8) -> <u32 as FloatOutBinary<i8>>::Output

impl FloatOutBinary<i8> for u64

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

fn _div(self, rhs: i8) -> <u64 as FloatOutBinary<i8>>::Output

fn _log(self, base: i8) -> <u64 as FloatOutBinary<i8>>::Output

fn _hypot(self, rhs: i8) -> <u64 as FloatOutBinary<i8>>::Output

impl FloatOutBinary<i8> for usize

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

fn _div(self, rhs: i8) -> <usize as FloatOutBinary<i8>>::Output

fn _log(self, base: i8) -> <usize as FloatOutBinary<i8>>::Output

fn _hypot(self, rhs: i8) -> <usize as FloatOutBinary<i8>>::Output

impl FloatOutBinary<i8> for bf16

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

fn _div(self, rhs: i8) -> <bf16 as FloatOutBinary<i8>>::Output

fn _log(self, base: i8) -> <bf16 as FloatOutBinary<i8>>::Output

fn _hypot(self, rhs: i8) -> <bf16 as FloatOutBinary<i8>>::Output

impl FloatOutBinary<i8> for f16

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

fn _div(self, rhs: i8) -> <f16 as FloatOutBinary<i8>>::Output

fn _log(self, base: i8) -> <f16 as FloatOutBinary<i8>>::Output

fn _hypot(self, rhs: i8) -> <f16 as FloatOutBinary<i8>>::Output

impl FloatOutBinary<i8> for Complex<f32>

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

fn _div(self, rhs: i8) -> <Complex<f32> as FloatOutBinary<i8>>::Output

fn _log(self, base: i8) -> <Complex<f32> as FloatOutBinary<i8>>::Output

fn _hypot(self, rhs: i8) -> <Complex<f32> as FloatOutBinary<i8>>::Output

impl FloatOutBinary<i8> for Complex<f64>

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

fn _div(self, rhs: i8) -> <Complex<f64> as FloatOutBinary<i8>>::Output

fn _log(self, base: i8) -> <Complex<f64> as FloatOutBinary<i8>>::Output

fn _hypot(self, rhs: i8) -> <Complex<f64> as FloatOutBinary<i8>>::Output

impl FloatOutBinary<i16> for bool

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

fn _div(self, rhs: i16) -> <bool as FloatOutBinary<i16>>::Output

fn _log(self, base: i16) -> <bool as FloatOutBinary<i16>>::Output

fn _hypot(self, rhs: i16) -> <bool as FloatOutBinary<i16>>::Output

impl FloatOutBinary<i16> for f32

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

fn _div(self, rhs: i16) -> <f32 as FloatOutBinary<i16>>::Output

fn _log(self, base: i16) -> <f32 as FloatOutBinary<i16>>::Output

fn _hypot(self, rhs: i16) -> <f32 as FloatOutBinary<i16>>::Output

impl FloatOutBinary<i16> for f64

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

fn _div(self, rhs: i16) -> <f64 as FloatOutBinary<i16>>::Output

fn _log(self, base: i16) -> <f64 as FloatOutBinary<i16>>::Output

fn _hypot(self, rhs: i16) -> <f64 as FloatOutBinary<i16>>::Output

impl FloatOutBinary<i16> for i8

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

fn _div(self, rhs: i16) -> <i8 as FloatOutBinary<i16>>::Output

fn _log(self, base: i16) -> <i8 as FloatOutBinary<i16>>::Output

fn _hypot(self, rhs: i16) -> <i8 as FloatOutBinary<i16>>::Output

impl FloatOutBinary<i16> for i32

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

fn _div(self, rhs: i16) -> <i32 as FloatOutBinary<i16>>::Output

fn _log(self, base: i16) -> <i32 as FloatOutBinary<i16>>::Output

fn _hypot(self, rhs: i16) -> <i32 as FloatOutBinary<i16>>::Output

impl FloatOutBinary<i16> for i64

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

fn _div(self, rhs: i16) -> <i64 as FloatOutBinary<i16>>::Output

fn _log(self, base: i16) -> <i64 as FloatOutBinary<i16>>::Output

fn _hypot(self, rhs: i16) -> <i64 as FloatOutBinary<i16>>::Output

impl FloatOutBinary<i16> for isize

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

fn _div(self, rhs: i16) -> <isize as FloatOutBinary<i16>>::Output

fn _log(self, base: i16) -> <isize as FloatOutBinary<i16>>::Output

fn _hypot(self, rhs: i16) -> <isize as FloatOutBinary<i16>>::Output

impl FloatOutBinary<i16> for u8

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

fn _div(self, rhs: i16) -> <u8 as FloatOutBinary<i16>>::Output

fn _log(self, base: i16) -> <u8 as FloatOutBinary<i16>>::Output

fn _hypot(self, rhs: i16) -> <u8 as FloatOutBinary<i16>>::Output

impl FloatOutBinary<i16> for u16

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

fn _div(self, rhs: i16) -> <u16 as FloatOutBinary<i16>>::Output

fn _log(self, base: i16) -> <u16 as FloatOutBinary<i16>>::Output

fn _hypot(self, rhs: i16) -> <u16 as FloatOutBinary<i16>>::Output

impl FloatOutBinary<i16> for u32

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

fn _div(self, rhs: i16) -> <u32 as FloatOutBinary<i16>>::Output

fn _log(self, base: i16) -> <u32 as FloatOutBinary<i16>>::Output

fn _hypot(self, rhs: i16) -> <u32 as FloatOutBinary<i16>>::Output

impl FloatOutBinary<i16> for u64

type Output = <u64 as FloatOutBinaryPromote<i16>>::Output

fn _div(self, rhs: i16) -> <u64 as FloatOutBinary<i16>>::Output

fn _log(self, base: i16) -> <u64 as FloatOutBinary<i16>>::Output

fn _hypot(self, rhs: i16) -> <u64 as FloatOutBinary<i16>>::Output

impl FloatOutBinary<i16> for usize

type Output = <usize as FloatOutBinaryPromote<i16>>::Output

fn _div(self, rhs: i16) -> <usize as FloatOutBinary<i16>>::Output

fn _log(self, base: i16) -> <usize as FloatOutBinary<i16>>::Output

fn _hypot(self, rhs: i16) -> <usize as FloatOutBinary<i16>>::Output

impl FloatOutBinary<i16> for bf16

type Output = <bf16 as FloatOutBinaryPromote<i16>>::Output

fn _div(self, rhs: i16) -> <bf16 as FloatOutBinary<i16>>::Output

fn _log(self, base: i16) -> <bf16 as FloatOutBinary<i16>>::Output

fn _hypot(self, rhs: i16) -> <bf16 as FloatOutBinary<i16>>::Output

impl FloatOutBinary<i16> for f16

type Output = <f16 as FloatOutBinaryPromote<i16>>::Output

fn _div(self, rhs: i16) -> <f16 as FloatOutBinary<i16>>::Output

fn _log(self, base: i16) -> <f16 as FloatOutBinary<i16>>::Output

fn _hypot(self, rhs: i16) -> <f16 as FloatOutBinary<i16>>::Output

impl FloatOutBinary<i16> for Complex<f32>

type Output = <Complex<f32> as FloatOutBinaryPromote<i16>>::Output

fn _div(self, rhs: i16) -> <Complex<f32> as FloatOutBinary<i16>>::Output

fn _log(self, base: i16) -> <Complex<f32> as FloatOutBinary<i16>>::Output

fn _hypot(self, rhs: i16) -> <Complex<f32> as FloatOutBinary<i16>>::Output

impl FloatOutBinary<i16> for Complex<f64>

type Output = <Complex<f64> as FloatOutBinaryPromote<i16>>::Output

fn _div(self, rhs: i16) -> <Complex<f64> as FloatOutBinary<i16>>::Output

fn _log(self, base: i16) -> <Complex<f64> as FloatOutBinary<i16>>::Output

fn _hypot(self, rhs: i16) -> <Complex<f64> as FloatOutBinary<i16>>::Output

impl FloatOutBinary<i32> for bool

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

fn _div(self, rhs: i32) -> <bool as FloatOutBinary<i32>>::Output

fn _log(self, base: i32) -> <bool as FloatOutBinary<i32>>::Output

fn _hypot(self, rhs: i32) -> <bool as FloatOutBinary<i32>>::Output

impl FloatOutBinary<i32> for f32

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

fn _div(self, rhs: i32) -> <f32 as FloatOutBinary<i32>>::Output

fn _log(self, base: i32) -> <f32 as FloatOutBinary<i32>>::Output

fn _hypot(self, rhs: i32) -> <f32 as FloatOutBinary<i32>>::Output

impl FloatOutBinary<i32> for f64

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

fn _div(self, rhs: i32) -> <f64 as FloatOutBinary<i32>>::Output

fn _log(self, base: i32) -> <f64 as FloatOutBinary<i32>>::Output

fn _hypot(self, rhs: i32) -> <f64 as FloatOutBinary<i32>>::Output

impl FloatOutBinary<i32> for i8

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

fn _div(self, rhs: i32) -> <i8 as FloatOutBinary<i32>>::Output

fn _log(self, base: i32) -> <i8 as FloatOutBinary<i32>>::Output

fn _hypot(self, rhs: i32) -> <i8 as FloatOutBinary<i32>>::Output

impl FloatOutBinary<i32> for i16

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

fn _div(self, rhs: i32) -> <i16 as FloatOutBinary<i32>>::Output

fn _log(self, base: i32) -> <i16 as FloatOutBinary<i32>>::Output

fn _hypot(self, rhs: i32) -> <i16 as FloatOutBinary<i32>>::Output

impl FloatOutBinary<i32> for i64

type Output = <i64 as FloatOutBinaryPromote<i32>>::Output

fn _div(self, rhs: i32) -> <i64 as FloatOutBinary<i32>>::Output

fn _log(self, base: i32) -> <i64 as FloatOutBinary<i32>>::Output

fn _hypot(self, rhs: i32) -> <i64 as FloatOutBinary<i32>>::Output

impl FloatOutBinary<i32> for isize

type Output = <isize as FloatOutBinaryPromote<i32>>::Output

fn _div(self, rhs: i32) -> <isize as FloatOutBinary<i32>>::Output

fn _log(self, base: i32) -> <isize as FloatOutBinary<i32>>::Output

fn _hypot(self, rhs: i32) -> <isize as FloatOutBinary<i32>>::Output

impl FloatOutBinary<i32> for u8

type Output = <u8 as FloatOutBinaryPromote<i32>>::Output

fn _div(self, rhs: i32) -> <u8 as FloatOutBinary<i32>>::Output

fn _log(self, base: i32) -> <u8 as FloatOutBinary<i32>>::Output

fn _hypot(self, rhs: i32) -> <u8 as FloatOutBinary<i32>>::Output

impl FloatOutBinary<i32> for u16

type Output = <u16 as FloatOutBinaryPromote<i32>>::Output

fn _div(self, rhs: i32) -> <u16 as FloatOutBinary<i32>>::Output

fn _log(self, base: i32) -> <u16 as FloatOutBinary<i32>>::Output

fn _hypot(self, rhs: i32) -> <u16 as FloatOutBinary<i32>>::Output

impl FloatOutBinary<i32> for u32

type Output = <u32 as FloatOutBinaryPromote<i32>>::Output

fn _div(self, rhs: i32) -> <u32 as FloatOutBinary<i32>>::Output

fn _log(self, base: i32) -> <u32 as FloatOutBinary<i32>>::Output

fn _hypot(self, rhs: i32) -> <u32 as FloatOutBinary<i32>>::Output

impl FloatOutBinary<i32> for u64

type Output = <u64 as FloatOutBinaryPromote<i32>>::Output

fn _div(self, rhs: i32) -> <u64 as FloatOutBinary<i32>>::Output

fn _log(self, base: i32) -> <u64 as FloatOutBinary<i32>>::Output

fn _hypot(self, rhs: i32) -> <u64 as FloatOutBinary<i32>>::Output

impl FloatOutBinary<i32> for usize

type Output = <usize as FloatOutBinaryPromote<i32>>::Output

fn _div(self, rhs: i32) -> <usize as FloatOutBinary<i32>>::Output

fn _log(self, base: i32) -> <usize as FloatOutBinary<i32>>::Output

fn _hypot(self, rhs: i32) -> <usize as FloatOutBinary<i32>>::Output

impl FloatOutBinary<i32> for bf16

type Output = <bf16 as FloatOutBinaryPromote<i32>>::Output

fn _div(self, rhs: i32) -> <bf16 as FloatOutBinary<i32>>::Output

fn _log(self, base: i32) -> <bf16 as FloatOutBinary<i32>>::Output

fn _hypot(self, rhs: i32) -> <bf16 as FloatOutBinary<i32>>::Output

impl FloatOutBinary<i32> for f16

type Output = <f16 as FloatOutBinaryPromote<i32>>::Output

fn _div(self, rhs: i32) -> <f16 as FloatOutBinary<i32>>::Output

fn _log(self, base: i32) -> <f16 as FloatOutBinary<i32>>::Output

fn _hypot(self, rhs: i32) -> <f16 as FloatOutBinary<i32>>::Output

impl FloatOutBinary<i32> for Complex<f32>

type Output = <Complex<f32> as FloatOutBinaryPromote<i32>>::Output

fn _div(self, rhs: i32) -> <Complex<f32> as FloatOutBinary<i32>>::Output

fn _log(self, base: i32) -> <Complex<f32> as FloatOutBinary<i32>>::Output

fn _hypot(self, rhs: i32) -> <Complex<f32> as FloatOutBinary<i32>>::Output

impl FloatOutBinary<i32> for Complex<f64>

type Output = <Complex<f64> as FloatOutBinaryPromote<i32>>::Output

fn _div(self, rhs: i32) -> <Complex<f64> as FloatOutBinary<i32>>::Output

fn _log(self, base: i32) -> <Complex<f64> as FloatOutBinary<i32>>::Output

fn _hypot(self, rhs: i32) -> <Complex<f64> as FloatOutBinary<i32>>::Output

impl FloatOutBinary<i64> for bool

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

fn _div(self, rhs: i64) -> <bool as FloatOutBinary<i64>>::Output

fn _log(self, base: i64) -> <bool as FloatOutBinary<i64>>::Output

fn _hypot(self, rhs: i64) -> <bool as FloatOutBinary<i64>>::Output

impl FloatOutBinary<i64> for f32

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

fn _div(self, rhs: i64) -> <f32 as FloatOutBinary<i64>>::Output

fn _log(self, base: i64) -> <f32 as FloatOutBinary<i64>>::Output

fn _hypot(self, rhs: i64) -> <f32 as FloatOutBinary<i64>>::Output

impl FloatOutBinary<i64> for f64

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

fn _div(self, rhs: i64) -> <f64 as FloatOutBinary<i64>>::Output

fn _log(self, base: i64) -> <f64 as FloatOutBinary<i64>>::Output

fn _hypot(self, rhs: i64) -> <f64 as FloatOutBinary<i64>>::Output

impl FloatOutBinary<i64> for i8

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

fn _div(self, rhs: i64) -> <i8 as FloatOutBinary<i64>>::Output

fn _log(self, base: i64) -> <i8 as FloatOutBinary<i64>>::Output

fn _hypot(self, rhs: i64) -> <i8 as FloatOutBinary<i64>>::Output

impl FloatOutBinary<i64> for i16

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

fn _div(self, rhs: i64) -> <i16 as FloatOutBinary<i64>>::Output

fn _log(self, base: i64) -> <i16 as FloatOutBinary<i64>>::Output

fn _hypot(self, rhs: i64) -> <i16 as FloatOutBinary<i64>>::Output

impl FloatOutBinary<i64> for i32

type Output = <i32 as FloatOutBinaryPromote<i64>>::Output

fn _div(self, rhs: i64) -> <i32 as FloatOutBinary<i64>>::Output

fn _log(self, base: i64) -> <i32 as FloatOutBinary<i64>>::Output

fn _hypot(self, rhs: i64) -> <i32 as FloatOutBinary<i64>>::Output

impl FloatOutBinary<i64> for isize

type Output = <isize as FloatOutBinaryPromote<i64>>::Output

fn _div(self, rhs: i64) -> <isize as FloatOutBinary<i64>>::Output

fn _log(self, base: i64) -> <isize as FloatOutBinary<i64>>::Output

fn _hypot(self, rhs: i64) -> <isize as FloatOutBinary<i64>>::Output

impl FloatOutBinary<i64> for u8

type Output = <u8 as FloatOutBinaryPromote<i64>>::Output

fn _div(self, rhs: i64) -> <u8 as FloatOutBinary<i64>>::Output

fn _log(self, base: i64) -> <u8 as FloatOutBinary<i64>>::Output

fn _hypot(self, rhs: i64) -> <u8 as FloatOutBinary<i64>>::Output

impl FloatOutBinary<i64> for u16

type Output = <u16 as FloatOutBinaryPromote<i64>>::Output

fn _div(self, rhs: i64) -> <u16 as FloatOutBinary<i64>>::Output

fn _log(self, base: i64) -> <u16 as FloatOutBinary<i64>>::Output

fn _hypot(self, rhs: i64) -> <u16 as FloatOutBinary<i64>>::Output

impl FloatOutBinary<i64> for u32

type Output = <u32 as FloatOutBinaryPromote<i64>>::Output

fn _div(self, rhs: i64) -> <u32 as FloatOutBinary<i64>>::Output

fn _log(self, base: i64) -> <u32 as FloatOutBinary<i64>>::Output

fn _hypot(self, rhs: i64) -> <u32 as FloatOutBinary<i64>>::Output

impl FloatOutBinary<i64> for u64

type Output = <u64 as FloatOutBinaryPromote<i64>>::Output

fn _div(self, rhs: i64) -> <u64 as FloatOutBinary<i64>>::Output

fn _log(self, base: i64) -> <u64 as FloatOutBinary<i64>>::Output

fn _hypot(self, rhs: i64) -> <u64 as FloatOutBinary<i64>>::Output

impl FloatOutBinary<i64> for usize

type Output = <usize as FloatOutBinaryPromote<i64>>::Output

fn _div(self, rhs: i64) -> <usize as FloatOutBinary<i64>>::Output

fn _log(self, base: i64) -> <usize as FloatOutBinary<i64>>::Output

fn _hypot(self, rhs: i64) -> <usize as FloatOutBinary<i64>>::Output

impl FloatOutBinary<i64> for bf16

type Output = <bf16 as FloatOutBinaryPromote<i64>>::Output

fn _div(self, rhs: i64) -> <bf16 as FloatOutBinary<i64>>::Output

fn _log(self, base: i64) -> <bf16 as FloatOutBinary<i64>>::Output

fn _hypot(self, rhs: i64) -> <bf16 as FloatOutBinary<i64>>::Output

impl FloatOutBinary<i64> for f16

type Output = <f16 as FloatOutBinaryPromote<i64>>::Output

fn _div(self, rhs: i64) -> <f16 as FloatOutBinary<i64>>::Output

fn _log(self, base: i64) -> <f16 as FloatOutBinary<i64>>::Output

fn _hypot(self, rhs: i64) -> <f16 as FloatOutBinary<i64>>::Output

impl FloatOutBinary<i64> for Complex<f32>

type Output = <Complex<f32> as FloatOutBinaryPromote<i64>>::Output

fn _div(self, rhs: i64) -> <Complex<f32> as FloatOutBinary<i64>>::Output

fn _log(self, base: i64) -> <Complex<f32> as FloatOutBinary<i64>>::Output

fn _hypot(self, rhs: i64) -> <Complex<f32> as FloatOutBinary<i64>>::Output

impl FloatOutBinary<i64> for Complex<f64>

type Output = <Complex<f64> as FloatOutBinaryPromote<i64>>::Output

fn _div(self, rhs: i64) -> <Complex<f64> as FloatOutBinary<i64>>::Output

fn _log(self, base: i64) -> <Complex<f64> as FloatOutBinary<i64>>::Output

fn _hypot(self, rhs: i64) -> <Complex<f64> as FloatOutBinary<i64>>::Output

impl FloatOutBinary<isize> for bool

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

fn _div(self, rhs: isize) -> <bool as FloatOutBinary<isize>>::Output

fn _log(self, base: isize) -> <bool as FloatOutBinary<isize>>::Output

fn _hypot(self, rhs: isize) -> <bool as FloatOutBinary<isize>>::Output

impl FloatOutBinary<isize> for f32

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

fn _div(self, rhs: isize) -> <f32 as FloatOutBinary<isize>>::Output

fn _log(self, base: isize) -> <f32 as FloatOutBinary<isize>>::Output

fn _hypot(self, rhs: isize) -> <f32 as FloatOutBinary<isize>>::Output

impl FloatOutBinary<isize> for f64

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

fn _div(self, rhs: isize) -> <f64 as FloatOutBinary<isize>>::Output

fn _log(self, base: isize) -> <f64 as FloatOutBinary<isize>>::Output

fn _hypot(self, rhs: isize) -> <f64 as FloatOutBinary<isize>>::Output

impl FloatOutBinary<isize> for i8

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

fn _div(self, rhs: isize) -> <i8 as FloatOutBinary<isize>>::Output

fn _log(self, base: isize) -> <i8 as FloatOutBinary<isize>>::Output

fn _hypot(self, rhs: isize) -> <i8 as FloatOutBinary<isize>>::Output

impl FloatOutBinary<isize> for i16

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

fn _div(self, rhs: isize) -> <i16 as FloatOutBinary<isize>>::Output

fn _log(self, base: isize) -> <i16 as FloatOutBinary<isize>>::Output

fn _hypot(self, rhs: isize) -> <i16 as FloatOutBinary<isize>>::Output

impl FloatOutBinary<isize> for i32

type Output = <i32 as FloatOutBinaryPromote<isize>>::Output

fn _div(self, rhs: isize) -> <i32 as FloatOutBinary<isize>>::Output

fn _log(self, base: isize) -> <i32 as FloatOutBinary<isize>>::Output

fn _hypot(self, rhs: isize) -> <i32 as FloatOutBinary<isize>>::Output

impl FloatOutBinary<isize> for i64

type Output = <i64 as FloatOutBinaryPromote<isize>>::Output

fn _div(self, rhs: isize) -> <i64 as FloatOutBinary<isize>>::Output

fn _log(self, base: isize) -> <i64 as FloatOutBinary<isize>>::Output

fn _hypot(self, rhs: isize) -> <i64 as FloatOutBinary<isize>>::Output

impl FloatOutBinary<isize> for u8

type Output = <u8 as FloatOutBinaryPromote<isize>>::Output

fn _div(self, rhs: isize) -> <u8 as FloatOutBinary<isize>>::Output

fn _log(self, base: isize) -> <u8 as FloatOutBinary<isize>>::Output

fn _hypot(self, rhs: isize) -> <u8 as FloatOutBinary<isize>>::Output

impl FloatOutBinary<isize> for u16

type Output = <u16 as FloatOutBinaryPromote<isize>>::Output

fn _div(self, rhs: isize) -> <u16 as FloatOutBinary<isize>>::Output

fn _log(self, base: isize) -> <u16 as FloatOutBinary<isize>>::Output

fn _hypot(self, rhs: isize) -> <u16 as FloatOutBinary<isize>>::Output

impl FloatOutBinary<isize> for u32

type Output = <u32 as FloatOutBinaryPromote<isize>>::Output

fn _div(self, rhs: isize) -> <u32 as FloatOutBinary<isize>>::Output

fn _log(self, base: isize) -> <u32 as FloatOutBinary<isize>>::Output

fn _hypot(self, rhs: isize) -> <u32 as FloatOutBinary<isize>>::Output

impl FloatOutBinary<isize> for u64

type Output = <u64 as FloatOutBinaryPromote<isize>>::Output

fn _div(self, rhs: isize) -> <u64 as FloatOutBinary<isize>>::Output

fn _log(self, base: isize) -> <u64 as FloatOutBinary<isize>>::Output

fn _hypot(self, rhs: isize) -> <u64 as FloatOutBinary<isize>>::Output

impl FloatOutBinary<isize> for usize

type Output = <usize as FloatOutBinaryPromote<isize>>::Output

fn _div(self, rhs: isize) -> <usize as FloatOutBinary<isize>>::Output

fn _log(self, base: isize) -> <usize as FloatOutBinary<isize>>::Output

fn _hypot(self, rhs: isize) -> <usize as FloatOutBinary<isize>>::Output

impl FloatOutBinary<isize> for bf16

type Output = <bf16 as FloatOutBinaryPromote<isize>>::Output

fn _div(self, rhs: isize) -> <bf16 as FloatOutBinary<isize>>::Output

fn _log(self, base: isize) -> <bf16 as FloatOutBinary<isize>>::Output

fn _hypot(self, rhs: isize) -> <bf16 as FloatOutBinary<isize>>::Output

impl FloatOutBinary<isize> for f16

type Output = <f16 as FloatOutBinaryPromote<isize>>::Output

fn _div(self, rhs: isize) -> <f16 as FloatOutBinary<isize>>::Output

fn _log(self, base: isize) -> <f16 as FloatOutBinary<isize>>::Output

fn _hypot(self, rhs: isize) -> <f16 as FloatOutBinary<isize>>::Output

impl FloatOutBinary<isize> for Complex<f32>

type Output = <Complex<f32> as FloatOutBinaryPromote<isize>>::Output

fn _div(self, rhs: isize) -> <Complex<f32> as FloatOutBinary<isize>>::Output

fn _log(self, base: isize) -> <Complex<f32> as FloatOutBinary<isize>>::Output

fn _hypot(self, rhs: isize) -> <Complex<f32> as FloatOutBinary<isize>>::Output

impl FloatOutBinary<isize> for Complex<f64>

type Output = <Complex<f64> as FloatOutBinaryPromote<isize>>::Output

fn _div(self, rhs: isize) -> <Complex<f64> as FloatOutBinary<isize>>::Output

fn _log(self, base: isize) -> <Complex<f64> as FloatOutBinary<isize>>::Output

fn _hypot(self, rhs: isize) -> <Complex<f64> as FloatOutBinary<isize>>::Output

impl FloatOutBinary<u8> for bool

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

fn _div(self, rhs: u8) -> <bool as FloatOutBinary<u8>>::Output

fn _log(self, base: u8) -> <bool as FloatOutBinary<u8>>::Output

fn _hypot(self, rhs: u8) -> <bool as FloatOutBinary<u8>>::Output

impl FloatOutBinary<u8> for f32

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

fn _div(self, rhs: u8) -> <f32 as FloatOutBinary<u8>>::Output

fn _log(self, base: u8) -> <f32 as FloatOutBinary<u8>>::Output

fn _hypot(self, rhs: u8) -> <f32 as FloatOutBinary<u8>>::Output

impl FloatOutBinary<u8> for f64

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

fn _div(self, rhs: u8) -> <f64 as FloatOutBinary<u8>>::Output

fn _log(self, base: u8) -> <f64 as FloatOutBinary<u8>>::Output

fn _hypot(self, rhs: u8) -> <f64 as FloatOutBinary<u8>>::Output

impl FloatOutBinary<u8> for i8

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

fn _div(self, rhs: u8) -> <i8 as FloatOutBinary<u8>>::Output

fn _log(self, base: u8) -> <i8 as FloatOutBinary<u8>>::Output

fn _hypot(self, rhs: u8) -> <i8 as FloatOutBinary<u8>>::Output

impl FloatOutBinary<u8> for i16

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

fn _div(self, rhs: u8) -> <i16 as FloatOutBinary<u8>>::Output

fn _log(self, base: u8) -> <i16 as FloatOutBinary<u8>>::Output

fn _hypot(self, rhs: u8) -> <i16 as FloatOutBinary<u8>>::Output

impl FloatOutBinary<u8> for i32

type Output = <i32 as FloatOutBinaryPromote<u8>>::Output

fn _div(self, rhs: u8) -> <i32 as FloatOutBinary<u8>>::Output

fn _log(self, base: u8) -> <i32 as FloatOutBinary<u8>>::Output

fn _hypot(self, rhs: u8) -> <i32 as FloatOutBinary<u8>>::Output

impl FloatOutBinary<u8> for i64

type Output = <i64 as FloatOutBinaryPromote<u8>>::Output

fn _div(self, rhs: u8) -> <i64 as FloatOutBinary<u8>>::Output

fn _log(self, base: u8) -> <i64 as FloatOutBinary<u8>>::Output

fn _hypot(self, rhs: u8) -> <i64 as FloatOutBinary<u8>>::Output

impl FloatOutBinary<u8> for isize

type Output = <isize as FloatOutBinaryPromote<u8>>::Output

fn _div(self, rhs: u8) -> <isize as FloatOutBinary<u8>>::Output

fn _log(self, base: u8) -> <isize as FloatOutBinary<u8>>::Output

fn _hypot(self, rhs: u8) -> <isize as FloatOutBinary<u8>>::Output

impl FloatOutBinary<u8> for u16

type Output = <u16 as FloatOutBinaryPromote<u8>>::Output

fn _div(self, rhs: u8) -> <u16 as FloatOutBinary<u8>>::Output

fn _log(self, base: u8) -> <u16 as FloatOutBinary<u8>>::Output

fn _hypot(self, rhs: u8) -> <u16 as FloatOutBinary<u8>>::Output

impl FloatOutBinary<u8> for u32

type Output = <u32 as FloatOutBinaryPromote<u8>>::Output

fn _div(self, rhs: u8) -> <u32 as FloatOutBinary<u8>>::Output

fn _log(self, base: u8) -> <u32 as FloatOutBinary<u8>>::Output

fn _hypot(self, rhs: u8) -> <u32 as FloatOutBinary<u8>>::Output

impl FloatOutBinary<u8> for u64

type Output = <u64 as FloatOutBinaryPromote<u8>>::Output

fn _div(self, rhs: u8) -> <u64 as FloatOutBinary<u8>>::Output

fn _log(self, base: u8) -> <u64 as FloatOutBinary<u8>>::Output

fn _hypot(self, rhs: u8) -> <u64 as FloatOutBinary<u8>>::Output

impl FloatOutBinary<u8> for usize

type Output = <usize as FloatOutBinaryPromote<u8>>::Output

fn _div(self, rhs: u8) -> <usize as FloatOutBinary<u8>>::Output

fn _log(self, base: u8) -> <usize as FloatOutBinary<u8>>::Output

fn _hypot(self, rhs: u8) -> <usize as FloatOutBinary<u8>>::Output

impl FloatOutBinary<u8> for bf16

type Output = <bf16 as FloatOutBinaryPromote<u8>>::Output

fn _div(self, rhs: u8) -> <bf16 as FloatOutBinary<u8>>::Output

fn _log(self, base: u8) -> <bf16 as FloatOutBinary<u8>>::Output

fn _hypot(self, rhs: u8) -> <bf16 as FloatOutBinary<u8>>::Output

impl FloatOutBinary<u8> for f16

type Output = <f16 as FloatOutBinaryPromote<u8>>::Output

fn _div(self, rhs: u8) -> <f16 as FloatOutBinary<u8>>::Output

fn _log(self, base: u8) -> <f16 as FloatOutBinary<u8>>::Output

fn _hypot(self, rhs: u8) -> <f16 as FloatOutBinary<u8>>::Output

impl FloatOutBinary<u8> for Complex<f32>

type Output = <Complex<f32> as FloatOutBinaryPromote<u8>>::Output

fn _div(self, rhs: u8) -> <Complex<f32> as FloatOutBinary<u8>>::Output

fn _log(self, base: u8) -> <Complex<f32> as FloatOutBinary<u8>>::Output

fn _hypot(self, rhs: u8) -> <Complex<f32> as FloatOutBinary<u8>>::Output

impl FloatOutBinary<u8> for Complex<f64>

type Output = <Complex<f64> as FloatOutBinaryPromote<u8>>::Output

fn _div(self, rhs: u8) -> <Complex<f64> as FloatOutBinary<u8>>::Output

fn _log(self, base: u8) -> <Complex<f64> as FloatOutBinary<u8>>::Output

fn _hypot(self, rhs: u8) -> <Complex<f64> as FloatOutBinary<u8>>::Output

impl FloatOutBinary<u16> for bool

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

fn _div(self, rhs: u16) -> <bool as FloatOutBinary<u16>>::Output

fn _log(self, base: u16) -> <bool as FloatOutBinary<u16>>::Output

fn _hypot(self, rhs: u16) -> <bool as FloatOutBinary<u16>>::Output

impl FloatOutBinary<u16> for f32

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

fn _div(self, rhs: u16) -> <f32 as FloatOutBinary<u16>>::Output

fn _log(self, base: u16) -> <f32 as FloatOutBinary<u16>>::Output

fn _hypot(self, rhs: u16) -> <f32 as FloatOutBinary<u16>>::Output

impl FloatOutBinary<u16> for f64

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

fn _div(self, rhs: u16) -> <f64 as FloatOutBinary<u16>>::Output

fn _log(self, base: u16) -> <f64 as FloatOutBinary<u16>>::Output

fn _hypot(self, rhs: u16) -> <f64 as FloatOutBinary<u16>>::Output

impl FloatOutBinary<u16> for i8

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

fn _div(self, rhs: u16) -> <i8 as FloatOutBinary<u16>>::Output

fn _log(self, base: u16) -> <i8 as FloatOutBinary<u16>>::Output

fn _hypot(self, rhs: u16) -> <i8 as FloatOutBinary<u16>>::Output

impl FloatOutBinary<u16> for i16

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

fn _div(self, rhs: u16) -> <i16 as FloatOutBinary<u16>>::Output

fn _log(self, base: u16) -> <i16 as FloatOutBinary<u16>>::Output

fn _hypot(self, rhs: u16) -> <i16 as FloatOutBinary<u16>>::Output

impl FloatOutBinary<u16> for i32

type Output = <i32 as FloatOutBinaryPromote<u16>>::Output

fn _div(self, rhs: u16) -> <i32 as FloatOutBinary<u16>>::Output

fn _log(self, base: u16) -> <i32 as FloatOutBinary<u16>>::Output

fn _hypot(self, rhs: u16) -> <i32 as FloatOutBinary<u16>>::Output

impl FloatOutBinary<u16> for i64

type Output = <i64 as FloatOutBinaryPromote<u16>>::Output

fn _div(self, rhs: u16) -> <i64 as FloatOutBinary<u16>>::Output

fn _log(self, base: u16) -> <i64 as FloatOutBinary<u16>>::Output

fn _hypot(self, rhs: u16) -> <i64 as FloatOutBinary<u16>>::Output

impl FloatOutBinary<u16> for isize

type Output = <isize as FloatOutBinaryPromote<u16>>::Output

fn _div(self, rhs: u16) -> <isize as FloatOutBinary<u16>>::Output

fn _log(self, base: u16) -> <isize as FloatOutBinary<u16>>::Output

fn _hypot(self, rhs: u16) -> <isize as FloatOutBinary<u16>>::Output

impl FloatOutBinary<u16> for u8

type Output = <u8 as FloatOutBinaryPromote<u16>>::Output

fn _div(self, rhs: u16) -> <u8 as FloatOutBinary<u16>>::Output

fn _log(self, base: u16) -> <u8 as FloatOutBinary<u16>>::Output

fn _hypot(self, rhs: u16) -> <u8 as FloatOutBinary<u16>>::Output

impl FloatOutBinary<u16> for u32

type Output = <u32 as FloatOutBinaryPromote<u16>>::Output

fn _div(self, rhs: u16) -> <u32 as FloatOutBinary<u16>>::Output

fn _log(self, base: u16) -> <u32 as FloatOutBinary<u16>>::Output

fn _hypot(self, rhs: u16) -> <u32 as FloatOutBinary<u16>>::Output

impl FloatOutBinary<u16> for u64

type Output = <u64 as FloatOutBinaryPromote<u16>>::Output

fn _div(self, rhs: u16) -> <u64 as FloatOutBinary<u16>>::Output

fn _log(self, base: u16) -> <u64 as FloatOutBinary<u16>>::Output

fn _hypot(self, rhs: u16) -> <u64 as FloatOutBinary<u16>>::Output

impl FloatOutBinary<u16> for usize

type Output = <usize as FloatOutBinaryPromote<u16>>::Output

fn _div(self, rhs: u16) -> <usize as FloatOutBinary<u16>>::Output

fn _log(self, base: u16) -> <usize as FloatOutBinary<u16>>::Output

fn _hypot(self, rhs: u16) -> <usize as FloatOutBinary<u16>>::Output

impl FloatOutBinary<u16> for bf16

type Output = <bf16 as FloatOutBinaryPromote<u16>>::Output

fn _div(self, rhs: u16) -> <bf16 as FloatOutBinary<u16>>::Output

fn _log(self, base: u16) -> <bf16 as FloatOutBinary<u16>>::Output

fn _hypot(self, rhs: u16) -> <bf16 as FloatOutBinary<u16>>::Output

impl FloatOutBinary<u16> for f16

type Output = <f16 as FloatOutBinaryPromote<u16>>::Output

fn _div(self, rhs: u16) -> <f16 as FloatOutBinary<u16>>::Output

fn _log(self, base: u16) -> <f16 as FloatOutBinary<u16>>::Output

fn _hypot(self, rhs: u16) -> <f16 as FloatOutBinary<u16>>::Output

impl FloatOutBinary<u16> for Complex<f32>

type Output = <Complex<f32> as FloatOutBinaryPromote<u16>>::Output

fn _div(self, rhs: u16) -> <Complex<f32> as FloatOutBinary<u16>>::Output

fn _log(self, base: u16) -> <Complex<f32> as FloatOutBinary<u16>>::Output

fn _hypot(self, rhs: u16) -> <Complex<f32> as FloatOutBinary<u16>>::Output

impl FloatOutBinary<u16> for Complex<f64>

type Output = <Complex<f64> as FloatOutBinaryPromote<u16>>::Output

fn _div(self, rhs: u16) -> <Complex<f64> as FloatOutBinary<u16>>::Output

fn _log(self, base: u16) -> <Complex<f64> as FloatOutBinary<u16>>::Output

fn _hypot(self, rhs: u16) -> <Complex<f64> as FloatOutBinary<u16>>::Output

impl FloatOutBinary<u32> for bool

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

fn _div(self, rhs: u32) -> <bool as FloatOutBinary<u32>>::Output

fn _log(self, base: u32) -> <bool as FloatOutBinary<u32>>::Output

fn _hypot(self, rhs: u32) -> <bool as FloatOutBinary<u32>>::Output

impl FloatOutBinary<u32> for f32

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

fn _div(self, rhs: u32) -> <f32 as FloatOutBinary<u32>>::Output

fn _log(self, base: u32) -> <f32 as FloatOutBinary<u32>>::Output

fn _hypot(self, rhs: u32) -> <f32 as FloatOutBinary<u32>>::Output

impl FloatOutBinary<u32> for f64

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

fn _div(self, rhs: u32) -> <f64 as FloatOutBinary<u32>>::Output

fn _log(self, base: u32) -> <f64 as FloatOutBinary<u32>>::Output

fn _hypot(self, rhs: u32) -> <f64 as FloatOutBinary<u32>>::Output

impl FloatOutBinary<u32> for i8

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

fn _div(self, rhs: u32) -> <i8 as FloatOutBinary<u32>>::Output

fn _log(self, base: u32) -> <i8 as FloatOutBinary<u32>>::Output

fn _hypot(self, rhs: u32) -> <i8 as FloatOutBinary<u32>>::Output

impl FloatOutBinary<u32> for i16

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

fn _div(self, rhs: u32) -> <i16 as FloatOutBinary<u32>>::Output

fn _log(self, base: u32) -> <i16 as FloatOutBinary<u32>>::Output

fn _hypot(self, rhs: u32) -> <i16 as FloatOutBinary<u32>>::Output

impl FloatOutBinary<u32> for i32

type Output = <i32 as FloatOutBinaryPromote<u32>>::Output

fn _div(self, rhs: u32) -> <i32 as FloatOutBinary<u32>>::Output

fn _log(self, base: u32) -> <i32 as FloatOutBinary<u32>>::Output

fn _hypot(self, rhs: u32) -> <i32 as FloatOutBinary<u32>>::Output

impl FloatOutBinary<u32> for i64

type Output = <i64 as FloatOutBinaryPromote<u32>>::Output

fn _div(self, rhs: u32) -> <i64 as FloatOutBinary<u32>>::Output

fn _log(self, base: u32) -> <i64 as FloatOutBinary<u32>>::Output

fn _hypot(self, rhs: u32) -> <i64 as FloatOutBinary<u32>>::Output

impl FloatOutBinary<u32> for isize

type Output = <isize as FloatOutBinaryPromote<u32>>::Output

fn _div(self, rhs: u32) -> <isize as FloatOutBinary<u32>>::Output

fn _log(self, base: u32) -> <isize as FloatOutBinary<u32>>::Output

fn _hypot(self, rhs: u32) -> <isize as FloatOutBinary<u32>>::Output

impl FloatOutBinary<u32> for u8

type Output = <u8 as FloatOutBinaryPromote<u32>>::Output

fn _div(self, rhs: u32) -> <u8 as FloatOutBinary<u32>>::Output

fn _log(self, base: u32) -> <u8 as FloatOutBinary<u32>>::Output

fn _hypot(self, rhs: u32) -> <u8 as FloatOutBinary<u32>>::Output

impl FloatOutBinary<u32> for u16

type Output = <u16 as FloatOutBinaryPromote<u32>>::Output

fn _div(self, rhs: u32) -> <u16 as FloatOutBinary<u32>>::Output

fn _log(self, base: u32) -> <u16 as FloatOutBinary<u32>>::Output

fn _hypot(self, rhs: u32) -> <u16 as FloatOutBinary<u32>>::Output

impl FloatOutBinary<u32> for u64

type Output = <u64 as FloatOutBinaryPromote<u32>>::Output

fn _div(self, rhs: u32) -> <u64 as FloatOutBinary<u32>>::Output

fn _log(self, base: u32) -> <u64 as FloatOutBinary<u32>>::Output

fn _hypot(self, rhs: u32) -> <u64 as FloatOutBinary<u32>>::Output

impl FloatOutBinary<u32> for usize

type Output = <usize as FloatOutBinaryPromote<u32>>::Output

fn _div(self, rhs: u32) -> <usize as FloatOutBinary<u32>>::Output

fn _log(self, base: u32) -> <usize as FloatOutBinary<u32>>::Output

fn _hypot(self, rhs: u32) -> <usize as FloatOutBinary<u32>>::Output

impl FloatOutBinary<u32> for bf16

type Output = <bf16 as FloatOutBinaryPromote<u32>>::Output

fn _div(self, rhs: u32) -> <bf16 as FloatOutBinary<u32>>::Output

fn _log(self, base: u32) -> <bf16 as FloatOutBinary<u32>>::Output

fn _hypot(self, rhs: u32) -> <bf16 as FloatOutBinary<u32>>::Output

impl FloatOutBinary<u32> for f16

type Output = <f16 as FloatOutBinaryPromote<u32>>::Output

fn _div(self, rhs: u32) -> <f16 as FloatOutBinary<u32>>::Output

fn _log(self, base: u32) -> <f16 as FloatOutBinary<u32>>::Output

fn _hypot(self, rhs: u32) -> <f16 as FloatOutBinary<u32>>::Output

impl FloatOutBinary<u32> for Complex<f32>

type Output = <Complex<f32> as FloatOutBinaryPromote<u32>>::Output

fn _div(self, rhs: u32) -> <Complex<f32> as FloatOutBinary<u32>>::Output

fn _log(self, base: u32) -> <Complex<f32> as FloatOutBinary<u32>>::Output

fn _hypot(self, rhs: u32) -> <Complex<f32> as FloatOutBinary<u32>>::Output

impl FloatOutBinary<u32> for Complex<f64>

type Output = <Complex<f64> as FloatOutBinaryPromote<u32>>::Output

fn _div(self, rhs: u32) -> <Complex<f64> as FloatOutBinary<u32>>::Output

fn _log(self, base: u32) -> <Complex<f64> as FloatOutBinary<u32>>::Output

fn _hypot(self, rhs: u32) -> <Complex<f64> as FloatOutBinary<u32>>::Output

impl FloatOutBinary<u64> for bool

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

fn _div(self, rhs: u64) -> <bool as FloatOutBinary<u64>>::Output

fn _log(self, base: u64) -> <bool as FloatOutBinary<u64>>::Output

fn _hypot(self, rhs: u64) -> <bool as FloatOutBinary<u64>>::Output

impl FloatOutBinary<u64> for f32

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

fn _div(self, rhs: u64) -> <f32 as FloatOutBinary<u64>>::Output

fn _log(self, base: u64) -> <f32 as FloatOutBinary<u64>>::Output

fn _hypot(self, rhs: u64) -> <f32 as FloatOutBinary<u64>>::Output

impl FloatOutBinary<u64> for f64

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

fn _div(self, rhs: u64) -> <f64 as FloatOutBinary<u64>>::Output

fn _log(self, base: u64) -> <f64 as FloatOutBinary<u64>>::Output

fn _hypot(self, rhs: u64) -> <f64 as FloatOutBinary<u64>>::Output

impl FloatOutBinary<u64> for i8

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

fn _div(self, rhs: u64) -> <i8 as FloatOutBinary<u64>>::Output

fn _log(self, base: u64) -> <i8 as FloatOutBinary<u64>>::Output

fn _hypot(self, rhs: u64) -> <i8 as FloatOutBinary<u64>>::Output

impl FloatOutBinary<u64> for i16

type Output = <i16 as FloatOutBinaryPromote<u64>>::Output

fn _div(self, rhs: u64) -> <i16 as FloatOutBinary<u64>>::Output

fn _log(self, base: u64) -> <i16 as FloatOutBinary<u64>>::Output

fn _hypot(self, rhs: u64) -> <i16 as FloatOutBinary<u64>>::Output

impl FloatOutBinary<u64> for i32

type Output = <i32 as FloatOutBinaryPromote<u64>>::Output

fn _div(self, rhs: u64) -> <i32 as FloatOutBinary<u64>>::Output

fn _log(self, base: u64) -> <i32 as FloatOutBinary<u64>>::Output

fn _hypot(self, rhs: u64) -> <i32 as FloatOutBinary<u64>>::Output

impl FloatOutBinary<u64> for i64

type Output = <i64 as FloatOutBinaryPromote<u64>>::Output

fn _div(self, rhs: u64) -> <i64 as FloatOutBinary<u64>>::Output

fn _log(self, base: u64) -> <i64 as FloatOutBinary<u64>>::Output

fn _hypot(self, rhs: u64) -> <i64 as FloatOutBinary<u64>>::Output

impl FloatOutBinary<u64> for isize

type Output = <isize as FloatOutBinaryPromote<u64>>::Output

fn _div(self, rhs: u64) -> <isize as FloatOutBinary<u64>>::Output

fn _log(self, base: u64) -> <isize as FloatOutBinary<u64>>::Output

fn _hypot(self, rhs: u64) -> <isize as FloatOutBinary<u64>>::Output

impl FloatOutBinary<u64> for u8

type Output = <u8 as FloatOutBinaryPromote<u64>>::Output

fn _div(self, rhs: u64) -> <u8 as FloatOutBinary<u64>>::Output

fn _log(self, base: u64) -> <u8 as FloatOutBinary<u64>>::Output

fn _hypot(self, rhs: u64) -> <u8 as FloatOutBinary<u64>>::Output

impl FloatOutBinary<u64> for u16

type Output = <u16 as FloatOutBinaryPromote<u64>>::Output

fn _div(self, rhs: u64) -> <u16 as FloatOutBinary<u64>>::Output

fn _log(self, base: u64) -> <u16 as FloatOutBinary<u64>>::Output

fn _hypot(self, rhs: u64) -> <u16 as FloatOutBinary<u64>>::Output

impl FloatOutBinary<u64> for u32

type Output = <u32 as FloatOutBinaryPromote<u64>>::Output

fn _div(self, rhs: u64) -> <u32 as FloatOutBinary<u64>>::Output

fn _log(self, base: u64) -> <u32 as FloatOutBinary<u64>>::Output

fn _hypot(self, rhs: u64) -> <u32 as FloatOutBinary<u64>>::Output

impl FloatOutBinary<u64> for usize

type Output = <usize as FloatOutBinaryPromote<u64>>::Output

fn _div(self, rhs: u64) -> <usize as FloatOutBinary<u64>>::Output

fn _log(self, base: u64) -> <usize as FloatOutBinary<u64>>::Output

fn _hypot(self, rhs: u64) -> <usize as FloatOutBinary<u64>>::Output

impl FloatOutBinary<u64> for bf16

type Output = <bf16 as FloatOutBinaryPromote<u64>>::Output

fn _div(self, rhs: u64) -> <bf16 as FloatOutBinary<u64>>::Output

fn _log(self, base: u64) -> <bf16 as FloatOutBinary<u64>>::Output

fn _hypot(self, rhs: u64) -> <bf16 as FloatOutBinary<u64>>::Output

impl FloatOutBinary<u64> for f16

type Output = <f16 as FloatOutBinaryPromote<u64>>::Output

fn _div(self, rhs: u64) -> <f16 as FloatOutBinary<u64>>::Output

fn _log(self, base: u64) -> <f16 as FloatOutBinary<u64>>::Output

fn _hypot(self, rhs: u64) -> <f16 as FloatOutBinary<u64>>::Output

impl FloatOutBinary<u64> for Complex<f32>

type Output = <Complex<f32> as FloatOutBinaryPromote<u64>>::Output

fn _div(self, rhs: u64) -> <Complex<f32> as FloatOutBinary<u64>>::Output

fn _log(self, base: u64) -> <Complex<f32> as FloatOutBinary<u64>>::Output

fn _hypot(self, rhs: u64) -> <Complex<f32> as FloatOutBinary<u64>>::Output

impl FloatOutBinary<u64> for Complex<f64>

type Output = <Complex<f64> as FloatOutBinaryPromote<u64>>::Output

fn _div(self, rhs: u64) -> <Complex<f64> as FloatOutBinary<u64>>::Output

fn _log(self, base: u64) -> <Complex<f64> as FloatOutBinary<u64>>::Output

fn _hypot(self, rhs: u64) -> <Complex<f64> as FloatOutBinary<u64>>::Output

impl FloatOutBinary<usize> for bool

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

fn _div(self, rhs: usize) -> <bool as FloatOutBinary<usize>>::Output

fn _log(self, base: usize) -> <bool as FloatOutBinary<usize>>::Output

fn _hypot(self, rhs: usize) -> <bool as FloatOutBinary<usize>>::Output

impl FloatOutBinary<usize> for f32

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

fn _div(self, rhs: usize) -> <f32 as FloatOutBinary<usize>>::Output

fn _log(self, base: usize) -> <f32 as FloatOutBinary<usize>>::Output

fn _hypot(self, rhs: usize) -> <f32 as FloatOutBinary<usize>>::Output

impl FloatOutBinary<usize> for f64

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

fn _div(self, rhs: usize) -> <f64 as FloatOutBinary<usize>>::Output

fn _log(self, base: usize) -> <f64 as FloatOutBinary<usize>>::Output

fn _hypot(self, rhs: usize) -> <f64 as FloatOutBinary<usize>>::Output

impl FloatOutBinary<usize> for i8

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

fn _div(self, rhs: usize) -> <i8 as FloatOutBinary<usize>>::Output

fn _log(self, base: usize) -> <i8 as FloatOutBinary<usize>>::Output

fn _hypot(self, rhs: usize) -> <i8 as FloatOutBinary<usize>>::Output

impl FloatOutBinary<usize> for i16

type Output = <i16 as FloatOutBinaryPromote<usize>>::Output

fn _div(self, rhs: usize) -> <i16 as FloatOutBinary<usize>>::Output

fn _log(self, base: usize) -> <i16 as FloatOutBinary<usize>>::Output

fn _hypot(self, rhs: usize) -> <i16 as FloatOutBinary<usize>>::Output

impl FloatOutBinary<usize> for i32

type Output = <i32 as FloatOutBinaryPromote<usize>>::Output

fn _div(self, rhs: usize) -> <i32 as FloatOutBinary<usize>>::Output

fn _log(self, base: usize) -> <i32 as FloatOutBinary<usize>>::Output

fn _hypot(self, rhs: usize) -> <i32 as FloatOutBinary<usize>>::Output

impl FloatOutBinary<usize> for i64

type Output = <i64 as FloatOutBinaryPromote<usize>>::Output

fn _div(self, rhs: usize) -> <i64 as FloatOutBinary<usize>>::Output

fn _log(self, base: usize) -> <i64 as FloatOutBinary<usize>>::Output

fn _hypot(self, rhs: usize) -> <i64 as FloatOutBinary<usize>>::Output

impl FloatOutBinary<usize> for isize

type Output = <isize as FloatOutBinaryPromote<usize>>::Output

fn _div(self, rhs: usize) -> <isize as FloatOutBinary<usize>>::Output

fn _log(self, base: usize) -> <isize as FloatOutBinary<usize>>::Output

fn _hypot(self, rhs: usize) -> <isize as FloatOutBinary<usize>>::Output

impl FloatOutBinary<usize> for u8

type Output = <u8 as FloatOutBinaryPromote<usize>>::Output

fn _div(self, rhs: usize) -> <u8 as FloatOutBinary<usize>>::Output

fn _log(self, base: usize) -> <u8 as FloatOutBinary<usize>>::Output

fn _hypot(self, rhs: usize) -> <u8 as FloatOutBinary<usize>>::Output

impl FloatOutBinary<usize> for u16

type Output = <u16 as FloatOutBinaryPromote<usize>>::Output

fn _div(self, rhs: usize) -> <u16 as FloatOutBinary<usize>>::Output

fn _log(self, base: usize) -> <u16 as FloatOutBinary<usize>>::Output

fn _hypot(self, rhs: usize) -> <u16 as FloatOutBinary<usize>>::Output

impl FloatOutBinary<usize> for u32

type Output = <u32 as FloatOutBinaryPromote<usize>>::Output

fn _div(self, rhs: usize) -> <u32 as FloatOutBinary<usize>>::Output

fn _log(self, base: usize) -> <u32 as FloatOutBinary<usize>>::Output

fn _hypot(self, rhs: usize) -> <u32 as FloatOutBinary<usize>>::Output

impl FloatOutBinary<usize> for u64

type Output = <u64 as FloatOutBinaryPromote<usize>>::Output

fn _div(self, rhs: usize) -> <u64 as FloatOutBinary<usize>>::Output

fn _log(self, base: usize) -> <u64 as FloatOutBinary<usize>>::Output

fn _hypot(self, rhs: usize) -> <u64 as FloatOutBinary<usize>>::Output

impl FloatOutBinary<usize> for bf16

type Output = <bf16 as FloatOutBinaryPromote<usize>>::Output

fn _div(self, rhs: usize) -> <bf16 as FloatOutBinary<usize>>::Output

fn _log(self, base: usize) -> <bf16 as FloatOutBinary<usize>>::Output

fn _hypot(self, rhs: usize) -> <bf16 as FloatOutBinary<usize>>::Output

impl FloatOutBinary<usize> for f16

type Output = <f16 as FloatOutBinaryPromote<usize>>::Output

fn _div(self, rhs: usize) -> <f16 as FloatOutBinary<usize>>::Output

fn _log(self, base: usize) -> <f16 as FloatOutBinary<usize>>::Output

fn _hypot(self, rhs: usize) -> <f16 as FloatOutBinary<usize>>::Output

impl FloatOutBinary<usize> for Complex<f32>

type Output = <Complex<f32> as FloatOutBinaryPromote<usize>>::Output

fn _div(self, rhs: usize) -> <Complex<f32> as FloatOutBinary<usize>>::Output

fn _log(self, base: usize) -> <Complex<f32> as FloatOutBinary<usize>>::Output

fn _hypot(self, rhs: usize) -> <Complex<f32> as FloatOutBinary<usize>>::Output

impl FloatOutBinary<usize> for Complex<f64>

type Output = <Complex<f64> as FloatOutBinaryPromote<usize>>::Output

fn _div(self, rhs: usize) -> <Complex<f64> as FloatOutBinary<usize>>::Output

fn _log(self, base: usize) -> <Complex<f64> as FloatOutBinary<usize>>::Output

fn _hypot(self, rhs: usize) -> <Complex<f64> as FloatOutBinary<usize>>::Output

impl FloatOutBinary<bf16x8> for bool

type Output = <boolx16 as FloatOutBinaryPromote<bf16x8>>::Output

fn _div(self, rhs: bf16x8) -> <bool as FloatOutBinary<bf16x8>>::Output

fn _log(self, base: bf16x8) -> <bool as FloatOutBinary<bf16x8>>::Output

fn _hypot(self, rhs: bf16x8) -> <bool as FloatOutBinary<bf16x8>>::Output

impl FloatOutBinary<bf16x8> for f32

type Output = <f32x4 as FloatOutBinaryPromote<bf16x8>>::Output

fn _div(self, rhs: bf16x8) -> <f32 as FloatOutBinary<bf16x8>>::Output

fn _log(self, base: bf16x8) -> <f32 as FloatOutBinary<bf16x8>>::Output

fn _hypot(self, rhs: bf16x8) -> <f32 as FloatOutBinary<bf16x8>>::Output

impl FloatOutBinary<bf16x8> for f64

type Output = <f64x2 as FloatOutBinaryPromote<bf16x8>>::Output

fn _div(self, rhs: bf16x8) -> <f64 as FloatOutBinary<bf16x8>>::Output

fn _log(self, base: bf16x8) -> <f64 as FloatOutBinary<bf16x8>>::Output

fn _hypot(self, rhs: bf16x8) -> <f64 as FloatOutBinary<bf16x8>>::Output

impl FloatOutBinary<bf16x8> for i8

type Output = <i8x16 as FloatOutBinaryPromote<bf16x8>>::Output

fn _div(self, rhs: bf16x8) -> <i8 as FloatOutBinary<bf16x8>>::Output

fn _log(self, base: bf16x8) -> <i8 as FloatOutBinary<bf16x8>>::Output

fn _hypot(self, rhs: bf16x8) -> <i8 as FloatOutBinary<bf16x8>>::Output

impl FloatOutBinary<bf16x8> for i16

type Output = <i16x8 as FloatOutBinaryPromote<bf16x8>>::Output

fn _div(self, rhs: bf16x8) -> <i16 as FloatOutBinary<bf16x8>>::Output

fn _log(self, base: bf16x8) -> <i16 as FloatOutBinary<bf16x8>>::Output

fn _hypot(self, rhs: bf16x8) -> <i16 as FloatOutBinary<bf16x8>>::Output

impl FloatOutBinary<bf16x8> for i32

type Output = <i32x4 as FloatOutBinaryPromote<bf16x8>>::Output

fn _div(self, rhs: bf16x8) -> <i32 as FloatOutBinary<bf16x8>>::Output

fn _log(self, base: bf16x8) -> <i32 as FloatOutBinary<bf16x8>>::Output

fn _hypot(self, rhs: bf16x8) -> <i32 as FloatOutBinary<bf16x8>>::Output

impl FloatOutBinary<bf16x8> for i64

type Output = <i64x2 as FloatOutBinaryPromote<bf16x8>>::Output

fn _div(self, rhs: bf16x8) -> <i64 as FloatOutBinary<bf16x8>>::Output

fn _log(self, base: bf16x8) -> <i64 as FloatOutBinary<bf16x8>>::Output

fn _hypot(self, rhs: bf16x8) -> <i64 as FloatOutBinary<bf16x8>>::Output

impl FloatOutBinary<bf16x8> for isize

type Output = <isizex2 as FloatOutBinaryPromote<bf16x8>>::Output

fn _div(self, rhs: bf16x8) -> <isize as FloatOutBinary<bf16x8>>::Output

fn _log(self, base: bf16x8) -> <isize as FloatOutBinary<bf16x8>>::Output

fn _hypot(self, rhs: bf16x8) -> <isize as FloatOutBinary<bf16x8>>::Output

impl FloatOutBinary<bf16x8> for u8

type Output = <u8x16 as FloatOutBinaryPromote<bf16x8>>::Output

fn _div(self, rhs: bf16x8) -> <u8 as FloatOutBinary<bf16x8>>::Output

fn _log(self, base: bf16x8) -> <u8 as FloatOutBinary<bf16x8>>::Output

fn _hypot(self, rhs: bf16x8) -> <u8 as FloatOutBinary<bf16x8>>::Output

impl FloatOutBinary<bf16x8> for u16

type Output = <u16x8 as FloatOutBinaryPromote<bf16x8>>::Output

fn _div(self, rhs: bf16x8) -> <u16 as FloatOutBinary<bf16x8>>::Output

fn _log(self, base: bf16x8) -> <u16 as FloatOutBinary<bf16x8>>::Output

fn _hypot(self, rhs: bf16x8) -> <u16 as FloatOutBinary<bf16x8>>::Output

impl FloatOutBinary<bf16x8> for u32

type Output = <u32x4 as FloatOutBinaryPromote<bf16x8>>::Output

fn _div(self, rhs: bf16x8) -> <u32 as FloatOutBinary<bf16x8>>::Output

fn _log(self, base: bf16x8) -> <u32 as FloatOutBinary<bf16x8>>::Output

fn _hypot(self, rhs: bf16x8) -> <u32 as FloatOutBinary<bf16x8>>::Output

impl FloatOutBinary<bf16x8> for u64

type Output = <u64x2 as FloatOutBinaryPromote<bf16x8>>::Output

fn _div(self, rhs: bf16x8) -> <u64 as FloatOutBinary<bf16x8>>::Output

fn _log(self, base: bf16x8) -> <u64 as FloatOutBinary<bf16x8>>::Output

fn _hypot(self, rhs: bf16x8) -> <u64 as FloatOutBinary<bf16x8>>::Output

impl FloatOutBinary<bf16x8> for usize

type Output = <usizex2 as FloatOutBinaryPromote<bf16x8>>::Output

fn _div(self, rhs: bf16x8) -> <usize as FloatOutBinary<bf16x8>>::Output

fn _log(self, base: bf16x8) -> <usize as FloatOutBinary<bf16x8>>::Output

fn _hypot(self, rhs: bf16x8) -> <usize as FloatOutBinary<bf16x8>>::Output

impl FloatOutBinary<bf16x8> for bf16

type Output = <bf16x8 as FloatOutBinaryPromote>::Output

fn _div(self, rhs: bf16x8) -> <bf16 as FloatOutBinary<bf16x8>>::Output

fn _log(self, base: bf16x8) -> <bf16 as FloatOutBinary<bf16x8>>::Output

fn _hypot(self, rhs: bf16x8) -> <bf16 as FloatOutBinary<bf16x8>>::Output

impl FloatOutBinary<bf16x8> for f16

type Output = <f16x8 as FloatOutBinaryPromote<bf16x8>>::Output

fn _div(self, rhs: bf16x8) -> <f16 as FloatOutBinary<bf16x8>>::Output

fn _log(self, base: bf16x8) -> <f16 as FloatOutBinary<bf16x8>>::Output

fn _hypot(self, rhs: bf16x8) -> <f16 as FloatOutBinary<bf16x8>>::Output

impl FloatOutBinary<bf16x8> for Complex<f32>

type Output = <cplx32x2 as FloatOutBinaryPromote<bf16x8>>::Output

fn _div(self, rhs: bf16x8) -> <Complex<f32> as FloatOutBinary<bf16x8>>::Output

fn _log(self, base: bf16x8) -> <Complex<f32> as FloatOutBinary<bf16x8>>::Output

fn _hypot(self, rhs: bf16x8) -> <Complex<f32> as FloatOutBinary<bf16x8>>::Output

impl FloatOutBinary<bf16x8> for Complex<f64>

type Output = <cplx64x1 as FloatOutBinaryPromote<bf16x8>>::Output

fn _div(self, rhs: bf16x8) -> <Complex<f64> as FloatOutBinary<bf16x8>>::Output

fn _log(self, base: bf16x8) -> <Complex<f64> as FloatOutBinary<bf16x8>>::Output

fn _hypot(self, rhs: bf16x8) -> <Complex<f64> as FloatOutBinary<bf16x8>>::Output

impl FloatOutBinary<boolx16> for bool

type Output = <boolx16 as FloatOutBinaryPromote>::Output

fn _div(self, rhs: boolx16) -> <bool as FloatOutBinary<boolx16>>::Output

fn _log(self, base: boolx16) -> <bool as FloatOutBinary<boolx16>>::Output

fn _hypot(self, rhs: boolx16) -> <bool as FloatOutBinary<boolx16>>::Output

impl FloatOutBinary<boolx16> for f32

type Output = <f32x4 as FloatOutBinaryPromote<boolx16>>::Output

fn _div(self, rhs: boolx16) -> <f32 as FloatOutBinary<boolx16>>::Output

fn _log(self, base: boolx16) -> <f32 as FloatOutBinary<boolx16>>::Output

fn _hypot(self, rhs: boolx16) -> <f32 as FloatOutBinary<boolx16>>::Output

impl FloatOutBinary<boolx16> for f64

type Output = <f64x2 as FloatOutBinaryPromote<boolx16>>::Output

fn _div(self, rhs: boolx16) -> <f64 as FloatOutBinary<boolx16>>::Output

fn _log(self, base: boolx16) -> <f64 as FloatOutBinary<boolx16>>::Output

fn _hypot(self, rhs: boolx16) -> <f64 as FloatOutBinary<boolx16>>::Output

impl FloatOutBinary<boolx16> for i8

type Output = <i8x16 as FloatOutBinaryPromote<boolx16>>::Output

fn _div(self, rhs: boolx16) -> <i8 as FloatOutBinary<boolx16>>::Output

fn _log(self, base: boolx16) -> <i8 as FloatOutBinary<boolx16>>::Output

fn _hypot(self, rhs: boolx16) -> <i8 as FloatOutBinary<boolx16>>::Output

impl FloatOutBinary<boolx16> for i16

type Output = <i16x8 as FloatOutBinaryPromote<boolx16>>::Output

fn _div(self, rhs: boolx16) -> <i16 as FloatOutBinary<boolx16>>::Output

fn _log(self, base: boolx16) -> <i16 as FloatOutBinary<boolx16>>::Output

fn _hypot(self, rhs: boolx16) -> <i16 as FloatOutBinary<boolx16>>::Output

impl FloatOutBinary<boolx16> for i32

type Output = <i32x4 as FloatOutBinaryPromote<boolx16>>::Output

fn _div(self, rhs: boolx16) -> <i32 as FloatOutBinary<boolx16>>::Output

fn _log(self, base: boolx16) -> <i32 as FloatOutBinary<boolx16>>::Output

fn _hypot(self, rhs: boolx16) -> <i32 as FloatOutBinary<boolx16>>::Output

impl FloatOutBinary<boolx16> for i64

type Output = <i64x2 as FloatOutBinaryPromote<boolx16>>::Output

fn _div(self, rhs: boolx16) -> <i64 as FloatOutBinary<boolx16>>::Output

fn _log(self, base: boolx16) -> <i64 as FloatOutBinary<boolx16>>::Output

fn _hypot(self, rhs: boolx16) -> <i64 as FloatOutBinary<boolx16>>::Output

impl FloatOutBinary<boolx16> for isize

type Output = <isizex2 as FloatOutBinaryPromote<boolx16>>::Output

fn _div(self, rhs: boolx16) -> <isize as FloatOutBinary<boolx16>>::Output

fn _log(self, base: boolx16) -> <isize as FloatOutBinary<boolx16>>::Output

fn _hypot(self, rhs: boolx16) -> <isize as FloatOutBinary<boolx16>>::Output

impl FloatOutBinary<boolx16> for u8

type Output = <u8x16 as FloatOutBinaryPromote<boolx16>>::Output

fn _div(self, rhs: boolx16) -> <u8 as FloatOutBinary<boolx16>>::Output

fn _log(self, base: boolx16) -> <u8 as FloatOutBinary<boolx16>>::Output

fn _hypot(self, rhs: boolx16) -> <u8 as FloatOutBinary<boolx16>>::Output

impl FloatOutBinary<boolx16> for u16

type Output = <u16x8 as FloatOutBinaryPromote<boolx16>>::Output

fn _div(self, rhs: boolx16) -> <u16 as FloatOutBinary<boolx16>>::Output

fn _log(self, base: boolx16) -> <u16 as FloatOutBinary<boolx16>>::Output

fn _hypot(self, rhs: boolx16) -> <u16 as FloatOutBinary<boolx16>>::Output

impl FloatOutBinary<boolx16> for u32

type Output = <u32x4 as FloatOutBinaryPromote<boolx16>>::Output

fn _div(self, rhs: boolx16) -> <u32 as FloatOutBinary<boolx16>>::Output

fn _log(self, base: boolx16) -> <u32 as FloatOutBinary<boolx16>>::Output

fn _hypot(self, rhs: boolx16) -> <u32 as FloatOutBinary<boolx16>>::Output

impl FloatOutBinary<boolx16> for u64

type Output = <u64x2 as FloatOutBinaryPromote<boolx16>>::Output

fn _div(self, rhs: boolx16) -> <u64 as FloatOutBinary<boolx16>>::Output

fn _log(self, base: boolx16) -> <u64 as FloatOutBinary<boolx16>>::Output

fn _hypot(self, rhs: boolx16) -> <u64 as FloatOutBinary<boolx16>>::Output

impl FloatOutBinary<boolx16> for usize

type Output = <usizex2 as FloatOutBinaryPromote<boolx16>>::Output

fn _div(self, rhs: boolx16) -> <usize as FloatOutBinary<boolx16>>::Output

fn _log(self, base: boolx16) -> <usize as FloatOutBinary<boolx16>>::Output

fn _hypot(self, rhs: boolx16) -> <usize as FloatOutBinary<boolx16>>::Output

impl FloatOutBinary<boolx16> for bf16

type Output = <bf16x8 as FloatOutBinaryPromote<boolx16>>::Output

fn _div(self, rhs: boolx16) -> <bf16 as FloatOutBinary<boolx16>>::Output

fn _log(self, base: boolx16) -> <bf16 as FloatOutBinary<boolx16>>::Output

fn _hypot(self, rhs: boolx16) -> <bf16 as FloatOutBinary<boolx16>>::Output

impl FloatOutBinary<boolx16> for f16

type Output = <f16x8 as FloatOutBinaryPromote<boolx16>>::Output

fn _div(self, rhs: boolx16) -> <f16 as FloatOutBinary<boolx16>>::Output

fn _log(self, base: boolx16) -> <f16 as FloatOutBinary<boolx16>>::Output

fn _hypot(self, rhs: boolx16) -> <f16 as FloatOutBinary<boolx16>>::Output

impl FloatOutBinary<boolx16> for Complex<f32>

type Output = <cplx32x2 as FloatOutBinaryPromote<boolx16>>::Output

fn _div(self, rhs: boolx16) -> <Complex<f32> as FloatOutBinary<boolx16>>::Output

fn _log( self, base: boolx16, ) -> <Complex<f32> as FloatOutBinary<boolx16>>::Output

fn _hypot( self, rhs: boolx16, ) -> <Complex<f32> as FloatOutBinary<boolx16>>::Output

impl FloatOutBinary<boolx16> for Complex<f64>

type Output = <cplx64x1 as FloatOutBinaryPromote<boolx16>>::Output

fn _div(self, rhs: boolx16) -> <Complex<f64> as FloatOutBinary<boolx16>>::Output

fn _log( self, base: boolx16, ) -> <Complex<f64> as FloatOutBinary<boolx16>>::Output

fn _hypot( self, rhs: boolx16, ) -> <Complex<f64> as FloatOutBinary<boolx16>>::Output

impl FloatOutBinary<cplx32x2> for bool

type Output = <boolx16 as FloatOutBinaryPromote<cplx32x2>>::Output

fn _div(self, rhs: cplx32x2) -> <bool as FloatOutBinary<cplx32x2>>::Output

fn _log(self, base: cplx32x2) -> <bool as FloatOutBinary<cplx32x2>>::Output

fn _hypot(self, rhs: cplx32x2) -> <bool as FloatOutBinary<cplx32x2>>::Output

impl FloatOutBinary<cplx32x2> for f32

type Output = <f32x4 as FloatOutBinaryPromote<cplx32x2>>::Output

fn _div(self, rhs: cplx32x2) -> <f32 as FloatOutBinary<cplx32x2>>::Output

fn _log(self, base: cplx32x2) -> <f32 as FloatOutBinary<cplx32x2>>::Output

fn _hypot(self, rhs: cplx32x2) -> <f32 as FloatOutBinary<cplx32x2>>::Output

impl FloatOutBinary<cplx32x2> for f64

type Output = <f64x2 as FloatOutBinaryPromote<cplx32x2>>::Output

fn _div(self, rhs: cplx32x2) -> <f64 as FloatOutBinary<cplx32x2>>::Output

fn _log(self, base: cplx32x2) -> <f64 as FloatOutBinary<cplx32x2>>::Output

fn _hypot(self, rhs: cplx32x2) -> <f64 as FloatOutBinary<cplx32x2>>::Output

impl FloatOutBinary<cplx32x2> for i8

type Output = <i8x16 as FloatOutBinaryPromote<cplx32x2>>::Output

fn _div(self, rhs: cplx32x2) -> <i8 as FloatOutBinary<cplx32x2>>::Output

fn _log(self, base: cplx32x2) -> <i8 as FloatOutBinary<cplx32x2>>::Output

fn _hypot(self, rhs: cplx32x2) -> <i8 as FloatOutBinary<cplx32x2>>::Output

impl FloatOutBinary<cplx32x2> for i16

type Output = <i16x8 as FloatOutBinaryPromote<cplx32x2>>::Output

fn _div(self, rhs: cplx32x2) -> <i16 as FloatOutBinary<cplx32x2>>::Output

fn _log(self, base: cplx32x2) -> <i16 as FloatOutBinary<cplx32x2>>::Output

fn _hypot(self, rhs: cplx32x2) -> <i16 as FloatOutBinary<cplx32x2>>::Output

impl FloatOutBinary<cplx32x2> for i32

type Output = <i32x4 as FloatOutBinaryPromote<cplx32x2>>::Output

fn _div(self, rhs: cplx32x2) -> <i32 as FloatOutBinary<cplx32x2>>::Output

fn _log(self, base: cplx32x2) -> <i32 as FloatOutBinary<cplx32x2>>::Output

fn _hypot(self, rhs: cplx32x2) -> <i32 as FloatOutBinary<cplx32x2>>::Output

impl FloatOutBinary<cplx32x2> for i64

type Output = <i64x2 as FloatOutBinaryPromote<cplx32x2>>::Output

fn _div(self, rhs: cplx32x2) -> <i64 as FloatOutBinary<cplx32x2>>::Output

fn _log(self, base: cplx32x2) -> <i64 as FloatOutBinary<cplx32x2>>::Output

fn _hypot(self, rhs: cplx32x2) -> <i64 as FloatOutBinary<cplx32x2>>::Output

impl FloatOutBinary<cplx32x2> for isize

type Output = <isizex2 as FloatOutBinaryPromote<cplx32x2>>::Output

fn _div(self, rhs: cplx32x2) -> <isize as FloatOutBinary<cplx32x2>>::Output

fn _log(self, base: cplx32x2) -> <isize as FloatOutBinary<cplx32x2>>::Output

fn _hypot(self, rhs: cplx32x2) -> <isize as FloatOutBinary<cplx32x2>>::Output

impl FloatOutBinary<cplx32x2> for u8

type Output = <u8x16 as FloatOutBinaryPromote<cplx32x2>>::Output

fn _div(self, rhs: cplx32x2) -> <u8 as FloatOutBinary<cplx32x2>>::Output

fn _log(self, base: cplx32x2) -> <u8 as FloatOutBinary<cplx32x2>>::Output

fn _hypot(self, rhs: cplx32x2) -> <u8 as FloatOutBinary<cplx32x2>>::Output

impl FloatOutBinary<cplx32x2> for u16

type Output = <u16x8 as FloatOutBinaryPromote<cplx32x2>>::Output

fn _div(self, rhs: cplx32x2) -> <u16 as FloatOutBinary<cplx32x2>>::Output

fn _log(self, base: cplx32x2) -> <u16 as FloatOutBinary<cplx32x2>>::Output

fn _hypot(self, rhs: cplx32x2) -> <u16 as FloatOutBinary<cplx32x2>>::Output

impl FloatOutBinary<cplx32x2> for u32

type Output = <u32x4 as FloatOutBinaryPromote<cplx32x2>>::Output

fn _div(self, rhs: cplx32x2) -> <u32 as FloatOutBinary<cplx32x2>>::Output

fn _log(self, base: cplx32x2) -> <u32 as FloatOutBinary<cplx32x2>>::Output

fn _hypot(self, rhs: cplx32x2) -> <u32 as FloatOutBinary<cplx32x2>>::Output

impl FloatOutBinary<cplx32x2> for u64

type Output = <u64x2 as FloatOutBinaryPromote<cplx32x2>>::Output

fn _div(self, rhs: cplx32x2) -> <u64 as FloatOutBinary<cplx32x2>>::Output

fn _log(self, base: cplx32x2) -> <u64 as FloatOutBinary<cplx32x2>>::Output

fn _hypot(self, rhs: cplx32x2) -> <u64 as FloatOutBinary<cplx32x2>>::Output

impl FloatOutBinary<cplx32x2> for usize

type Output = <usizex2 as FloatOutBinaryPromote<cplx32x2>>::Output

fn _div(self, rhs: cplx32x2) -> <usize as FloatOutBinary<cplx32x2>>::Output

fn _log(self, base: cplx32x2) -> <usize as FloatOutBinary<cplx32x2>>::Output

fn _hypot(self, rhs: cplx32x2) -> <usize as FloatOutBinary<cplx32x2>>::Output

impl FloatOutBinary<cplx32x2> for bf16

type Output = <bf16x8 as FloatOutBinaryPromote<cplx32x2>>::Output

fn _div(self, rhs: cplx32x2) -> <bf16 as FloatOutBinary<cplx32x2>>::Output

fn _log(self, base: cplx32x2) -> <bf16 as FloatOutBinary<cplx32x2>>::Output

fn _hypot(self, rhs: cplx32x2) -> <bf16 as FloatOutBinary<cplx32x2>>::Output

impl FloatOutBinary<cplx32x2> for f16

type Output = <f16x8 as FloatOutBinaryPromote<cplx32x2>>::Output

fn _div(self, rhs: cplx32x2) -> <f16 as FloatOutBinary<cplx32x2>>::Output

fn _log(self, base: cplx32x2) -> <f16 as FloatOutBinary<cplx32x2>>::Output

fn _hypot(self, rhs: cplx32x2) -> <f16 as FloatOutBinary<cplx32x2>>::Output

impl FloatOutBinary<cplx32x2> for Complex<f32>

type Output = <cplx32x2 as FloatOutBinaryPromote>::Output

fn _div( self, rhs: cplx32x2, ) -> <Complex<f32> as FloatOutBinary<cplx32x2>>::Output

fn _log( self, base: cplx32x2, ) -> <Complex<f32> as FloatOutBinary<cplx32x2>>::Output

fn _hypot( self, rhs: cplx32x2, ) -> <Complex<f32> as FloatOutBinary<cplx32x2>>::Output

impl FloatOutBinary<cplx32x2> for Complex<f64>

type Output = <cplx64x1 as FloatOutBinaryPromote<cplx32x2>>::Output

fn _div( self, rhs: cplx32x2, ) -> <Complex<f64> as FloatOutBinary<cplx32x2>>::Output

fn _log( self, base: cplx32x2, ) -> <Complex<f64> as FloatOutBinary<cplx32x2>>::Output

fn _hypot( self, rhs: cplx32x2, ) -> <Complex<f64> as FloatOutBinary<cplx32x2>>::Output

impl FloatOutBinary<cplx64x1> for bool

type Output = <boolx16 as FloatOutBinaryPromote<cplx64x1>>::Output

fn _div(self, rhs: cplx64x1) -> <bool as FloatOutBinary<cplx64x1>>::Output

fn _log(self, base: cplx64x1) -> <bool as FloatOutBinary<cplx64x1>>::Output

fn _hypot(self, rhs: cplx64x1) -> <bool as FloatOutBinary<cplx64x1>>::Output

impl FloatOutBinary<cplx64x1> for f32

type Output = <f32x4 as FloatOutBinaryPromote<cplx64x1>>::Output

fn _div(self, rhs: cplx64x1) -> <f32 as FloatOutBinary<cplx64x1>>::Output

fn _log(self, base: cplx64x1) -> <f32 as FloatOutBinary<cplx64x1>>::Output

fn _hypot(self, rhs: cplx64x1) -> <f32 as FloatOutBinary<cplx64x1>>::Output

impl FloatOutBinary<cplx64x1> for f64

type Output = <f64x2 as FloatOutBinaryPromote<cplx64x1>>::Output

fn _div(self, rhs: cplx64x1) -> <f64 as FloatOutBinary<cplx64x1>>::Output

fn _log(self, base: cplx64x1) -> <f64 as FloatOutBinary<cplx64x1>>::Output

fn _hypot(self, rhs: cplx64x1) -> <f64 as FloatOutBinary<cplx64x1>>::Output

impl FloatOutBinary<cplx64x1> for i8

type Output = <i8x16 as FloatOutBinaryPromote<cplx64x1>>::Output

fn _div(self, rhs: cplx64x1) -> <i8 as FloatOutBinary<cplx64x1>>::Output

fn _log(self, base: cplx64x1) -> <i8 as FloatOutBinary<cplx64x1>>::Output

fn _hypot(self, rhs: cplx64x1) -> <i8 as FloatOutBinary<cplx64x1>>::Output

impl FloatOutBinary<cplx64x1> for i16

type Output = <i16x8 as FloatOutBinaryPromote<cplx64x1>>::Output

fn _div(self, rhs: cplx64x1) -> <i16 as FloatOutBinary<cplx64x1>>::Output

fn _log(self, base: cplx64x1) -> <i16 as FloatOutBinary<cplx64x1>>::Output

fn _hypot(self, rhs: cplx64x1) -> <i16 as FloatOutBinary<cplx64x1>>::Output

impl FloatOutBinary<cplx64x1> for i32

type Output = <i32x4 as FloatOutBinaryPromote<cplx64x1>>::Output

fn _div(self, rhs: cplx64x1) -> <i32 as FloatOutBinary<cplx64x1>>::Output

fn _log(self, base: cplx64x1) -> <i32 as FloatOutBinary<cplx64x1>>::Output

fn _hypot(self, rhs: cplx64x1) -> <i32 as FloatOutBinary<cplx64x1>>::Output

impl FloatOutBinary<cplx64x1> for i64

type Output = <i64x2 as FloatOutBinaryPromote<cplx64x1>>::Output

fn _div(self, rhs: cplx64x1) -> <i64 as FloatOutBinary<cplx64x1>>::Output

fn _log(self, base: cplx64x1) -> <i64 as FloatOutBinary<cplx64x1>>::Output

fn _hypot(self, rhs: cplx64x1) -> <i64 as FloatOutBinary<cplx64x1>>::Output

impl FloatOutBinary<cplx64x1> for isize

type Output = <isizex2 as FloatOutBinaryPromote<cplx64x1>>::Output

fn _div(self, rhs: cplx64x1) -> <isize as FloatOutBinary<cplx64x1>>::Output

fn _log(self, base: cplx64x1) -> <isize as FloatOutBinary<cplx64x1>>::Output

fn _hypot(self, rhs: cplx64x1) -> <isize as FloatOutBinary<cplx64x1>>::Output

impl FloatOutBinary<cplx64x1> for u8

type Output = <u8x16 as FloatOutBinaryPromote<cplx64x1>>::Output

fn _div(self, rhs: cplx64x1) -> <u8 as FloatOutBinary<cplx64x1>>::Output

fn _log(self, base: cplx64x1) -> <u8 as FloatOutBinary<cplx64x1>>::Output

fn _hypot(self, rhs: cplx64x1) -> <u8 as FloatOutBinary<cplx64x1>>::Output

impl FloatOutBinary<cplx64x1> for u16

type Output = <u16x8 as FloatOutBinaryPromote<cplx64x1>>::Output

fn _div(self, rhs: cplx64x1) -> <u16 as FloatOutBinary<cplx64x1>>::Output

fn _log(self, base: cplx64x1) -> <u16 as FloatOutBinary<cplx64x1>>::Output

fn _hypot(self, rhs: cplx64x1) -> <u16 as FloatOutBinary<cplx64x1>>::Output

impl FloatOutBinary<cplx64x1> for u32

type Output = <u32x4 as FloatOutBinaryPromote<cplx64x1>>::Output

fn _div(self, rhs: cplx64x1) -> <u32 as FloatOutBinary<cplx64x1>>::Output

fn _log(self, base: cplx64x1) -> <u32 as FloatOutBinary<cplx64x1>>::Output

fn _hypot(self, rhs: cplx64x1) -> <u32 as FloatOutBinary<cplx64x1>>::Output

impl FloatOutBinary<cplx64x1> for u64

type Output = <u64x2 as FloatOutBinaryPromote<cplx64x1>>::Output

fn _div(self, rhs: cplx64x1) -> <u64 as FloatOutBinary<cplx64x1>>::Output

fn _log(self, base: cplx64x1) -> <u64 as FloatOutBinary<cplx64x1>>::Output

fn _hypot(self, rhs: cplx64x1) -> <u64 as FloatOutBinary<cplx64x1>>::Output

impl FloatOutBinary<cplx64x1> for usize

type Output = <usizex2 as FloatOutBinaryPromote<cplx64x1>>::Output

fn _div(self, rhs: cplx64x1) -> <usize as FloatOutBinary<cplx64x1>>::Output

fn _log(self, base: cplx64x1) -> <usize as FloatOutBinary<cplx64x1>>::Output

fn _hypot(self, rhs: cplx64x1) -> <usize as FloatOutBinary<cplx64x1>>::Output

impl FloatOutBinary<cplx64x1> for bf16

type Output = <bf16x8 as FloatOutBinaryPromote<cplx64x1>>::Output

fn _div(self, rhs: cplx64x1) -> <bf16 as FloatOutBinary<cplx64x1>>::Output

fn _log(self, base: cplx64x1) -> <bf16 as FloatOutBinary<cplx64x1>>::Output

fn _hypot(self, rhs: cplx64x1) -> <bf16 as FloatOutBinary<cplx64x1>>::Output

impl FloatOutBinary<cplx64x1> for f16

type Output = <f16x8 as FloatOutBinaryPromote<cplx64x1>>::Output

fn _div(self, rhs: cplx64x1) -> <f16 as FloatOutBinary<cplx64x1>>::Output

fn _log(self, base: cplx64x1) -> <f16 as FloatOutBinary<cplx64x1>>::Output

fn _hypot(self, rhs: cplx64x1) -> <f16 as FloatOutBinary<cplx64x1>>::Output

impl FloatOutBinary<cplx64x1> for Complex<f32>

type Output = <cplx32x2 as FloatOutBinaryPromote<cplx64x1>>::Output

fn _div( self, rhs: cplx64x1, ) -> <Complex<f32> as FloatOutBinary<cplx64x1>>::Output

fn _log( self, base: cplx64x1, ) -> <Complex<f32> as FloatOutBinary<cplx64x1>>::Output

fn _hypot( self, rhs: cplx64x1, ) -> <Complex<f32> as FloatOutBinary<cplx64x1>>::Output

impl FloatOutBinary<cplx64x1> for Complex<f64>

type Output = <cplx64x1 as FloatOutBinaryPromote>::Output

fn _div( self, rhs: cplx64x1, ) -> <Complex<f64> as FloatOutBinary<cplx64x1>>::Output

fn _log( self, base: cplx64x1, ) -> <Complex<f64> as FloatOutBinary<cplx64x1>>::Output

fn _hypot( self, rhs: cplx64x1, ) -> <Complex<f64> as FloatOutBinary<cplx64x1>>::Output

impl FloatOutBinary<f16x8> for bool

type Output = <boolx16 as FloatOutBinaryPromote<f16x8>>::Output

fn _div(self, rhs: f16x8) -> <bool as FloatOutBinary<f16x8>>::Output

fn _log(self, base: f16x8) -> <bool as FloatOutBinary<f16x8>>::Output

fn _hypot(self, rhs: f16x8) -> <bool as FloatOutBinary<f16x8>>::Output

impl FloatOutBinary<f16x8> for f32

type Output = <f32x4 as FloatOutBinaryPromote<f16x8>>::Output

fn _div(self, rhs: f16x8) -> <f32 as FloatOutBinary<f16x8>>::Output

fn _log(self, base: f16x8) -> <f32 as FloatOutBinary<f16x8>>::Output

fn _hypot(self, rhs: f16x8) -> <f32 as FloatOutBinary<f16x8>>::Output

impl FloatOutBinary<f16x8> for f64

type Output = <f64x2 as FloatOutBinaryPromote<f16x8>>::Output

fn _div(self, rhs: f16x8) -> <f64 as FloatOutBinary<f16x8>>::Output

fn _log(self, base: f16x8) -> <f64 as FloatOutBinary<f16x8>>::Output

fn _hypot(self, rhs: f16x8) -> <f64 as FloatOutBinary<f16x8>>::Output

impl FloatOutBinary<f16x8> for i8

type Output = <i8x16 as FloatOutBinaryPromote<f16x8>>::Output

fn _div(self, rhs: f16x8) -> <i8 as FloatOutBinary<f16x8>>::Output

fn _log(self, base: f16x8) -> <i8 as FloatOutBinary<f16x8>>::Output

fn _hypot(self, rhs: f16x8) -> <i8 as FloatOutBinary<f16x8>>::Output

impl FloatOutBinary<f16x8> for i16

type Output = <i16x8 as FloatOutBinaryPromote<f16x8>>::Output

fn _div(self, rhs: f16x8) -> <i16 as FloatOutBinary<f16x8>>::Output

fn _log(self, base: f16x8) -> <i16 as FloatOutBinary<f16x8>>::Output

fn _hypot(self, rhs: f16x8) -> <i16 as FloatOutBinary<f16x8>>::Output

impl FloatOutBinary<f16x8> for i32

type Output = <i32x4 as FloatOutBinaryPromote<f16x8>>::Output

fn _div(self, rhs: f16x8) -> <i32 as FloatOutBinary<f16x8>>::Output

fn _log(self, base: f16x8) -> <i32 as FloatOutBinary<f16x8>>::Output

fn _hypot(self, rhs: f16x8) -> <i32 as FloatOutBinary<f16x8>>::Output

impl FloatOutBinary<f16x8> for i64

type Output = <i64x2 as FloatOutBinaryPromote<f16x8>>::Output

fn _div(self, rhs: f16x8) -> <i64 as FloatOutBinary<f16x8>>::Output

fn _log(self, base: f16x8) -> <i64 as FloatOutBinary<f16x8>>::Output

fn _hypot(self, rhs: f16x8) -> <i64 as FloatOutBinary<f16x8>>::Output

impl FloatOutBinary<f16x8> for isize

type Output = <isizex2 as FloatOutBinaryPromote<f16x8>>::Output

fn _div(self, rhs: f16x8) -> <isize as FloatOutBinary<f16x8>>::Output

fn _log(self, base: f16x8) -> <isize as FloatOutBinary<f16x8>>::Output

fn _hypot(self, rhs: f16x8) -> <isize as FloatOutBinary<f16x8>>::Output

impl FloatOutBinary<f16x8> for u8

type Output = <u8x16 as FloatOutBinaryPromote<f16x8>>::Output

fn _div(self, rhs: f16x8) -> <u8 as FloatOutBinary<f16x8>>::Output

fn _log(self, base: f16x8) -> <u8 as FloatOutBinary<f16x8>>::Output

fn _hypot(self, rhs: f16x8) -> <u8 as FloatOutBinary<f16x8>>::Output

impl FloatOutBinary<f16x8> for u16

type Output = <u16x8 as FloatOutBinaryPromote<f16x8>>::Output

fn _div(self, rhs: f16x8) -> <u16 as FloatOutBinary<f16x8>>::Output

fn _log(self, base: f16x8) -> <u16 as FloatOutBinary<f16x8>>::Output

fn _hypot(self, rhs: f16x8) -> <u16 as FloatOutBinary<f16x8>>::Output

impl FloatOutBinary<f16x8> for u32

type Output = <u32x4 as FloatOutBinaryPromote<f16x8>>::Output

fn _div(self, rhs: f16x8) -> <u32 as FloatOutBinary<f16x8>>::Output

fn _log(self, base: f16x8) -> <u32 as FloatOutBinary<f16x8>>::Output

fn _hypot(self, rhs: f16x8) -> <u32 as FloatOutBinary<f16x8>>::Output

impl FloatOutBinary<f16x8> for u64

type Output = <u64x2 as FloatOutBinaryPromote<f16x8>>::Output

fn _div(self, rhs: f16x8) -> <u64 as FloatOutBinary<f16x8>>::Output

fn _log(self, base: f16x8) -> <u64 as FloatOutBinary<f16x8>>::Output

fn _hypot(self, rhs: f16x8) -> <u64 as FloatOutBinary<f16x8>>::Output

impl FloatOutBinary<f16x8> for usize

type Output = <usizex2 as FloatOutBinaryPromote<f16x8>>::Output

fn _div(self, rhs: f16x8) -> <usize as FloatOutBinary<f16x8>>::Output

fn _log(self, base: f16x8) -> <usize as FloatOutBinary<f16x8>>::Output

fn _hypot(self, rhs: f16x8) -> <usize as FloatOutBinary<f16x8>>::Output

impl FloatOutBinary<f16x8> for bf16

type Output = <bf16x8 as FloatOutBinaryPromote<f16x8>>::Output

fn _div(self, rhs: f16x8) -> <bf16 as FloatOutBinary<f16x8>>::Output

fn _log(self, base: f16x8) -> <bf16 as FloatOutBinary<f16x8>>::Output

fn _hypot(self, rhs: f16x8) -> <bf16 as FloatOutBinary<f16x8>>::Output

impl FloatOutBinary<f16x8> for f16

type Output = <f16x8 as FloatOutBinaryPromote>::Output

fn _div(self, rhs: f16x8) -> <f16 as FloatOutBinary<f16x8>>::Output

fn _log(self, base: f16x8) -> <f16 as FloatOutBinary<f16x8>>::Output

fn _hypot(self, rhs: f16x8) -> <f16 as FloatOutBinary<f16x8>>::Output

impl FloatOutBinary<f16x8> for Complex<f32>

type Output = <cplx32x2 as FloatOutBinaryPromote<f16x8>>::Output

fn _div(self, rhs: f16x8) -> <Complex<f32> as FloatOutBinary<f16x8>>::Output

fn _log(self, base: f16x8) -> <Complex<f32> as FloatOutBinary<f16x8>>::Output

fn _hypot(self, rhs: f16x8) -> <Complex<f32> as FloatOutBinary<f16x8>>::Output

impl FloatOutBinary<f16x8> for Complex<f64>

type Output = <cplx64x1 as FloatOutBinaryPromote<f16x8>>::Output

fn _div(self, rhs: f16x8) -> <Complex<f64> as FloatOutBinary<f16x8>>::Output

fn _log(self, base: f16x8) -> <Complex<f64> as FloatOutBinary<f16x8>>::Output

fn _hypot(self, rhs: f16x8) -> <Complex<f64> as FloatOutBinary<f16x8>>::Output

impl FloatOutBinary<f32x4> for bool

type Output = <boolx16 as FloatOutBinaryPromote<f32x4>>::Output

fn _div(self, rhs: f32x4) -> <bool as FloatOutBinary<f32x4>>::Output

fn _log(self, base: f32x4) -> <bool as FloatOutBinary<f32x4>>::Output

fn _hypot(self, rhs: f32x4) -> <bool as FloatOutBinary<f32x4>>::Output

impl FloatOutBinary<f32x4> for f32

type Output = <f32x4 as FloatOutBinaryPromote>::Output

fn _div(self, rhs: f32x4) -> <f32 as FloatOutBinary<f32x4>>::Output

fn _log(self, base: f32x4) -> <f32 as FloatOutBinary<f32x4>>::Output

fn _hypot(self, rhs: f32x4) -> <f32 as FloatOutBinary<f32x4>>::Output

impl FloatOutBinary<f32x4> for f64

type Output = <f64x2 as FloatOutBinaryPromote<f32x4>>::Output

fn _div(self, rhs: f32x4) -> <f64 as FloatOutBinary<f32x4>>::Output

fn _log(self, base: f32x4) -> <f64 as FloatOutBinary<f32x4>>::Output

fn _hypot(self, rhs: f32x4) -> <f64 as FloatOutBinary<f32x4>>::Output

impl FloatOutBinary<f32x4> for i8

type Output = <i8x16 as FloatOutBinaryPromote<f32x4>>::Output

fn _div(self, rhs: f32x4) -> <i8 as FloatOutBinary<f32x4>>::Output

fn _log(self, base: f32x4) -> <i8 as FloatOutBinary<f32x4>>::Output

fn _hypot(self, rhs: f32x4) -> <i8 as FloatOutBinary<f32x4>>::Output

impl FloatOutBinary<f32x4> for i16

type Output = <i16x8 as FloatOutBinaryPromote<f32x4>>::Output

fn _div(self, rhs: f32x4) -> <i16 as FloatOutBinary<f32x4>>::Output

fn _log(self, base: f32x4) -> <i16 as FloatOutBinary<f32x4>>::Output

fn _hypot(self, rhs: f32x4) -> <i16 as FloatOutBinary<f32x4>>::Output

impl FloatOutBinary<f32x4> for i32

type Output = <i32x4 as FloatOutBinaryPromote<f32x4>>::Output

fn _div(self, rhs: f32x4) -> <i32 as FloatOutBinary<f32x4>>::Output

fn _log(self, base: f32x4) -> <i32 as FloatOutBinary<f32x4>>::Output

fn _hypot(self, rhs: f32x4) -> <i32 as FloatOutBinary<f32x4>>::Output

impl FloatOutBinary<f32x4> for i64

type Output = <i64x2 as FloatOutBinaryPromote<f32x4>>::Output

fn _div(self, rhs: f32x4) -> <i64 as FloatOutBinary<f32x4>>::Output

fn _log(self, base: f32x4) -> <i64 as FloatOutBinary<f32x4>>::Output

fn _hypot(self, rhs: f32x4) -> <i64 as FloatOutBinary<f32x4>>::Output

impl FloatOutBinary<f32x4> for isize

type Output = <isizex2 as FloatOutBinaryPromote<f32x4>>::Output

fn _div(self, rhs: f32x4) -> <isize as FloatOutBinary<f32x4>>::Output

fn _log(self, base: f32x4) -> <isize as FloatOutBinary<f32x4>>::Output

fn _hypot(self, rhs: f32x4) -> <isize as FloatOutBinary<f32x4>>::Output

impl FloatOutBinary<f32x4> for u8

type Output = <u8x16 as FloatOutBinaryPromote<f32x4>>::Output

fn _div(self, rhs: f32x4) -> <u8 as FloatOutBinary<f32x4>>::Output

fn _log(self, base: f32x4) -> <u8 as FloatOutBinary<f32x4>>::Output

fn _hypot(self, rhs: f32x4) -> <u8 as FloatOutBinary<f32x4>>::Output

impl FloatOutBinary<f32x4> for u16

type Output = <u16x8 as FloatOutBinaryPromote<f32x4>>::Output

fn _div(self, rhs: f32x4) -> <u16 as FloatOutBinary<f32x4>>::Output

fn _log(self, base: f32x4) -> <u16 as FloatOutBinary<f32x4>>::Output

fn _hypot(self, rhs: f32x4) -> <u16 as FloatOutBinary<f32x4>>::Output

impl FloatOutBinary<f32x4> for u32

type Output = <u32x4 as FloatOutBinaryPromote<f32x4>>::Output

fn _div(self, rhs: f32x4) -> <u32 as FloatOutBinary<f32x4>>::Output

fn _log(self, base: f32x4) -> <u32 as FloatOutBinary<f32x4>>::Output

fn _hypot(self, rhs: f32x4) -> <u32 as FloatOutBinary<f32x4>>::Output

impl FloatOutBinary<f32x4> for u64

type Output = <u64x2 as FloatOutBinaryPromote<f32x4>>::Output

fn _div(self, rhs: f32x4) -> <u64 as FloatOutBinary<f32x4>>::Output

fn _log(self, base: f32x4) -> <u64 as FloatOutBinary<f32x4>>::Output

fn _hypot(self, rhs: f32x4) -> <u64 as FloatOutBinary<f32x4>>::Output

impl FloatOutBinary<f32x4> for usize

type Output = <usizex2 as FloatOutBinaryPromote<f32x4>>::Output

fn _div(self, rhs: f32x4) -> <usize as FloatOutBinary<f32x4>>::Output

fn _log(self, base: f32x4) -> <usize as FloatOutBinary<f32x4>>::Output

fn _hypot(self, rhs: f32x4) -> <usize as FloatOutBinary<f32x4>>::Output

impl FloatOutBinary<f32x4> for bf16

type Output = <bf16x8 as FloatOutBinaryPromote<f32x4>>::Output

fn _div(self, rhs: f32x4) -> <bf16 as FloatOutBinary<f32x4>>::Output

fn _log(self, base: f32x4) -> <bf16 as FloatOutBinary<f32x4>>::Output

fn _hypot(self, rhs: f32x4) -> <bf16 as FloatOutBinary<f32x4>>::Output

impl FloatOutBinary<f32x4> for f16

type Output = <f16x8 as FloatOutBinaryPromote<f32x4>>::Output

fn _div(self, rhs: f32x4) -> <f16 as FloatOutBinary<f32x4>>::Output

fn _log(self, base: f32x4) -> <f16 as FloatOutBinary<f32x4>>::Output

fn _hypot(self, rhs: f32x4) -> <f16 as FloatOutBinary<f32x4>>::Output

impl FloatOutBinary<f32x4> for Complex<f32>

type Output = <cplx32x2 as FloatOutBinaryPromote<f32x4>>::Output

fn _div(self, rhs: f32x4) -> <Complex<f32> as FloatOutBinary<f32x4>>::Output

fn _log(self, base: f32x4) -> <Complex<f32> as FloatOutBinary<f32x4>>::Output

fn _hypot(self, rhs: f32x4) -> <Complex<f32> as FloatOutBinary<f32x4>>::Output

impl FloatOutBinary<f32x4> for Complex<f64>

type Output = <cplx64x1 as FloatOutBinaryPromote<f32x4>>::Output

fn _div(self, rhs: f32x4) -> <Complex<f64> as FloatOutBinary<f32x4>>::Output

fn _log(self, base: f32x4) -> <Complex<f64> as FloatOutBinary<f32x4>>::Output

fn _hypot(self, rhs: f32x4) -> <Complex<f64> as FloatOutBinary<f32x4>>::Output

impl FloatOutBinary<f64x2> for bool

type Output = <boolx16 as FloatOutBinaryPromote<f64x2>>::Output

fn _div(self, rhs: f64x2) -> <bool as FloatOutBinary<f64x2>>::Output

fn _log(self, base: f64x2) -> <bool as FloatOutBinary<f64x2>>::Output

fn _hypot(self, rhs: f64x2) -> <bool as FloatOutBinary<f64x2>>::Output

impl FloatOutBinary<f64x2> for f32

type Output = <f32x4 as FloatOutBinaryPromote<f64x2>>::Output

fn _div(self, rhs: f64x2) -> <f32 as FloatOutBinary<f64x2>>::Output

fn _log(self, base: f64x2) -> <f32 as FloatOutBinary<f64x2>>::Output

fn _hypot(self, rhs: f64x2) -> <f32 as FloatOutBinary<f64x2>>::Output

impl FloatOutBinary<f64x2> for f64

type Output = <f64x2 as FloatOutBinaryPromote>::Output

fn _div(self, rhs: f64x2) -> <f64 as FloatOutBinary<f64x2>>::Output

fn _log(self, base: f64x2) -> <f64 as FloatOutBinary<f64x2>>::Output

fn _hypot(self, rhs: f64x2) -> <f64 as FloatOutBinary<f64x2>>::Output

impl FloatOutBinary<f64x2> for i8

type Output = <i8x16 as FloatOutBinaryPromote<f64x2>>::Output

fn _div(self, rhs: f64x2) -> <i8 as FloatOutBinary<f64x2>>::Output

fn _log(self, base: f64x2) -> <i8 as FloatOutBinary<f64x2>>::Output

fn _hypot(self, rhs: f64x2) -> <i8 as FloatOutBinary<f64x2>>::Output

impl FloatOutBinary<f64x2> for i16

type Output = <i16x8 as FloatOutBinaryPromote<f64x2>>::Output

fn _div(self, rhs: f64x2) -> <i16 as FloatOutBinary<f64x2>>::Output

fn _log(self, base: f64x2) -> <i16 as FloatOutBinary<f64x2>>::Output

fn _hypot(self, rhs: f64x2) -> <i16 as FloatOutBinary<f64x2>>::Output

impl FloatOutBinary<f64x2> for i32

type Output = <i32x4 as FloatOutBinaryPromote<f64x2>>::Output

fn _div(self, rhs: f64x2) -> <i32 as FloatOutBinary<f64x2>>::Output

fn _log(self, base: f64x2) -> <i32 as FloatOutBinary<f64x2>>::Output

fn _hypot(self, rhs: f64x2) -> <i32 as FloatOutBinary<f64x2>>::Output

impl FloatOutBinary<f64x2> for i64

type Output = <i64x2 as FloatOutBinaryPromote<f64x2>>::Output

fn _div(self, rhs: f64x2) -> <i64 as FloatOutBinary<f64x2>>::Output

fn _log(self, base: f64x2) -> <i64 as FloatOutBinary<f64x2>>::Output

fn _hypot(self, rhs: f64x2) -> <i64 as FloatOutBinary<f64x2>>::Output

impl FloatOutBinary<f64x2> for isize

type Output = <isizex2 as FloatOutBinaryPromote<f64x2>>::Output

fn _div(self, rhs: f64x2) -> <isize as FloatOutBinary<f64x2>>::Output

fn _log(self, base: f64x2) -> <isize as FloatOutBinary<f64x2>>::Output

fn _hypot(self, rhs: f64x2) -> <isize as FloatOutBinary<f64x2>>::Output

impl FloatOutBinary<f64x2> for u8

type Output = <u8x16 as FloatOutBinaryPromote<f64x2>>::Output

fn _div(self, rhs: f64x2) -> <u8 as FloatOutBinary<f64x2>>::Output

fn _log(self, base: f64x2) -> <u8 as FloatOutBinary<f64x2>>::Output

fn _hypot(self, rhs: f64x2) -> <u8 as FloatOutBinary<f64x2>>::Output

impl FloatOutBinary<f64x2> for u16

type Output = <u16x8 as FloatOutBinaryPromote<f64x2>>::Output

fn _div(self, rhs: f64x2) -> <u16 as FloatOutBinary<f64x2>>::Output

fn _log(self, base: f64x2) -> <u16 as FloatOutBinary<f64x2>>::Output

fn _hypot(self, rhs: f64x2) -> <u16 as FloatOutBinary<f64x2>>::Output

impl FloatOutBinary<f64x2> for u32

type Output = <u32x4 as FloatOutBinaryPromote<f64x2>>::Output

fn _div(self, rhs: f64x2) -> <u32 as FloatOutBinary<f64x2>>::Output

fn _log(self, base: f64x2) -> <u32 as FloatOutBinary<f64x2>>::Output

fn _hypot(self, rhs: f64x2) -> <u32 as FloatOutBinary<f64x2>>::Output

impl FloatOutBinary<f64x2> for u64

type Output = <u64x2 as FloatOutBinaryPromote<f64x2>>::Output

fn _div(self, rhs: f64x2) -> <u64 as FloatOutBinary<f64x2>>::Output

fn _log(self, base: f64x2) -> <u64 as FloatOutBinary<f64x2>>::Output

fn _hypot(self, rhs: f64x2) -> <u64 as FloatOutBinary<f64x2>>::Output

impl FloatOutBinary<f64x2> for usize

type Output = <usizex2 as FloatOutBinaryPromote<f64x2>>::Output

fn _div(self, rhs: f64x2) -> <usize as FloatOutBinary<f64x2>>::Output

fn _log(self, base: f64x2) -> <usize as FloatOutBinary<f64x2>>::Output

fn _hypot(self, rhs: f64x2) -> <usize as FloatOutBinary<f64x2>>::Output

impl FloatOutBinary<f64x2> for bf16

type Output = <bf16x8 as FloatOutBinaryPromote<f64x2>>::Output

fn _div(self, rhs: f64x2) -> <bf16 as FloatOutBinary<f64x2>>::Output

fn _log(self, base: f64x2) -> <bf16 as FloatOutBinary<f64x2>>::Output

fn _hypot(self, rhs: f64x2) -> <bf16 as FloatOutBinary<f64x2>>::Output

impl FloatOutBinary<f64x2> for f16

type Output = <f16x8 as FloatOutBinaryPromote<f64x2>>::Output

fn _div(self, rhs: f64x2) -> <f16 as FloatOutBinary<f64x2>>::Output

fn _log(self, base: f64x2) -> <f16 as FloatOutBinary<f64x2>>::Output

fn _hypot(self, rhs: f64x2) -> <f16 as FloatOutBinary<f64x2>>::Output

impl FloatOutBinary<f64x2> for Complex<f32>

type Output = <cplx32x2 as FloatOutBinaryPromote<f64x2>>::Output

fn _div(self, rhs: f64x2) -> <Complex<f32> as FloatOutBinary<f64x2>>::Output

fn _log(self, base: f64x2) -> <Complex<f32> as FloatOutBinary<f64x2>>::Output

fn _hypot(self, rhs: f64x2) -> <Complex<f32> as FloatOutBinary<f64x2>>::Output

impl FloatOutBinary<f64x2> for Complex<f64>

type Output = <cplx64x1 as FloatOutBinaryPromote<f64x2>>::Output

fn _div(self, rhs: f64x2) -> <Complex<f64> as FloatOutBinary<f64x2>>::Output

fn _log(self, base: f64x2) -> <Complex<f64> as FloatOutBinary<f64x2>>::Output

fn _hypot(self, rhs: f64x2) -> <Complex<f64> as FloatOutBinary<f64x2>>::Output

impl FloatOutBinary<i8x16> for bool

type Output = <boolx16 as FloatOutBinaryPromote<i8x16>>::Output

fn _div(self, rhs: i8x16) -> <bool as FloatOutBinary<i8x16>>::Output

fn _log(self, base: i8x16) -> <bool as FloatOutBinary<i8x16>>::Output

fn _hypot(self, rhs: i8x16) -> <bool as FloatOutBinary<i8x16>>::Output

impl FloatOutBinary<i8x16> for f32

type Output = <f32x4 as FloatOutBinaryPromote<i8x16>>::Output

fn _div(self, rhs: i8x16) -> <f32 as FloatOutBinary<i8x16>>::Output

fn _log(self, base: i8x16) -> <f32 as FloatOutBinary<i8x16>>::Output

fn _hypot(self, rhs: i8x16) -> <f32 as FloatOutBinary<i8x16>>::Output

impl FloatOutBinary<i8x16> for f64

type Output = <f64x2 as FloatOutBinaryPromote<i8x16>>::Output

fn _div(self, rhs: i8x16) -> <f64 as FloatOutBinary<i8x16>>::Output

fn _log(self, base: i8x16) -> <f64 as FloatOutBinary<i8x16>>::Output

fn _hypot(self, rhs: i8x16) -> <f64 as FloatOutBinary<i8x16>>::Output

impl FloatOutBinary<i8x16> for i8

type Output = <i8x16 as FloatOutBinaryPromote>::Output

fn _div(self, rhs: i8x16) -> <i8 as FloatOutBinary<i8x16>>::Output

fn _log(self, base: i8x16) -> <i8 as FloatOutBinary<i8x16>>::Output

fn _hypot(self, rhs: i8x16) -> <i8 as FloatOutBinary<i8x16>>::Output

impl FloatOutBinary<i8x16> for i16

type Output = <i16x8 as FloatOutBinaryPromote<i8x16>>::Output

fn _div(self, rhs: i8x16) -> <i16 as FloatOutBinary<i8x16>>::Output

fn _log(self, base: i8x16) -> <i16 as FloatOutBinary<i8x16>>::Output

fn _hypot(self, rhs: i8x16) -> <i16 as FloatOutBinary<i8x16>>::Output

impl FloatOutBinary<i8x16> for i32

type Output = <i32x4 as FloatOutBinaryPromote<i8x16>>::Output

fn _div(self, rhs: i8x16) -> <i32 as FloatOutBinary<i8x16>>::Output

fn _log(self, base: i8x16) -> <i32 as FloatOutBinary<i8x16>>::Output

fn _hypot(self, rhs: i8x16) -> <i32 as FloatOutBinary<i8x16>>::Output

impl FloatOutBinary<i8x16> for i64

type Output = <i64x2 as FloatOutBinaryPromote<i8x16>>::Output

fn _div(self, rhs: i8x16) -> <i64 as FloatOutBinary<i8x16>>::Output

fn _log(self, base: i8x16) -> <i64 as FloatOutBinary<i8x16>>::Output

fn _hypot(self, rhs: i8x16) -> <i64 as FloatOutBinary<i8x16>>::Output

impl FloatOutBinary<i8x16> for isize

type Output = <isizex2 as FloatOutBinaryPromote<i8x16>>::Output

fn _div(self, rhs: i8x16) -> <isize as FloatOutBinary<i8x16>>::Output

fn _log(self, base: i8x16) -> <isize as FloatOutBinary<i8x16>>::Output

fn _hypot(self, rhs: i8x16) -> <isize as FloatOutBinary<i8x16>>::Output

impl FloatOutBinary<i8x16> for u8

type Output = <u8x16 as FloatOutBinaryPromote<i8x16>>::Output

fn _div(self, rhs: i8x16) -> <u8 as FloatOutBinary<i8x16>>::Output

fn _log(self, base: i8x16) -> <u8 as FloatOutBinary<i8x16>>::Output

fn _hypot(self, rhs: i8x16) -> <u8 as FloatOutBinary<i8x16>>::Output

impl FloatOutBinary<i8x16> for u16

type Output = <u16x8 as FloatOutBinaryPromote<i8x16>>::Output

fn _div(self, rhs: i8x16) -> <u16 as FloatOutBinary<i8x16>>::Output

fn _log(self, base: i8x16) -> <u16 as FloatOutBinary<i8x16>>::Output

fn _hypot(self, rhs: i8x16) -> <u16 as FloatOutBinary<i8x16>>::Output

impl FloatOutBinary<i8x16> for u32

type Output = <u32x4 as FloatOutBinaryPromote<i8x16>>::Output

fn _div(self, rhs: i8x16) -> <u32 as FloatOutBinary<i8x16>>::Output

fn _log(self, base: i8x16) -> <u32 as FloatOutBinary<i8x16>>::Output

fn _hypot(self, rhs: i8x16) -> <u32 as FloatOutBinary<i8x16>>::Output

impl FloatOutBinary<i8x16> for u64

type Output = <u64x2 as FloatOutBinaryPromote<i8x16>>::Output

fn _div(self, rhs: i8x16) -> <u64 as FloatOutBinary<i8x16>>::Output

fn _log(self, base: i8x16) -> <u64 as FloatOutBinary<i8x16>>::Output

fn _hypot(self, rhs: i8x16) -> <u64 as FloatOutBinary<i8x16>>::Output

impl FloatOutBinary<i8x16> for usize

type Output = <usizex2 as FloatOutBinaryPromote<i8x16>>::Output

fn _div(self, rhs: i8x16) -> <usize as FloatOutBinary<i8x16>>::Output

fn _log(self, base: i8x16) -> <usize as FloatOutBinary<i8x16>>::Output

fn _hypot(self, rhs: i8x16) -> <usize as FloatOutBinary<i8x16>>::Output

impl FloatOutBinary<i8x16> for bf16

type Output = <bf16x8 as FloatOutBinaryPromote<i8x16>>::Output

fn _div(self, rhs: i8x16) -> <bf16 as FloatOutBinary<i8x16>>::Output

fn _log(self, base: i8x16) -> <bf16 as FloatOutBinary<i8x16>>::Output

fn _hypot(self, rhs: i8x16) -> <bf16 as FloatOutBinary<i8x16>>::Output

impl FloatOutBinary<i8x16> for f16

type Output = <f16x8 as FloatOutBinaryPromote<i8x16>>::Output

fn _div(self, rhs: i8x16) -> <f16 as FloatOutBinary<i8x16>>::Output

fn _log(self, base: i8x16) -> <f16 as FloatOutBinary<i8x16>>::Output

fn _hypot(self, rhs: i8x16) -> <f16 as FloatOutBinary<i8x16>>::Output

impl FloatOutBinary<i8x16> for Complex<f32>

type Output = <cplx32x2 as FloatOutBinaryPromote<i8x16>>::Output

fn _div(self, rhs: i8x16) -> <Complex<f32> as FloatOutBinary<i8x16>>::Output

fn _log(self, base: i8x16) -> <Complex<f32> as FloatOutBinary<i8x16>>::Output

fn _hypot(self, rhs: i8x16) -> <Complex<f32> as FloatOutBinary<i8x16>>::Output

impl FloatOutBinary<i8x16> for Complex<f64>

type Output = <cplx64x1 as FloatOutBinaryPromote<i8x16>>::Output

fn _div(self, rhs: i8x16) -> <Complex<f64> as FloatOutBinary<i8x16>>::Output

fn _log(self, base: i8x16) -> <Complex<f64> as FloatOutBinary<i8x16>>::Output

fn _hypot(self, rhs: i8x16) -> <Complex<f64> as FloatOutBinary<i8x16>>::Output

impl FloatOutBinary<i16x8> for bool

type Output = <boolx16 as FloatOutBinaryPromote<i16x8>>::Output

fn _div(self, rhs: i16x8) -> <bool as FloatOutBinary<i16x8>>::Output

fn _log(self, base: i16x8) -> <bool as FloatOutBinary<i16x8>>::Output

fn _hypot(self, rhs: i16x8) -> <bool as FloatOutBinary<i16x8>>::Output

impl FloatOutBinary<i16x8> for f32

type Output = <f32x4 as FloatOutBinaryPromote<i16x8>>::Output

fn _div(self, rhs: i16x8) -> <f32 as FloatOutBinary<i16x8>>::Output

fn _log(self, base: i16x8) -> <f32 as FloatOutBinary<i16x8>>::Output

fn _hypot(self, rhs: i16x8) -> <f32 as FloatOutBinary<i16x8>>::Output

impl FloatOutBinary<i16x8> for f64

type Output = <f64x2 as FloatOutBinaryPromote<i16x8>>::Output

fn _div(self, rhs: i16x8) -> <f64 as FloatOutBinary<i16x8>>::Output

fn _log(self, base: i16x8) -> <f64 as FloatOutBinary<i16x8>>::Output

fn _hypot(self, rhs: i16x8) -> <f64 as FloatOutBinary<i16x8>>::Output

impl FloatOutBinary<i16x8> for i8

type Output = <i8x16 as FloatOutBinaryPromote<i16x8>>::Output

fn _div(self, rhs: i16x8) -> <i8 as FloatOutBinary<i16x8>>::Output

fn _log(self, base: i16x8) -> <i8 as FloatOutBinary<i16x8>>::Output

fn _hypot(self, rhs: i16x8) -> <i8 as FloatOutBinary<i16x8>>::Output

impl FloatOutBinary<i16x8> for i16

type Output = <i16x8 as FloatOutBinaryPromote>::Output

fn _div(self, rhs: i16x8) -> <i16 as FloatOutBinary<i16x8>>::Output

fn _log(self, base: i16x8) -> <i16 as FloatOutBinary<i16x8>>::Output

fn _hypot(self, rhs: i16x8) -> <i16 as FloatOutBinary<i16x8>>::Output

impl FloatOutBinary<i16x8> for i32

type Output = <i32x4 as FloatOutBinaryPromote<i16x8>>::Output

fn _div(self, rhs: i16x8) -> <i32 as FloatOutBinary<i16x8>>::Output

fn _log(self, base: i16x8) -> <i32 as FloatOutBinary<i16x8>>::Output

fn _hypot(self, rhs: i16x8) -> <i32 as FloatOutBinary<i16x8>>::Output

impl FloatOutBinary<i16x8> for i64

type Output = <i64x2 as FloatOutBinaryPromote<i16x8>>::Output

fn _div(self, rhs: i16x8) -> <i64 as FloatOutBinary<i16x8>>::Output

fn _log(self, base: i16x8) -> <i64 as FloatOutBinary<i16x8>>::Output

fn _hypot(self, rhs: i16x8) -> <i64 as FloatOutBinary<i16x8>>::Output

impl FloatOutBinary<i16x8> for isize

type Output = <isizex2 as FloatOutBinaryPromote<i16x8>>::Output

fn _div(self, rhs: i16x8) -> <isize as FloatOutBinary<i16x8>>::Output

fn _log(self, base: i16x8) -> <isize as FloatOutBinary<i16x8>>::Output

fn _hypot(self, rhs: i16x8) -> <isize as FloatOutBinary<i16x8>>::Output

impl FloatOutBinary<i16x8> for u8

type Output = <u8x16 as FloatOutBinaryPromote<i16x8>>::Output

fn _div(self, rhs: i16x8) -> <u8 as FloatOutBinary<i16x8>>::Output

fn _log(self, base: i16x8) -> <u8 as FloatOutBinary<i16x8>>::Output

fn _hypot(self, rhs: i16x8) -> <u8 as FloatOutBinary<i16x8>>::Output

impl FloatOutBinary<i16x8> for u16

type Output = <u16x8 as FloatOutBinaryPromote<i16x8>>::Output

fn _div(self, rhs: i16x8) -> <u16 as FloatOutBinary<i16x8>>::Output

fn _log(self, base: i16x8) -> <u16 as FloatOutBinary<i16x8>>::Output

fn _hypot(self, rhs: i16x8) -> <u16 as FloatOutBinary<i16x8>>::Output

impl FloatOutBinary<i16x8> for u32

type Output = <u32x4 as FloatOutBinaryPromote<i16x8>>::Output

fn _div(self, rhs: i16x8) -> <u32 as FloatOutBinary<i16x8>>::Output

fn _log(self, base: i16x8) -> <u32 as FloatOutBinary<i16x8>>::Output

fn _hypot(self, rhs: i16x8) -> <u32 as FloatOutBinary<i16x8>>::Output

impl FloatOutBinary<i16x8> for u64

type Output = <u64x2 as FloatOutBinaryPromote<i16x8>>::Output

fn _div(self, rhs: i16x8) -> <u64 as FloatOutBinary<i16x8>>::Output

fn _log(self, base: i16x8) -> <u64 as FloatOutBinary<i16x8>>::Output

fn _hypot(self, rhs: i16x8) -> <u64 as FloatOutBinary<i16x8>>::Output

impl FloatOutBinary<i16x8> for usize

type Output = <usizex2 as FloatOutBinaryPromote<i16x8>>::Output

fn _div(self, rhs: i16x8) -> <usize as FloatOutBinary<i16x8>>::Output

fn _log(self, base: i16x8) -> <usize as FloatOutBinary<i16x8>>::Output

fn _hypot(self, rhs: i16x8) -> <usize as FloatOutBinary<i16x8>>::Output

impl FloatOutBinary<i16x8> for bf16

type Output = <bf16x8 as FloatOutBinaryPromote<i16x8>>::Output

fn _div(self, rhs: i16x8) -> <bf16 as FloatOutBinary<i16x8>>::Output

fn _log(self, base: i16x8) -> <bf16 as FloatOutBinary<i16x8>>::Output

fn _hypot(self, rhs: i16x8) -> <bf16 as FloatOutBinary<i16x8>>::Output

impl FloatOutBinary<i16x8> for f16

type Output = <f16x8 as FloatOutBinaryPromote<i16x8>>::Output

fn _div(self, rhs: i16x8) -> <f16 as FloatOutBinary<i16x8>>::Output

fn _log(self, base: i16x8) -> <f16 as FloatOutBinary<i16x8>>::Output

fn _hypot(self, rhs: i16x8) -> <f16 as FloatOutBinary<i16x8>>::Output

impl FloatOutBinary<i16x8> for Complex<f32>

type Output = <cplx32x2 as FloatOutBinaryPromote<i16x8>>::Output

fn _div(self, rhs: i16x8) -> <Complex<f32> as FloatOutBinary<i16x8>>::Output

fn _log(self, base: i16x8) -> <Complex<f32> as FloatOutBinary<i16x8>>::Output

fn _hypot(self, rhs: i16x8) -> <Complex<f32> as FloatOutBinary<i16x8>>::Output

impl FloatOutBinary<i16x8> for Complex<f64>

type Output = <cplx64x1 as FloatOutBinaryPromote<i16x8>>::Output

fn _div(self, rhs: i16x8) -> <Complex<f64> as FloatOutBinary<i16x8>>::Output

fn _log(self, base: i16x8) -> <Complex<f64> as FloatOutBinary<i16x8>>::Output

fn _hypot(self, rhs: i16x8) -> <Complex<f64> as FloatOutBinary<i16x8>>::Output

impl FloatOutBinary<i32x4> for bool

type Output = <boolx16 as FloatOutBinaryPromote<i32x4>>::Output

fn _div(self, rhs: i32x4) -> <bool as FloatOutBinary<i32x4>>::Output

fn _log(self, base: i32x4) -> <bool as FloatOutBinary<i32x4>>::Output

fn _hypot(self, rhs: i32x4) -> <bool as FloatOutBinary<i32x4>>::Output

impl FloatOutBinary<i32x4> for f32

type Output = <f32x4 as FloatOutBinaryPromote<i32x4>>::Output

fn _div(self, rhs: i32x4) -> <f32 as FloatOutBinary<i32x4>>::Output

fn _log(self, base: i32x4) -> <f32 as FloatOutBinary<i32x4>>::Output

fn _hypot(self, rhs: i32x4) -> <f32 as FloatOutBinary<i32x4>>::Output

impl FloatOutBinary<i32x4> for f64

type Output = <f64x2 as FloatOutBinaryPromote<i32x4>>::Output

fn _div(self, rhs: i32x4) -> <f64 as FloatOutBinary<i32x4>>::Output

fn _log(self, base: i32x4) -> <f64 as FloatOutBinary<i32x4>>::Output

fn _hypot(self, rhs: i32x4) -> <f64 as FloatOutBinary<i32x4>>::Output

impl FloatOutBinary<i32x4> for i8

type Output = <i8x16 as FloatOutBinaryPromote<i32x4>>::Output

fn _div(self, rhs: i32x4) -> <i8 as FloatOutBinary<i32x4>>::Output

fn _log(self, base: i32x4) -> <i8 as FloatOutBinary<i32x4>>::Output

fn _hypot(self, rhs: i32x4) -> <i8 as FloatOutBinary<i32x4>>::Output

impl FloatOutBinary<i32x4> for i16

type Output = <i16x8 as FloatOutBinaryPromote<i32x4>>::Output

fn _div(self, rhs: i32x4) -> <i16 as FloatOutBinary<i32x4>>::Output

fn _log(self, base: i32x4) -> <i16 as FloatOutBinary<i32x4>>::Output

fn _hypot(self, rhs: i32x4) -> <i16 as FloatOutBinary<i32x4>>::Output

impl FloatOutBinary<i32x4> for i32

type Output = <i32x4 as FloatOutBinaryPromote>::Output

fn _div(self, rhs: i32x4) -> <i32 as FloatOutBinary<i32x4>>::Output

fn _log(self, base: i32x4) -> <i32 as FloatOutBinary<i32x4>>::Output

fn _hypot(self, rhs: i32x4) -> <i32 as FloatOutBinary<i32x4>>::Output

impl FloatOutBinary<i32x4> for i64

type Output = <i64x2 as FloatOutBinaryPromote<i32x4>>::Output

fn _div(self, rhs: i32x4) -> <i64 as FloatOutBinary<i32x4>>::Output

fn _log(self, base: i32x4) -> <i64 as FloatOutBinary<i32x4>>::Output

fn _hypot(self, rhs: i32x4) -> <i64 as FloatOutBinary<i32x4>>::Output

impl FloatOutBinary<i32x4> for isize

type Output = <isizex2 as FloatOutBinaryPromote<i32x4>>::Output

fn _div(self, rhs: i32x4) -> <isize as FloatOutBinary<i32x4>>::Output

fn _log(self, base: i32x4) -> <isize as FloatOutBinary<i32x4>>::Output

fn _hypot(self, rhs: i32x4) -> <isize as FloatOutBinary<i32x4>>::Output

impl FloatOutBinary<i32x4> for u8

type Output = <u8x16 as FloatOutBinaryPromote<i32x4>>::Output

fn _div(self, rhs: i32x4) -> <u8 as FloatOutBinary<i32x4>>::Output

fn _log(self, base: i32x4) -> <u8 as FloatOutBinary<i32x4>>::Output

fn _hypot(self, rhs: i32x4) -> <u8 as FloatOutBinary<i32x4>>::Output

impl FloatOutBinary<i32x4> for u16

type Output = <u16x8 as FloatOutBinaryPromote<i32x4>>::Output

fn _div(self, rhs: i32x4) -> <u16 as FloatOutBinary<i32x4>>::Output

fn _log(self, base: i32x4) -> <u16 as FloatOutBinary<i32x4>>::Output

fn _hypot(self, rhs: i32x4) -> <u16 as FloatOutBinary<i32x4>>::Output

impl FloatOutBinary<i32x4> for u32

type Output = <u32x4 as FloatOutBinaryPromote<i32x4>>::Output

fn _div(self, rhs: i32x4) -> <u32 as FloatOutBinary<i32x4>>::Output

fn _log(self, base: i32x4) -> <u32 as FloatOutBinary<i32x4>>::Output

fn _hypot(self, rhs: i32x4) -> <u32 as FloatOutBinary<i32x4>>::Output

impl FloatOutBinary<i32x4> for u64

type Output = <u64x2 as FloatOutBinaryPromote<i32x4>>::Output

fn _div(self, rhs: i32x4) -> <u64 as FloatOutBinary<i32x4>>::Output

fn _log(self, base: i32x4) -> <u64 as FloatOutBinary<i32x4>>::Output

fn _hypot(self, rhs: i32x4) -> <u64 as FloatOutBinary<i32x4>>::Output

impl FloatOutBinary<i32x4> for usize

type Output = <usizex2 as FloatOutBinaryPromote<i32x4>>::Output

fn _div(self, rhs: i32x4) -> <usize as FloatOutBinary<i32x4>>::Output

fn _log(self, base: i32x4) -> <usize as FloatOutBinary<i32x4>>::Output

fn _hypot(self, rhs: i32x4) -> <usize as FloatOutBinary<i32x4>>::Output

impl FloatOutBinary<i32x4> for bf16

type Output = <bf16x8 as FloatOutBinaryPromote<i32x4>>::Output

fn _div(self, rhs: i32x4) -> <bf16 as FloatOutBinary<i32x4>>::Output

fn _log(self, base: i32x4) -> <bf16 as FloatOutBinary<i32x4>>::Output

fn _hypot(self, rhs: i32x4) -> <bf16 as FloatOutBinary<i32x4>>::Output

impl FloatOutBinary<i32x4> for f16

type Output = <f16x8 as FloatOutBinaryPromote<i32x4>>::Output

fn _div(self, rhs: i32x4) -> <f16 as FloatOutBinary<i32x4>>::Output

fn _log(self, base: i32x4) -> <f16 as FloatOutBinary<i32x4>>::Output

fn _hypot(self, rhs: i32x4) -> <f16 as FloatOutBinary<i32x4>>::Output

impl FloatOutBinary<i32x4> for Complex<f32>

type Output = <cplx32x2 as FloatOutBinaryPromote<i32x4>>::Output

fn _div(self, rhs: i32x4) -> <Complex<f32> as FloatOutBinary<i32x4>>::Output

fn _log(self, base: i32x4) -> <Complex<f32> as FloatOutBinary<i32x4>>::Output

fn _hypot(self, rhs: i32x4) -> <Complex<f32> as FloatOutBinary<i32x4>>::Output

impl FloatOutBinary<i32x4> for Complex<f64>

type Output = <cplx64x1 as FloatOutBinaryPromote<i32x4>>::Output

fn _div(self, rhs: i32x4) -> <Complex<f64> as FloatOutBinary<i32x4>>::Output

fn _log(self, base: i32x4) -> <Complex<f64> as FloatOutBinary<i32x4>>::Output

fn _hypot(self, rhs: i32x4) -> <Complex<f64> as FloatOutBinary<i32x4>>::Output

impl FloatOutBinary<i64x2> for bool

type Output = <boolx16 as FloatOutBinaryPromote<i64x2>>::Output

fn _div(self, rhs: i64x2) -> <bool as FloatOutBinary<i64x2>>::Output

fn _log(self, base: i64x2) -> <bool as FloatOutBinary<i64x2>>::Output

fn _hypot(self, rhs: i64x2) -> <bool as FloatOutBinary<i64x2>>::Output

impl FloatOutBinary<i64x2> for f32

type Output = <f32x4 as FloatOutBinaryPromote<i64x2>>::Output

fn _div(self, rhs: i64x2) -> <f32 as FloatOutBinary<i64x2>>::Output

fn _log(self, base: i64x2) -> <f32 as FloatOutBinary<i64x2>>::Output

fn _hypot(self, rhs: i64x2) -> <f32 as FloatOutBinary<i64x2>>::Output

impl FloatOutBinary<i64x2> for f64

type Output = <f64x2 as FloatOutBinaryPromote<i64x2>>::Output

fn _div(self, rhs: i64x2) -> <f64 as FloatOutBinary<i64x2>>::Output

fn _log(self, base: i64x2) -> <f64 as FloatOutBinary<i64x2>>::Output

fn _hypot(self, rhs: i64x2) -> <f64 as FloatOutBinary<i64x2>>::Output

impl FloatOutBinary<i64x2> for i8

type Output = <i8x16 as FloatOutBinaryPromote<i64x2>>::Output

fn _div(self, rhs: i64x2) -> <i8 as FloatOutBinary<i64x2>>::Output

fn _log(self, base: i64x2) -> <i8 as FloatOutBinary<i64x2>>::Output

fn _hypot(self, rhs: i64x2) -> <i8 as FloatOutBinary<i64x2>>::Output

impl FloatOutBinary<i64x2> for i16

type Output = <i16x8 as FloatOutBinaryPromote<i64x2>>::Output

fn _div(self, rhs: i64x2) -> <i16 as FloatOutBinary<i64x2>>::Output

fn _log(self, base: i64x2) -> <i16 as FloatOutBinary<i64x2>>::Output

fn _hypot(self, rhs: i64x2) -> <i16 as FloatOutBinary<i64x2>>::Output

impl FloatOutBinary<i64x2> for i32

type Output = <i32x4 as FloatOutBinaryPromote<i64x2>>::Output

fn _div(self, rhs: i64x2) -> <i32 as FloatOutBinary<i64x2>>::Output

fn _log(self, base: i64x2) -> <i32 as FloatOutBinary<i64x2>>::Output

fn _hypot(self, rhs: i64x2) -> <i32 as FloatOutBinary<i64x2>>::Output

impl FloatOutBinary<i64x2> for i64

type Output = <i64x2 as FloatOutBinaryPromote>::Output

fn _div(self, rhs: i64x2) -> <i64 as FloatOutBinary<i64x2>>::Output

fn _log(self, base: i64x2) -> <i64 as FloatOutBinary<i64x2>>::Output

fn _hypot(self, rhs: i64x2) -> <i64 as FloatOutBinary<i64x2>>::Output

impl FloatOutBinary<i64x2> for isize

type Output = <isizex2 as FloatOutBinaryPromote<i64x2>>::Output

fn _div(self, rhs: i64x2) -> <isize as FloatOutBinary<i64x2>>::Output

fn _log(self, base: i64x2) -> <isize as FloatOutBinary<i64x2>>::Output

fn _hypot(self, rhs: i64x2) -> <isize as FloatOutBinary<i64x2>>::Output

impl FloatOutBinary<i64x2> for u8

type Output = <u8x16 as FloatOutBinaryPromote<i64x2>>::Output

fn _div(self, rhs: i64x2) -> <u8 as FloatOutBinary<i64x2>>::Output

fn _log(self, base: i64x2) -> <u8 as FloatOutBinary<i64x2>>::Output

fn _hypot(self, rhs: i64x2) -> <u8 as FloatOutBinary<i64x2>>::Output

impl FloatOutBinary<i64x2> for u16

type Output = <u16x8 as FloatOutBinaryPromote<i64x2>>::Output

fn _div(self, rhs: i64x2) -> <u16 as FloatOutBinary<i64x2>>::Output

fn _log(self, base: i64x2) -> <u16 as FloatOutBinary<i64x2>>::Output

fn _hypot(self, rhs: i64x2) -> <u16 as FloatOutBinary<i64x2>>::Output

impl FloatOutBinary<i64x2> for u32

type Output = <u32x4 as FloatOutBinaryPromote<i64x2>>::Output

fn _div(self, rhs: i64x2) -> <u32 as FloatOutBinary<i64x2>>::Output

fn _log(self, base: i64x2) -> <u32 as FloatOutBinary<i64x2>>::Output

fn _hypot(self, rhs: i64x2) -> <u32 as FloatOutBinary<i64x2>>::Output

impl FloatOutBinary<i64x2> for u64

type Output = <u64x2 as FloatOutBinaryPromote<i64x2>>::Output

fn _div(self, rhs: i64x2) -> <u64 as FloatOutBinary<i64x2>>::Output

fn _log(self, base: i64x2) -> <u64 as FloatOutBinary<i64x2>>::Output

fn _hypot(self, rhs: i64x2) -> <u64 as FloatOutBinary<i64x2>>::Output

impl FloatOutBinary<i64x2> for usize

type Output = <usizex2 as FloatOutBinaryPromote<i64x2>>::Output

fn _div(self, rhs: i64x2) -> <usize as FloatOutBinary<i64x2>>::Output

fn _log(self, base: i64x2) -> <usize as FloatOutBinary<i64x2>>::Output

fn _hypot(self, rhs: i64x2) -> <usize as FloatOutBinary<i64x2>>::Output

impl FloatOutBinary<i64x2> for bf16

type Output = <bf16x8 as FloatOutBinaryPromote<i64x2>>::Output

fn _div(self, rhs: i64x2) -> <bf16 as FloatOutBinary<i64x2>>::Output

fn _log(self, base: i64x2) -> <bf16 as FloatOutBinary<i64x2>>::Output

fn _hypot(self, rhs: i64x2) -> <bf16 as FloatOutBinary<i64x2>>::Output

impl FloatOutBinary<i64x2> for f16

type Output = <f16x8 as FloatOutBinaryPromote<i64x2>>::Output

fn _div(self, rhs: i64x2) -> <f16 as FloatOutBinary<i64x2>>::Output

fn _log(self, base: i64x2) -> <f16 as FloatOutBinary<i64x2>>::Output

fn _hypot(self, rhs: i64x2) -> <f16 as FloatOutBinary<i64x2>>::Output

impl FloatOutBinary<i64x2> for Complex<f32>

type Output = <cplx32x2 as FloatOutBinaryPromote<i64x2>>::Output

fn _div(self, rhs: i64x2) -> <Complex<f32> as FloatOutBinary<i64x2>>::Output

fn _log(self, base: i64x2) -> <Complex<f32> as FloatOutBinary<i64x2>>::Output

fn _hypot(self, rhs: i64x2) -> <Complex<f32> as FloatOutBinary<i64x2>>::Output

impl FloatOutBinary<i64x2> for Complex<f64>

type Output = <cplx64x1 as FloatOutBinaryPromote<i64x2>>::Output

fn _div(self, rhs: i64x2) -> <Complex<f64> as FloatOutBinary<i64x2>>::Output

fn _log(self, base: i64x2) -> <Complex<f64> as FloatOutBinary<i64x2>>::Output

fn _hypot(self, rhs: i64x2) -> <Complex<f64> as FloatOutBinary<i64x2>>::Output

impl FloatOutBinary<isizex2> for bool

type Output = <boolx16 as FloatOutBinaryPromote<isizex2>>::Output

fn _div(self, rhs: isizex2) -> <bool as FloatOutBinary<isizex2>>::Output

fn _log(self, base: isizex2) -> <bool as FloatOutBinary<isizex2>>::Output

fn _hypot(self, rhs: isizex2) -> <bool as FloatOutBinary<isizex2>>::Output

impl FloatOutBinary<isizex2> for f32

type Output = <f32x4 as FloatOutBinaryPromote<isizex2>>::Output

fn _div(self, rhs: isizex2) -> <f32 as FloatOutBinary<isizex2>>::Output

fn _log(self, base: isizex2) -> <f32 as FloatOutBinary<isizex2>>::Output

fn _hypot(self, rhs: isizex2) -> <f32 as FloatOutBinary<isizex2>>::Output

impl FloatOutBinary<isizex2> for f64

type Output = <f64x2 as FloatOutBinaryPromote<isizex2>>::Output

fn _div(self, rhs: isizex2) -> <f64 as FloatOutBinary<isizex2>>::Output

fn _log(self, base: isizex2) -> <f64 as FloatOutBinary<isizex2>>::Output

fn _hypot(self, rhs: isizex2) -> <f64 as FloatOutBinary<isizex2>>::Output

impl FloatOutBinary<isizex2> for i8

type Output = <i8x16 as FloatOutBinaryPromote<isizex2>>::Output

fn _div(self, rhs: isizex2) -> <i8 as FloatOutBinary<isizex2>>::Output

fn _log(self, base: isizex2) -> <i8 as FloatOutBinary<isizex2>>::Output

fn _hypot(self, rhs: isizex2) -> <i8 as FloatOutBinary<isizex2>>::Output

impl FloatOutBinary<isizex2> for i16

type Output = <i16x8 as FloatOutBinaryPromote<isizex2>>::Output

fn _div(self, rhs: isizex2) -> <i16 as FloatOutBinary<isizex2>>::Output

fn _log(self, base: isizex2) -> <i16 as FloatOutBinary<isizex2>>::Output

fn _hypot(self, rhs: isizex2) -> <i16 as FloatOutBinary<isizex2>>::Output

impl FloatOutBinary<isizex2> for i32

type Output = <i32x4 as FloatOutBinaryPromote<isizex2>>::Output

fn _div(self, rhs: isizex2) -> <i32 as FloatOutBinary<isizex2>>::Output

fn _log(self, base: isizex2) -> <i32 as FloatOutBinary<isizex2>>::Output

fn _hypot(self, rhs: isizex2) -> <i32 as FloatOutBinary<isizex2>>::Output

impl FloatOutBinary<isizex2> for i64

type Output = <i64x2 as FloatOutBinaryPromote<isizex2>>::Output

fn _div(self, rhs: isizex2) -> <i64 as FloatOutBinary<isizex2>>::Output

fn _log(self, base: isizex2) -> <i64 as FloatOutBinary<isizex2>>::Output

fn _hypot(self, rhs: isizex2) -> <i64 as FloatOutBinary<isizex2>>::Output

impl FloatOutBinary<isizex2> for isize

type Output = <isizex2 as FloatOutBinaryPromote>::Output

fn _div(self, rhs: isizex2) -> <isize as FloatOutBinary<isizex2>>::Output

fn _log(self, base: isizex2) -> <isize as FloatOutBinary<isizex2>>::Output

fn _hypot(self, rhs: isizex2) -> <isize as FloatOutBinary<isizex2>>::Output

impl FloatOutBinary<isizex2> for u8

type Output = <u8x16 as FloatOutBinaryPromote<isizex2>>::Output

fn _div(self, rhs: isizex2) -> <u8 as FloatOutBinary<isizex2>>::Output

fn _log(self, base: isizex2) -> <u8 as FloatOutBinary<isizex2>>::Output

fn _hypot(self, rhs: isizex2) -> <u8 as FloatOutBinary<isizex2>>::Output

impl FloatOutBinary<isizex2> for u16

type Output = <u16x8 as FloatOutBinaryPromote<isizex2>>::Output

fn _div(self, rhs: isizex2) -> <u16 as FloatOutBinary<isizex2>>::Output

fn _log(self, base: isizex2) -> <u16 as FloatOutBinary<isizex2>>::Output

fn _hypot(self, rhs: isizex2) -> <u16 as FloatOutBinary<isizex2>>::Output

impl FloatOutBinary<isizex2> for u32

type Output = <u32x4 as FloatOutBinaryPromote<isizex2>>::Output

fn _div(self, rhs: isizex2) -> <u32 as FloatOutBinary<isizex2>>::Output

fn _log(self, base: isizex2) -> <u32 as FloatOutBinary<isizex2>>::Output

fn _hypot(self, rhs: isizex2) -> <u32 as FloatOutBinary<isizex2>>::Output

impl FloatOutBinary<isizex2> for u64

type Output = <u64x2 as FloatOutBinaryPromote<isizex2>>::Output

fn _div(self, rhs: isizex2) -> <u64 as FloatOutBinary<isizex2>>::Output

fn _log(self, base: isizex2) -> <u64 as FloatOutBinary<isizex2>>::Output

fn _hypot(self, rhs: isizex2) -> <u64 as FloatOutBinary<isizex2>>::Output

impl FloatOutBinary<isizex2> for usize

type Output = <usizex2 as FloatOutBinaryPromote<isizex2>>::Output

fn _div(self, rhs: isizex2) -> <usize as FloatOutBinary<isizex2>>::Output

fn _log(self, base: isizex2) -> <usize as FloatOutBinary<isizex2>>::Output

fn _hypot(self, rhs: isizex2) -> <usize as FloatOutBinary<isizex2>>::Output

impl FloatOutBinary<isizex2> for bf16

type Output = <bf16x8 as FloatOutBinaryPromote<isizex2>>::Output

fn _div(self, rhs: isizex2) -> <bf16 as FloatOutBinary<isizex2>>::Output

fn _log(self, base: isizex2) -> <bf16 as FloatOutBinary<isizex2>>::Output

fn _hypot(self, rhs: isizex2) -> <bf16 as FloatOutBinary<isizex2>>::Output

impl FloatOutBinary<isizex2> for f16

type Output = <f16x8 as FloatOutBinaryPromote<isizex2>>::Output

fn _div(self, rhs: isizex2) -> <f16 as FloatOutBinary<isizex2>>::Output

fn _log(self, base: isizex2) -> <f16 as FloatOutBinary<isizex2>>::Output

fn _hypot(self, rhs: isizex2) -> <f16 as FloatOutBinary<isizex2>>::Output

impl FloatOutBinary<isizex2> for Complex<f32>

type Output = <cplx32x2 as FloatOutBinaryPromote<isizex2>>::Output

fn _div(self, rhs: isizex2) -> <Complex<f32> as FloatOutBinary<isizex2>>::Output

fn _log( self, base: isizex2, ) -> <Complex<f32> as FloatOutBinary<isizex2>>::Output

fn _hypot( self, rhs: isizex2, ) -> <Complex<f32> as FloatOutBinary<isizex2>>::Output

impl FloatOutBinary<isizex2> for Complex<f64>

type Output = <cplx64x1 as FloatOutBinaryPromote<isizex2>>::Output

fn _div(self, rhs: isizex2) -> <Complex<f64> as FloatOutBinary<isizex2>>::Output

fn _log( self, base: isizex2, ) -> <Complex<f64> as FloatOutBinary<isizex2>>::Output

fn _hypot( self, rhs: isizex2, ) -> <Complex<f64> as FloatOutBinary<isizex2>>::Output

impl FloatOutBinary<u8x16> for bool

type Output = <boolx16 as FloatOutBinaryPromote<u8x16>>::Output

fn _div(self, rhs: u8x16) -> <bool as FloatOutBinary<u8x16>>::Output

fn _log(self, base: u8x16) -> <bool as FloatOutBinary<u8x16>>::Output

fn _hypot(self, rhs: u8x16) -> <bool as FloatOutBinary<u8x16>>::Output

impl FloatOutBinary<u8x16> for f32

type Output = <f32x4 as FloatOutBinaryPromote<u8x16>>::Output

fn _div(self, rhs: u8x16) -> <f32 as FloatOutBinary<u8x16>>::Output

fn _log(self, base: u8x16) -> <f32 as FloatOutBinary<u8x16>>::Output

fn _hypot(self, rhs: u8x16) -> <f32 as FloatOutBinary<u8x16>>::Output

impl FloatOutBinary<u8x16> for f64

type Output = <f64x2 as FloatOutBinaryPromote<u8x16>>::Output

fn _div(self, rhs: u8x16) -> <f64 as FloatOutBinary<u8x16>>::Output

fn _log(self, base: u8x16) -> <f64 as FloatOutBinary<u8x16>>::Output

fn _hypot(self, rhs: u8x16) -> <f64 as FloatOutBinary<u8x16>>::Output

impl FloatOutBinary<u8x16> for i8

type Output = <i8x16 as FloatOutBinaryPromote<u8x16>>::Output

fn _div(self, rhs: u8x16) -> <i8 as FloatOutBinary<u8x16>>::Output

fn _log(self, base: u8x16) -> <i8 as FloatOutBinary<u8x16>>::Output

fn _hypot(self, rhs: u8x16) -> <i8 as FloatOutBinary<u8x16>>::Output

impl FloatOutBinary<u8x16> for i16

type Output = <i16x8 as FloatOutBinaryPromote<u8x16>>::Output

fn _div(self, rhs: u8x16) -> <i16 as FloatOutBinary<u8x16>>::Output

fn _log(self, base: u8x16) -> <i16 as FloatOutBinary<u8x16>>::Output

fn _hypot(self, rhs: u8x16) -> <i16 as FloatOutBinary<u8x16>>::Output

impl FloatOutBinary<u8x16> for i32

type Output = <i32x4 as FloatOutBinaryPromote<u8x16>>::Output

fn _div(self, rhs: u8x16) -> <i32 as FloatOutBinary<u8x16>>::Output

fn _log(self, base: u8x16) -> <i32 as FloatOutBinary<u8x16>>::Output

fn _hypot(self, rhs: u8x16) -> <i32 as FloatOutBinary<u8x16>>::Output

impl FloatOutBinary<u8x16> for i64

type Output = <i64x2 as FloatOutBinaryPromote<u8x16>>::Output

fn _div(self, rhs: u8x16) -> <i64 as FloatOutBinary<u8x16>>::Output

fn _log(self, base: u8x16) -> <i64 as FloatOutBinary<u8x16>>::Output

fn _hypot(self, rhs: u8x16) -> <i64 as FloatOutBinary<u8x16>>::Output

impl FloatOutBinary<u8x16> for isize

type Output = <isizex2 as FloatOutBinaryPromote<u8x16>>::Output

fn _div(self, rhs: u8x16) -> <isize as FloatOutBinary<u8x16>>::Output

fn _log(self, base: u8x16) -> <isize as FloatOutBinary<u8x16>>::Output

fn _hypot(self, rhs: u8x16) -> <isize as FloatOutBinary<u8x16>>::Output

impl FloatOutBinary<u8x16> for u8

type Output = <u8x16 as FloatOutBinaryPromote>::Output

fn _div(self, rhs: u8x16) -> <u8 as FloatOutBinary<u8x16>>::Output

fn _log(self, base: u8x16) -> <u8 as FloatOutBinary<u8x16>>::Output

fn _hypot(self, rhs: u8x16) -> <u8 as FloatOutBinary<u8x16>>::Output

impl FloatOutBinary<u8x16> for u16

type Output = <u16x8 as FloatOutBinaryPromote<u8x16>>::Output

fn _div(self, rhs: u8x16) -> <u16 as FloatOutBinary<u8x16>>::Output

fn _log(self, base: u8x16) -> <u16 as FloatOutBinary<u8x16>>::Output

fn _hypot(self, rhs: u8x16) -> <u16 as FloatOutBinary<u8x16>>::Output

impl FloatOutBinary<u8x16> for u32

type Output = <u32x4 as FloatOutBinaryPromote<u8x16>>::Output

fn _div(self, rhs: u8x16) -> <u32 as FloatOutBinary<u8x16>>::Output

fn _log(self, base: u8x16) -> <u32 as FloatOutBinary<u8x16>>::Output

fn _hypot(self, rhs: u8x16) -> <u32 as FloatOutBinary<u8x16>>::Output

impl FloatOutBinary<u8x16> for u64

type Output = <u64x2 as FloatOutBinaryPromote<u8x16>>::Output

fn _div(self, rhs: u8x16) -> <u64 as FloatOutBinary<u8x16>>::Output

fn _log(self, base: u8x16) -> <u64 as FloatOutBinary<u8x16>>::Output

fn _hypot(self, rhs: u8x16) -> <u64 as FloatOutBinary<u8x16>>::Output

impl FloatOutBinary<u8x16> for usize

type Output = <usizex2 as FloatOutBinaryPromote<u8x16>>::Output

fn _div(self, rhs: u8x16) -> <usize as FloatOutBinary<u8x16>>::Output

fn _log(self, base: u8x16) -> <usize as FloatOutBinary<u8x16>>::Output

fn _hypot(self, rhs: u8x16) -> <usize as FloatOutBinary<u8x16>>::Output

impl FloatOutBinary<u8x16> for bf16

type Output = <bf16x8 as FloatOutBinaryPromote<u8x16>>::Output

fn _div(self, rhs: u8x16) -> <bf16 as FloatOutBinary<u8x16>>::Output

fn _log(self, base: u8x16) -> <bf16 as FloatOutBinary<u8x16>>::Output

fn _hypot(self, rhs: u8x16) -> <bf16 as FloatOutBinary<u8x16>>::Output

impl FloatOutBinary<u8x16> for f16

type Output = <f16x8 as FloatOutBinaryPromote<u8x16>>::Output

fn _div(self, rhs: u8x16) -> <f16 as FloatOutBinary<u8x16>>::Output

fn _log(self, base: u8x16) -> <f16 as FloatOutBinary<u8x16>>::Output

fn _hypot(self, rhs: u8x16) -> <f16 as FloatOutBinary<u8x16>>::Output

impl FloatOutBinary<u8x16> for Complex<f32>

type Output = <cplx32x2 as FloatOutBinaryPromote<u8x16>>::Output

fn _div(self, rhs: u8x16) -> <Complex<f32> as FloatOutBinary<u8x16>>::Output

fn _log(self, base: u8x16) -> <Complex<f32> as FloatOutBinary<u8x16>>::Output

fn _hypot(self, rhs: u8x16) -> <Complex<f32> as FloatOutBinary<u8x16>>::Output

impl FloatOutBinary<u8x16> for Complex<f64>

type Output = <cplx64x1 as FloatOutBinaryPromote<u8x16>>::Output

fn _div(self, rhs: u8x16) -> <Complex<f64> as FloatOutBinary<u8x16>>::Output

fn _log(self, base: u8x16) -> <Complex<f64> as FloatOutBinary<u8x16>>::Output

fn _hypot(self, rhs: u8x16) -> <Complex<f64> as FloatOutBinary<u8x16>>::Output

impl FloatOutBinary<u16x8> for bool

type Output = <boolx16 as FloatOutBinaryPromote<u16x8>>::Output

fn _div(self, rhs: u16x8) -> <bool as FloatOutBinary<u16x8>>::Output

fn _log(self, base: u16x8) -> <bool as FloatOutBinary<u16x8>>::Output

fn _hypot(self, rhs: u16x8) -> <bool as FloatOutBinary<u16x8>>::Output

impl FloatOutBinary<u16x8> for f32

type Output = <f32x4 as FloatOutBinaryPromote<u16x8>>::Output

fn _div(self, rhs: u16x8) -> <f32 as FloatOutBinary<u16x8>>::Output

fn _log(self, base: u16x8) -> <f32 as FloatOutBinary<u16x8>>::Output

fn _hypot(self, rhs: u16x8) -> <f32 as FloatOutBinary<u16x8>>::Output

impl FloatOutBinary<u16x8> for f64

type Output = <f64x2 as FloatOutBinaryPromote<u16x8>>::Output

fn _div(self, rhs: u16x8) -> <f64 as FloatOutBinary<u16x8>>::Output

fn _log(self, base: u16x8) -> <f64 as FloatOutBinary<u16x8>>::Output

fn _hypot(self, rhs: u16x8) -> <f64 as FloatOutBinary<u16x8>>::Output

impl FloatOutBinary<u16x8> for i8

type Output = <i8x16 as FloatOutBinaryPromote<u16x8>>::Output

fn _div(self, rhs: u16x8) -> <i8 as FloatOutBinary<u16x8>>::Output

fn _log(self, base: u16x8) -> <i8 as FloatOutBinary<u16x8>>::Output

fn _hypot(self, rhs: u16x8) -> <i8 as FloatOutBinary<u16x8>>::Output

impl FloatOutBinary<u16x8> for i16

type Output = <i16x8 as FloatOutBinaryPromote<u16x8>>::Output

fn _div(self, rhs: u16x8) -> <i16 as FloatOutBinary<u16x8>>::Output

fn _log(self, base: u16x8) -> <i16 as FloatOutBinary<u16x8>>::Output

fn _hypot(self, rhs: u16x8) -> <i16 as FloatOutBinary<u16x8>>::Output

impl FloatOutBinary<u16x8> for i32

type Output = <i32x4 as FloatOutBinaryPromote<u16x8>>::Output

fn _div(self, rhs: u16x8) -> <i32 as FloatOutBinary<u16x8>>::Output

fn _log(self, base: u16x8) -> <i32 as FloatOutBinary<u16x8>>::Output

fn _hypot(self, rhs: u16x8) -> <i32 as FloatOutBinary<u16x8>>::Output

impl FloatOutBinary<u16x8> for i64

type Output = <i64x2 as FloatOutBinaryPromote<u16x8>>::Output

fn _div(self, rhs: u16x8) -> <i64 as FloatOutBinary<u16x8>>::Output

fn _log(self, base: u16x8) -> <i64 as FloatOutBinary<u16x8>>::Output

fn _hypot(self, rhs: u16x8) -> <i64 as FloatOutBinary<u16x8>>::Output

impl FloatOutBinary<u16x8> for isize

type Output = <isizex2 as FloatOutBinaryPromote<u16x8>>::Output

fn _div(self, rhs: u16x8) -> <isize as FloatOutBinary<u16x8>>::Output

fn _log(self, base: u16x8) -> <isize as FloatOutBinary<u16x8>>::Output

fn _hypot(self, rhs: u16x8) -> <isize as FloatOutBinary<u16x8>>::Output

impl FloatOutBinary<u16x8> for u8

type Output = <u8x16 as FloatOutBinaryPromote<u16x8>>::Output

fn _div(self, rhs: u16x8) -> <u8 as FloatOutBinary<u16x8>>::Output

fn _log(self, base: u16x8) -> <u8 as FloatOutBinary<u16x8>>::Output

fn _hypot(self, rhs: u16x8) -> <u8 as FloatOutBinary<u16x8>>::Output

impl FloatOutBinary<u16x8> for u16

type Output = <u16x8 as FloatOutBinaryPromote>::Output

fn _div(self, rhs: u16x8) -> <u16 as FloatOutBinary<u16x8>>::Output

fn _log(self, base: u16x8) -> <u16 as FloatOutBinary<u16x8>>::Output

fn _hypot(self, rhs: u16x8) -> <u16 as FloatOutBinary<u16x8>>::Output

impl FloatOutBinary<u16x8> for u32

type Output = <u32x4 as FloatOutBinaryPromote<u16x8>>::Output

fn _div(self, rhs: u16x8) -> <u32 as FloatOutBinary<u16x8>>::Output

fn _log(self, base: u16x8) -> <u32 as FloatOutBinary<u16x8>>::Output

fn _hypot(self, rhs: u16x8) -> <u32 as FloatOutBinary<u16x8>>::Output

impl FloatOutBinary<u16x8> for u64

type Output = <u64x2 as FloatOutBinaryPromote<u16x8>>::Output

fn _div(self, rhs: u16x8) -> <u64 as FloatOutBinary<u16x8>>::Output

fn _log(self, base: u16x8) -> <u64 as FloatOutBinary<u16x8>>::Output

fn _hypot(self, rhs: u16x8) -> <u64 as FloatOutBinary<u16x8>>::Output

impl FloatOutBinary<u16x8> for usize

type Output = <usizex2 as FloatOutBinaryPromote<u16x8>>::Output

fn _div(self, rhs: u16x8) -> <usize as FloatOutBinary<u16x8>>::Output

fn _log(self, base: u16x8) -> <usize as FloatOutBinary<u16x8>>::Output

fn _hypot(self, rhs: u16x8) -> <usize as FloatOutBinary<u16x8>>::Output

impl FloatOutBinary<u16x8> for bf16

type Output = <bf16x8 as FloatOutBinaryPromote<u16x8>>::Output

fn _div(self, rhs: u16x8) -> <bf16 as FloatOutBinary<u16x8>>::Output

fn _log(self, base: u16x8) -> <bf16 as FloatOutBinary<u16x8>>::Output

fn _hypot(self, rhs: u16x8) -> <bf16 as FloatOutBinary<u16x8>>::Output

impl FloatOutBinary<u16x8> for f16

type Output = <f16x8 as FloatOutBinaryPromote<u16x8>>::Output

fn _div(self, rhs: u16x8) -> <f16 as FloatOutBinary<u16x8>>::Output

fn _log(self, base: u16x8) -> <f16 as FloatOutBinary<u16x8>>::Output

fn _hypot(self, rhs: u16x8) -> <f16 as FloatOutBinary<u16x8>>::Output

impl FloatOutBinary<u16x8> for Complex<f32>

type Output = <cplx32x2 as FloatOutBinaryPromote<u16x8>>::Output

fn _div(self, rhs: u16x8) -> <Complex<f32> as FloatOutBinary<u16x8>>::Output

fn _log(self, base: u16x8) -> <Complex<f32> as FloatOutBinary<u16x8>>::Output

fn _hypot(self, rhs: u16x8) -> <Complex<f32> as FloatOutBinary<u16x8>>::Output

impl FloatOutBinary<u16x8> for Complex<f64>

type Output = <cplx64x1 as FloatOutBinaryPromote<u16x8>>::Output

fn _div(self, rhs: u16x8) -> <Complex<f64> as FloatOutBinary<u16x8>>::Output

fn _log(self, base: u16x8) -> <Complex<f64> as FloatOutBinary<u16x8>>::Output

fn _hypot(self, rhs: u16x8) -> <Complex<f64> as FloatOutBinary<u16x8>>::Output

impl FloatOutBinary<u32x4> for bool

type Output = <boolx16 as FloatOutBinaryPromote<u32x4>>::Output

fn _div(self, rhs: u32x4) -> <bool as FloatOutBinary<u32x4>>::Output

fn _log(self, base: u32x4) -> <bool as FloatOutBinary<u32x4>>::Output

fn _hypot(self, rhs: u32x4) -> <bool as FloatOutBinary<u32x4>>::Output

impl FloatOutBinary<u32x4> for f32

type Output = <f32x4 as FloatOutBinaryPromote<u32x4>>::Output

fn _div(self, rhs: u32x4) -> <f32 as FloatOutBinary<u32x4>>::Output

fn _log(self, base: u32x4) -> <f32 as FloatOutBinary<u32x4>>::Output

fn _hypot(self, rhs: u32x4) -> <f32 as FloatOutBinary<u32x4>>::Output

impl FloatOutBinary<u32x4> for f64

type Output = <f64x2 as FloatOutBinaryPromote<u32x4>>::Output

fn _div(self, rhs: u32x4) -> <f64 as FloatOutBinary<u32x4>>::Output

fn _log(self, base: u32x4) -> <f64 as FloatOutBinary<u32x4>>::Output

fn _hypot(self, rhs: u32x4) -> <f64 as FloatOutBinary<u32x4>>::Output

impl FloatOutBinary<u32x4> for i8

type Output = <i8x16 as FloatOutBinaryPromote<u32x4>>::Output

fn _div(self, rhs: u32x4) -> <i8 as FloatOutBinary<u32x4>>::Output

fn _log(self, base: u32x4) -> <i8 as FloatOutBinary<u32x4>>::Output

fn _hypot(self, rhs: u32x4) -> <i8 as FloatOutBinary<u32x4>>::Output

impl FloatOutBinary<u32x4> for i16

type Output = <i16x8 as FloatOutBinaryPromote<u32x4>>::Output

fn _div(self, rhs: u32x4) -> <i16 as FloatOutBinary<u32x4>>::Output

fn _log(self, base: u32x4) -> <i16 as FloatOutBinary<u32x4>>::Output

fn _hypot(self, rhs: u32x4) -> <i16 as FloatOutBinary<u32x4>>::Output

impl FloatOutBinary<u32x4> for i32

type Output = <i32x4 as FloatOutBinaryPromote<u32x4>>::Output

fn _div(self, rhs: u32x4) -> <i32 as FloatOutBinary<u32x4>>::Output

fn _log(self, base: u32x4) -> <i32 as FloatOutBinary<u32x4>>::Output

fn _hypot(self, rhs: u32x4) -> <i32 as FloatOutBinary<u32x4>>::Output

impl FloatOutBinary<u32x4> for i64

type Output = <i64x2 as FloatOutBinaryPromote<u32x4>>::Output

fn _div(self, rhs: u32x4) -> <i64 as FloatOutBinary<u32x4>>::Output

fn _log(self, base: u32x4) -> <i64 as FloatOutBinary<u32x4>>::Output

fn _hypot(self, rhs: u32x4) -> <i64 as FloatOutBinary<u32x4>>::Output

impl FloatOutBinary<u32x4> for isize

type Output = <isizex2 as FloatOutBinaryPromote<u32x4>>::Output

fn _div(self, rhs: u32x4) -> <isize as FloatOutBinary<u32x4>>::Output

fn _log(self, base: u32x4) -> <isize as FloatOutBinary<u32x4>>::Output

fn _hypot(self, rhs: u32x4) -> <isize as FloatOutBinary<u32x4>>::Output

impl FloatOutBinary<u32x4> for u8

type Output = <u8x16 as FloatOutBinaryPromote<u32x4>>::Output

fn _div(self, rhs: u32x4) -> <u8 as FloatOutBinary<u32x4>>::Output

fn _log(self, base: u32x4) -> <u8 as FloatOutBinary<u32x4>>::Output

fn _hypot(self, rhs: u32x4) -> <u8 as FloatOutBinary<u32x4>>::Output

impl FloatOutBinary<u32x4> for u16

type Output = <u16x8 as FloatOutBinaryPromote<u32x4>>::Output

fn _div(self, rhs: u32x4) -> <u16 as FloatOutBinary<u32x4>>::Output

fn _log(self, base: u32x4) -> <u16 as FloatOutBinary<u32x4>>::Output

fn _hypot(self, rhs: u32x4) -> <u16 as FloatOutBinary<u32x4>>::Output

impl FloatOutBinary<u32x4> for u32

type Output = <u32x4 as FloatOutBinaryPromote>::Output

fn _div(self, rhs: u32x4) -> <u32 as FloatOutBinary<u32x4>>::Output

fn _log(self, base: u32x4) -> <u32 as FloatOutBinary<u32x4>>::Output

fn _hypot(self, rhs: u32x4) -> <u32 as FloatOutBinary<u32x4>>::Output

impl FloatOutBinary<u32x4> for u64

type Output = <u64x2 as FloatOutBinaryPromote<u32x4>>::Output

fn _div(self, rhs: u32x4) -> <u64 as FloatOutBinary<u32x4>>::Output

fn _log(self, base: u32x4) -> <u64 as FloatOutBinary<u32x4>>::Output

fn _hypot(self, rhs: u32x4) -> <u64 as FloatOutBinary<u32x4>>::Output

impl FloatOutBinary<u32x4> for usize

type Output = <usizex2 as FloatOutBinaryPromote<u32x4>>::Output

fn _div(self, rhs: u32x4) -> <usize as FloatOutBinary<u32x4>>::Output

fn _log(self, base: u32x4) -> <usize as FloatOutBinary<u32x4>>::Output

fn _hypot(self, rhs: u32x4) -> <usize as FloatOutBinary<u32x4>>::Output

impl FloatOutBinary<u32x4> for bf16

type Output = <bf16x8 as FloatOutBinaryPromote<u32x4>>::Output

fn _div(self, rhs: u32x4) -> <bf16 as FloatOutBinary<u32x4>>::Output

fn _log(self, base: u32x4) -> <bf16 as FloatOutBinary<u32x4>>::Output

fn _hypot(self, rhs: u32x4) -> <bf16 as FloatOutBinary<u32x4>>::Output

impl FloatOutBinary<u32x4> for f16

type Output = <f16x8 as FloatOutBinaryPromote<u32x4>>::Output

fn _div(self, rhs: u32x4) -> <f16 as FloatOutBinary<u32x4>>::Output

fn _log(self, base: u32x4) -> <f16 as FloatOutBinary<u32x4>>::Output

fn _hypot(self, rhs: u32x4) -> <f16 as FloatOutBinary<u32x4>>::Output

impl FloatOutBinary<u32x4> for Complex<f32>

type Output = <cplx32x2 as FloatOutBinaryPromote<u32x4>>::Output

fn _div(self, rhs: u32x4) -> <Complex<f32> as FloatOutBinary<u32x4>>::Output

fn _log(self, base: u32x4) -> <Complex<f32> as FloatOutBinary<u32x4>>::Output

fn _hypot(self, rhs: u32x4) -> <Complex<f32> as FloatOutBinary<u32x4>>::Output

impl FloatOutBinary<u32x4> for Complex<f64>

type Output = <cplx64x1 as FloatOutBinaryPromote<u32x4>>::Output

fn _div(self, rhs: u32x4) -> <Complex<f64> as FloatOutBinary<u32x4>>::Output

fn _log(self, base: u32x4) -> <Complex<f64> as FloatOutBinary<u32x4>>::Output

fn _hypot(self, rhs: u32x4) -> <Complex<f64> as FloatOutBinary<u32x4>>::Output

impl FloatOutBinary<u64x2> for bool

type Output = <boolx16 as FloatOutBinaryPromote<u64x2>>::Output

fn _div(self, rhs: u64x2) -> <bool as FloatOutBinary<u64x2>>::Output

fn _log(self, base: u64x2) -> <bool as FloatOutBinary<u64x2>>::Output

fn _hypot(self, rhs: u64x2) -> <bool as FloatOutBinary<u64x2>>::Output

impl FloatOutBinary<u64x2> for f32

type Output = <f32x4 as FloatOutBinaryPromote<u64x2>>::Output

fn _div(self, rhs: u64x2) -> <f32 as FloatOutBinary<u64x2>>::Output

fn _log(self, base: u64x2) -> <f32 as FloatOutBinary<u64x2>>::Output

fn _hypot(self, rhs: u64x2) -> <f32 as FloatOutBinary<u64x2>>::Output

impl FloatOutBinary<u64x2> for f64

type Output = <f64x2 as FloatOutBinaryPromote<u64x2>>::Output

fn _div(self, rhs: u64x2) -> <f64 as FloatOutBinary<u64x2>>::Output

fn _log(self, base: u64x2) -> <f64 as FloatOutBinary<u64x2>>::Output

fn _hypot(self, rhs: u64x2) -> <f64 as FloatOutBinary<u64x2>>::Output

impl FloatOutBinary<u64x2> for i8

type Output = <i8x16 as FloatOutBinaryPromote<u64x2>>::Output

fn _div(self, rhs: u64x2) -> <i8 as FloatOutBinary<u64x2>>::Output

fn _log(self, base: u64x2) -> <i8 as FloatOutBinary<u64x2>>::Output

fn _hypot(self, rhs: u64x2) -> <i8 as FloatOutBinary<u64x2>>::Output

impl FloatOutBinary<u64x2> for i16

type Output = <i16x8 as FloatOutBinaryPromote<u64x2>>::Output

fn _div(self, rhs: u64x2) -> <i16 as FloatOutBinary<u64x2>>::Output

fn _log(self, base: u64x2) -> <i16 as FloatOutBinary<u64x2>>::Output

fn _hypot(self, rhs: u64x2) -> <i16 as FloatOutBinary<u64x2>>::Output

impl FloatOutBinary<u64x2> for i32

type Output = <i32x4 as FloatOutBinaryPromote<u64x2>>::Output

fn _div(self, rhs: u64x2) -> <i32 as FloatOutBinary<u64x2>>::Output

fn _log(self, base: u64x2) -> <i32 as FloatOutBinary<u64x2>>::Output

fn _hypot(self, rhs: u64x2) -> <i32 as FloatOutBinary<u64x2>>::Output

impl FloatOutBinary<u64x2> for i64

type Output = <i64x2 as FloatOutBinaryPromote<u64x2>>::Output

fn _div(self, rhs: u64x2) -> <i64 as FloatOutBinary<u64x2>>::Output

fn _log(self, base: u64x2) -> <i64 as FloatOutBinary<u64x2>>::Output

fn _hypot(self, rhs: u64x2) -> <i64 as FloatOutBinary<u64x2>>::Output

impl FloatOutBinary<u64x2> for isize

type Output = <isizex2 as FloatOutBinaryPromote<u64x2>>::Output

fn _div(self, rhs: u64x2) -> <isize as FloatOutBinary<u64x2>>::Output

fn _log(self, base: u64x2) -> <isize as FloatOutBinary<u64x2>>::Output

fn _hypot(self, rhs: u64x2) -> <isize as FloatOutBinary<u64x2>>::Output

impl FloatOutBinary<u64x2> for u8

type Output = <u8x16 as FloatOutBinaryPromote<u64x2>>::Output

fn _div(self, rhs: u64x2) -> <u8 as FloatOutBinary<u64x2>>::Output

fn _log(self, base: u64x2) -> <u8 as FloatOutBinary<u64x2>>::Output

fn _hypot(self, rhs: u64x2) -> <u8 as FloatOutBinary<u64x2>>::Output

impl FloatOutBinary<u64x2> for u16

type Output = <u16x8 as FloatOutBinaryPromote<u64x2>>::Output

fn _div(self, rhs: u64x2) -> <u16 as FloatOutBinary<u64x2>>::Output

fn _log(self, base: u64x2) -> <u16 as FloatOutBinary<u64x2>>::Output

fn _hypot(self, rhs: u64x2) -> <u16 as FloatOutBinary<u64x2>>::Output

impl FloatOutBinary<u64x2> for u32

type Output = <u32x4 as FloatOutBinaryPromote<u64x2>>::Output

fn _div(self, rhs: u64x2) -> <u32 as FloatOutBinary<u64x2>>::Output

fn _log(self, base: u64x2) -> <u32 as FloatOutBinary<u64x2>>::Output

fn _hypot(self, rhs: u64x2) -> <u32 as FloatOutBinary<u64x2>>::Output

impl FloatOutBinary<u64x2> for u64

type Output = <u64x2 as FloatOutBinaryPromote>::Output

fn _div(self, rhs: u64x2) -> <u64 as FloatOutBinary<u64x2>>::Output

fn _log(self, base: u64x2) -> <u64 as FloatOutBinary<u64x2>>::Output

fn _hypot(self, rhs: u64x2) -> <u64 as FloatOutBinary<u64x2>>::Output

impl FloatOutBinary<u64x2> for usize

type Output = <usizex2 as FloatOutBinaryPromote<u64x2>>::Output

fn _div(self, rhs: u64x2) -> <usize as FloatOutBinary<u64x2>>::Output

fn _log(self, base: u64x2) -> <usize as FloatOutBinary<u64x2>>::Output

fn _hypot(self, rhs: u64x2) -> <usize as FloatOutBinary<u64x2>>::Output

impl FloatOutBinary<u64x2> for bf16

type Output = <bf16x8 as FloatOutBinaryPromote<u64x2>>::Output

fn _div(self, rhs: u64x2) -> <bf16 as FloatOutBinary<u64x2>>::Output

fn _log(self, base: u64x2) -> <bf16 as FloatOutBinary<u64x2>>::Output

fn _hypot(self, rhs: u64x2) -> <bf16 as FloatOutBinary<u64x2>>::Output

impl FloatOutBinary<u64x2> for f16

type Output = <f16x8 as FloatOutBinaryPromote<u64x2>>::Output

fn _div(self, rhs: u64x2) -> <f16 as FloatOutBinary<u64x2>>::Output

fn _log(self, base: u64x2) -> <f16 as FloatOutBinary<u64x2>>::Output

fn _hypot(self, rhs: u64x2) -> <f16 as FloatOutBinary<u64x2>>::Output

impl FloatOutBinary<u64x2> for Complex<f32>

type Output = <cplx32x2 as FloatOutBinaryPromote<u64x2>>::Output

fn _div(self, rhs: u64x2) -> <Complex<f32> as FloatOutBinary<u64x2>>::Output

fn _log(self, base: u64x2) -> <Complex<f32> as FloatOutBinary<u64x2>>::Output

fn _hypot(self, rhs: u64x2) -> <Complex<f32> as FloatOutBinary<u64x2>>::Output

impl FloatOutBinary<u64x2> for Complex<f64>

type Output = <cplx64x1 as FloatOutBinaryPromote<u64x2>>::Output

fn _div(self, rhs: u64x2) -> <Complex<f64> as FloatOutBinary<u64x2>>::Output

fn _log(self, base: u64x2) -> <Complex<f64> as FloatOutBinary<u64x2>>::Output

fn _hypot(self, rhs: u64x2) -> <Complex<f64> as FloatOutBinary<u64x2>>::Output

impl FloatOutBinary<usizex2> for bool

type Output = <boolx16 as FloatOutBinaryPromote<usizex2>>::Output

fn _div(self, rhs: usizex2) -> <bool as FloatOutBinary<usizex2>>::Output

fn _log(self, base: usizex2) -> <bool as FloatOutBinary<usizex2>>::Output

fn _hypot(self, rhs: usizex2) -> <bool as FloatOutBinary<usizex2>>::Output

impl FloatOutBinary<usizex2> for f32

type Output = <f32x4 as FloatOutBinaryPromote<usizex2>>::Output

fn _div(self, rhs: usizex2) -> <f32 as FloatOutBinary<usizex2>>::Output

fn _log(self, base: usizex2) -> <f32 as FloatOutBinary<usizex2>>::Output

fn _hypot(self, rhs: usizex2) -> <f32 as FloatOutBinary<usizex2>>::Output

impl FloatOutBinary<usizex2> for f64

type Output = <f64x2 as FloatOutBinaryPromote<usizex2>>::Output

fn _div(self, rhs: usizex2) -> <f64 as FloatOutBinary<usizex2>>::Output

fn _log(self, base: usizex2) -> <f64 as FloatOutBinary<usizex2>>::Output

fn _hypot(self, rhs: usizex2) -> <f64 as FloatOutBinary<usizex2>>::Output

impl FloatOutBinary<usizex2> for i8

type Output = <i8x16 as FloatOutBinaryPromote<usizex2>>::Output

fn _div(self, rhs: usizex2) -> <i8 as FloatOutBinary<usizex2>>::Output

fn _log(self, base: usizex2) -> <i8 as FloatOutBinary<usizex2>>::Output

fn _hypot(self, rhs: usizex2) -> <i8 as FloatOutBinary<usizex2>>::Output

impl FloatOutBinary<usizex2> for i16

type Output = <i16x8 as FloatOutBinaryPromote<usizex2>>::Output

fn _div(self, rhs: usizex2) -> <i16 as FloatOutBinary<usizex2>>::Output

fn _log(self, base: usizex2) -> <i16 as FloatOutBinary<usizex2>>::Output

fn _hypot(self, rhs: usizex2) -> <i16 as FloatOutBinary<usizex2>>::Output

impl FloatOutBinary<usizex2> for i32

type Output = <i32x4 as FloatOutBinaryPromote<usizex2>>::Output

fn _div(self, rhs: usizex2) -> <i32 as FloatOutBinary<usizex2>>::Output

fn _log(self, base: usizex2) -> <i32 as FloatOutBinary<usizex2>>::Output

fn _hypot(self, rhs: usizex2) -> <i32 as FloatOutBinary<usizex2>>::Output

impl FloatOutBinary<usizex2> for i64

type Output = <i64x2 as FloatOutBinaryPromote<usizex2>>::Output

fn _div(self, rhs: usizex2) -> <i64 as FloatOutBinary<usizex2>>::Output

fn _log(self, base: usizex2) -> <i64 as FloatOutBinary<usizex2>>::Output

fn _hypot(self, rhs: usizex2) -> <i64 as FloatOutBinary<usizex2>>::Output

impl FloatOutBinary<usizex2> for isize

type Output = <isizex2 as FloatOutBinaryPromote<usizex2>>::Output

fn _div(self, rhs: usizex2) -> <isize as FloatOutBinary<usizex2>>::Output

fn _log(self, base: usizex2) -> <isize as FloatOutBinary<usizex2>>::Output

fn _hypot(self, rhs: usizex2) -> <isize as FloatOutBinary<usizex2>>::Output

impl FloatOutBinary<usizex2> for u8

type Output = <u8x16 as FloatOutBinaryPromote<usizex2>>::Output

fn _div(self, rhs: usizex2) -> <u8 as FloatOutBinary<usizex2>>::Output

fn _log(self, base: usizex2) -> <u8 as FloatOutBinary<usizex2>>::Output

fn _hypot(self, rhs: usizex2) -> <u8 as FloatOutBinary<usizex2>>::Output

impl FloatOutBinary<usizex2> for u16

type Output = <u16x8 as FloatOutBinaryPromote<usizex2>>::Output

fn _div(self, rhs: usizex2) -> <u16 as FloatOutBinary<usizex2>>::Output

fn _log(self, base: usizex2) -> <u16 as FloatOutBinary<usizex2>>::Output

fn _hypot(self, rhs: usizex2) -> <u16 as FloatOutBinary<usizex2>>::Output

impl FloatOutBinary<usizex2> for u32

type Output = <u32x4 as FloatOutBinaryPromote<usizex2>>::Output

fn _div(self, rhs: usizex2) -> <u32 as FloatOutBinary<usizex2>>::Output

fn _log(self, base: usizex2) -> <u32 as FloatOutBinary<usizex2>>::Output

fn _hypot(self, rhs: usizex2) -> <u32 as FloatOutBinary<usizex2>>::Output

impl FloatOutBinary<usizex2> for u64

type Output = <u64x2 as FloatOutBinaryPromote<usizex2>>::Output

fn _div(self, rhs: usizex2) -> <u64 as FloatOutBinary<usizex2>>::Output

fn _log(self, base: usizex2) -> <u64 as FloatOutBinary<usizex2>>::Output

fn _hypot(self, rhs: usizex2) -> <u64 as FloatOutBinary<usizex2>>::Output

impl FloatOutBinary<usizex2> for usize

type Output = <usizex2 as FloatOutBinaryPromote>::Output

fn _div(self, rhs: usizex2) -> <usize as FloatOutBinary<usizex2>>::Output

fn _log(self, base: usizex2) -> <usize as FloatOutBinary<usizex2>>::Output

fn _hypot(self, rhs: usizex2) -> <usize as FloatOutBinary<usizex2>>::Output

impl FloatOutBinary<usizex2> for bf16

type Output = <bf16x8 as FloatOutBinaryPromote<usizex2>>::Output

fn _div(self, rhs: usizex2) -> <bf16 as FloatOutBinary<usizex2>>::Output

fn _log(self, base: usizex2) -> <bf16 as FloatOutBinary<usizex2>>::Output

fn _hypot(self, rhs: usizex2) -> <bf16 as FloatOutBinary<usizex2>>::Output

impl FloatOutBinary<usizex2> for f16

type Output = <f16x8 as FloatOutBinaryPromote<usizex2>>::Output

fn _div(self, rhs: usizex2) -> <f16 as FloatOutBinary<usizex2>>::Output

fn _log(self, base: usizex2) -> <f16 as FloatOutBinary<usizex2>>::Output

fn _hypot(self, rhs: usizex2) -> <f16 as FloatOutBinary<usizex2>>::Output

impl FloatOutBinary<usizex2> for Complex<f32>

type Output = <cplx32x2 as FloatOutBinaryPromote<usizex2>>::Output

fn _div(self, rhs: usizex2) -> <Complex<f32> as FloatOutBinary<usizex2>>::Output

fn _log( self, base: usizex2, ) -> <Complex<f32> as FloatOutBinary<usizex2>>::Output

fn _hypot( self, rhs: usizex2, ) -> <Complex<f32> as FloatOutBinary<usizex2>>::Output

impl FloatOutBinary<usizex2> for Complex<f64>

type Output = <cplx64x1 as FloatOutBinaryPromote<usizex2>>::Output

fn _div(self, rhs: usizex2) -> <Complex<f64> as FloatOutBinary<usizex2>>::Output

fn _log( self, base: usizex2, ) -> <Complex<f64> as FloatOutBinary<usizex2>>::Output

fn _hypot( self, rhs: usizex2, ) -> <Complex<f64> as FloatOutBinary<usizex2>>::Output

impl FloatOutBinary<bf16> for bool

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

fn _div(self, rhs: bf16) -> <bool as FloatOutBinary<bf16>>::Output

fn _log(self, base: bf16) -> <bool as FloatOutBinary<bf16>>::Output

fn _hypot(self, rhs: bf16) -> <bool as FloatOutBinary<bf16>>::Output

impl FloatOutBinary<bf16> for f32

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

fn _div(self, rhs: bf16) -> <f32 as FloatOutBinary<bf16>>::Output

fn _log(self, base: bf16) -> <f32 as FloatOutBinary<bf16>>::Output

fn _hypot(self, rhs: bf16) -> <f32 as FloatOutBinary<bf16>>::Output

impl FloatOutBinary<bf16> for f64

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

fn _div(self, rhs: bf16) -> <f64 as FloatOutBinary<bf16>>::Output

fn _log(self, base: bf16) -> <f64 as FloatOutBinary<bf16>>::Output

fn _hypot(self, rhs: bf16) -> <f64 as FloatOutBinary<bf16>>::Output

impl FloatOutBinary<bf16> for i8

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

fn _div(self, rhs: bf16) -> <i8 as FloatOutBinary<bf16>>::Output

fn _log(self, base: bf16) -> <i8 as FloatOutBinary<bf16>>::Output

fn _hypot(self, rhs: bf16) -> <i8 as FloatOutBinary<bf16>>::Output

impl FloatOutBinary<bf16> for i16

type Output = <i16 as FloatOutBinaryPromote<bf16>>::Output

fn _div(self, rhs: bf16) -> <i16 as FloatOutBinary<bf16>>::Output

fn _log(self, base: bf16) -> <i16 as FloatOutBinary<bf16>>::Output

fn _hypot(self, rhs: bf16) -> <i16 as FloatOutBinary<bf16>>::Output

impl FloatOutBinary<bf16> for i32

type Output = <i32 as FloatOutBinaryPromote<bf16>>::Output

fn _div(self, rhs: bf16) -> <i32 as FloatOutBinary<bf16>>::Output

fn _log(self, base: bf16) -> <i32 as FloatOutBinary<bf16>>::Output

fn _hypot(self, rhs: bf16) -> <i32 as FloatOutBinary<bf16>>::Output

impl FloatOutBinary<bf16> for i64

type Output = <i64 as FloatOutBinaryPromote<bf16>>::Output

fn _div(self, rhs: bf16) -> <i64 as FloatOutBinary<bf16>>::Output

fn _log(self, base: bf16) -> <i64 as FloatOutBinary<bf16>>::Output

fn _hypot(self, rhs: bf16) -> <i64 as FloatOutBinary<bf16>>::Output

impl FloatOutBinary<bf16> for isize

type Output = <isize as FloatOutBinaryPromote<bf16>>::Output

fn _div(self, rhs: bf16) -> <isize as FloatOutBinary<bf16>>::Output

fn _log(self, base: bf16) -> <isize as FloatOutBinary<bf16>>::Output

fn _hypot(self, rhs: bf16) -> <isize as FloatOutBinary<bf16>>::Output

impl FloatOutBinary<bf16> for u8

type Output = <u8 as FloatOutBinaryPromote<bf16>>::Output

fn _div(self, rhs: bf16) -> <u8 as FloatOutBinary<bf16>>::Output

fn _log(self, base: bf16) -> <u8 as FloatOutBinary<bf16>>::Output

fn _hypot(self, rhs: bf16) -> <u8 as FloatOutBinary<bf16>>::Output

impl FloatOutBinary<bf16> for u16

type Output = <u16 as FloatOutBinaryPromote<bf16>>::Output

fn _div(self, rhs: bf16) -> <u16 as FloatOutBinary<bf16>>::Output

fn _log(self, base: bf16) -> <u16 as FloatOutBinary<bf16>>::Output

fn _hypot(self, rhs: bf16) -> <u16 as FloatOutBinary<bf16>>::Output

impl FloatOutBinary<bf16> for u32

type Output = <u32 as FloatOutBinaryPromote<bf16>>::Output

fn _div(self, rhs: bf16) -> <u32 as FloatOutBinary<bf16>>::Output

fn _log(self, base: bf16) -> <u32 as FloatOutBinary<bf16>>::Output

fn _hypot(self, rhs: bf16) -> <u32 as FloatOutBinary<bf16>>::Output

impl FloatOutBinary<bf16> for u64

type Output = <u64 as FloatOutBinaryPromote<bf16>>::Output

fn _div(self, rhs: bf16) -> <u64 as FloatOutBinary<bf16>>::Output

fn _log(self, base: bf16) -> <u64 as FloatOutBinary<bf16>>::Output

fn _hypot(self, rhs: bf16) -> <u64 as FloatOutBinary<bf16>>::Output

impl FloatOutBinary<bf16> for usize

type Output = <usize as FloatOutBinaryPromote<bf16>>::Output

fn _div(self, rhs: bf16) -> <usize as FloatOutBinary<bf16>>::Output

fn _log(self, base: bf16) -> <usize as FloatOutBinary<bf16>>::Output

fn _hypot(self, rhs: bf16) -> <usize as FloatOutBinary<bf16>>::Output

impl FloatOutBinary<bf16> for f16

type Output = <f16 as FloatOutBinaryPromote<bf16>>::Output

fn _div(self, rhs: bf16) -> <f16 as FloatOutBinary<bf16>>::Output

fn _log(self, base: bf16) -> <f16 as FloatOutBinary<bf16>>::Output

fn _hypot(self, rhs: bf16) -> <f16 as FloatOutBinary<bf16>>::Output

impl FloatOutBinary<bf16> for Complex<f32>

type Output = <Complex<f32> as FloatOutBinaryPromote<bf16>>::Output

fn _div(self, rhs: bf16) -> <Complex<f32> as FloatOutBinary<bf16>>::Output

fn _log(self, base: bf16) -> <Complex<f32> as FloatOutBinary<bf16>>::Output

fn _hypot(self, rhs: bf16) -> <Complex<f32> as FloatOutBinary<bf16>>::Output

impl FloatOutBinary<bf16> for Complex<f64>

type Output = <Complex<f64> as FloatOutBinaryPromote<bf16>>::Output

fn _div(self, rhs: bf16) -> <Complex<f64> as FloatOutBinary<bf16>>::Output

fn _log(self, base: bf16) -> <Complex<f64> as FloatOutBinary<bf16>>::Output

fn _hypot(self, rhs: bf16) -> <Complex<f64> as FloatOutBinary<bf16>>::Output

impl FloatOutBinary<f16> for bool

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

fn _div(self, rhs: f16) -> <bool as FloatOutBinary<f16>>::Output

fn _log(self, base: f16) -> <bool as FloatOutBinary<f16>>::Output

fn _hypot(self, rhs: f16) -> <bool as FloatOutBinary<f16>>::Output

impl FloatOutBinary<f16> for f32

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

fn _div(self, rhs: f16) -> <f32 as FloatOutBinary<f16>>::Output

fn _log(self, base: f16) -> <f32 as FloatOutBinary<f16>>::Output

fn _hypot(self, rhs: f16) -> <f32 as FloatOutBinary<f16>>::Output

impl FloatOutBinary<f16> for f64

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

fn _div(self, rhs: f16) -> <f64 as FloatOutBinary<f16>>::Output

fn _log(self, base: f16) -> <f64 as FloatOutBinary<f16>>::Output

fn _hypot(self, rhs: f16) -> <f64 as FloatOutBinary<f16>>::Output

impl FloatOutBinary<f16> for i8

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

fn _div(self, rhs: f16) -> <i8 as FloatOutBinary<f16>>::Output

fn _log(self, base: f16) -> <i8 as FloatOutBinary<f16>>::Output

fn _hypot(self, rhs: f16) -> <i8 as FloatOutBinary<f16>>::Output

impl FloatOutBinary<f16> for i16

type Output = <i16 as FloatOutBinaryPromote<f16>>::Output

fn _div(self, rhs: f16) -> <i16 as FloatOutBinary<f16>>::Output

fn _log(self, base: f16) -> <i16 as FloatOutBinary<f16>>::Output

fn _hypot(self, rhs: f16) -> <i16 as FloatOutBinary<f16>>::Output

impl FloatOutBinary<f16> for i32

type Output = <i32 as FloatOutBinaryPromote<f16>>::Output

fn _div(self, rhs: f16) -> <i32 as FloatOutBinary<f16>>::Output

fn _log(self, base: f16) -> <i32 as FloatOutBinary<f16>>::Output

fn _hypot(self, rhs: f16) -> <i32 as FloatOutBinary<f16>>::Output

impl FloatOutBinary<f16> for i64

type Output = <i64 as FloatOutBinaryPromote<f16>>::Output

fn _div(self, rhs: f16) -> <i64 as FloatOutBinary<f16>>::Output

fn _log(self, base: f16) -> <i64 as FloatOutBinary<f16>>::Output

fn _hypot(self, rhs: f16) -> <i64 as FloatOutBinary<f16>>::Output

impl FloatOutBinary<f16> for isize

type Output = <isize as FloatOutBinaryPromote<f16>>::Output

fn _div(self, rhs: f16) -> <isize as FloatOutBinary<f16>>::Output

fn _log(self, base: f16) -> <isize as FloatOutBinary<f16>>::Output

fn _hypot(self, rhs: f16) -> <isize as FloatOutBinary<f16>>::Output

impl FloatOutBinary<f16> for u8

type Output = <u8 as FloatOutBinaryPromote<f16>>::Output

fn _div(self, rhs: f16) -> <u8 as FloatOutBinary<f16>>::Output

fn _log(self, base: f16) -> <u8 as FloatOutBinary<f16>>::Output

fn _hypot(self, rhs: f16) -> <u8 as FloatOutBinary<f16>>::Output

impl FloatOutBinary<f16> for u16

type Output = <u16 as FloatOutBinaryPromote<f16>>::Output

fn _div(self, rhs: f16) -> <u16 as FloatOutBinary<f16>>::Output

fn _log(self, base: f16) -> <u16 as FloatOutBinary<f16>>::Output

fn _hypot(self, rhs: f16) -> <u16 as FloatOutBinary<f16>>::Output

impl FloatOutBinary<f16> for u32

type Output = <u32 as FloatOutBinaryPromote<f16>>::Output

fn _div(self, rhs: f16) -> <u32 as FloatOutBinary<f16>>::Output

fn _log(self, base: f16) -> <u32 as FloatOutBinary<f16>>::Output

fn _hypot(self, rhs: f16) -> <u32 as FloatOutBinary<f16>>::Output

impl FloatOutBinary<f16> for u64

type Output = <u64 as FloatOutBinaryPromote<f16>>::Output

fn _div(self, rhs: f16) -> <u64 as FloatOutBinary<f16>>::Output

fn _log(self, base: f16) -> <u64 as FloatOutBinary<f16>>::Output

fn _hypot(self, rhs: f16) -> <u64 as FloatOutBinary<f16>>::Output

impl FloatOutBinary<f16> for usize

type Output = <usize as FloatOutBinaryPromote<f16>>::Output

fn _div(self, rhs: f16) -> <usize as FloatOutBinary<f16>>::Output

fn _log(self, base: f16) -> <usize as FloatOutBinary<f16>>::Output

fn _hypot(self, rhs: f16) -> <usize as FloatOutBinary<f16>>::Output

impl FloatOutBinary<f16> for bf16

type Output = <bf16 as FloatOutBinaryPromote<f16>>::Output

fn _div(self, rhs: f16) -> <bf16 as FloatOutBinary<f16>>::Output

fn _log(self, base: f16) -> <bf16 as FloatOutBinary<f16>>::Output

fn _hypot(self, rhs: f16) -> <bf16 as FloatOutBinary<f16>>::Output

impl FloatOutBinary<f16> for Complex<f32>

type Output = <Complex<f32> as FloatOutBinaryPromote<f16>>::Output

fn _div(self, rhs: f16) -> <Complex<f32> as FloatOutBinary<f16>>::Output

fn _log(self, base: f16) -> <Complex<f32> as FloatOutBinary<f16>>::Output

fn _hypot(self, rhs: f16) -> <Complex<f32> as FloatOutBinary<f16>>::Output

impl FloatOutBinary<f16> for Complex<f64>

type Output = <Complex<f64> as FloatOutBinaryPromote<f16>>::Output

fn _div(self, rhs: f16) -> <Complex<f64> as FloatOutBinary<f16>>::Output

fn _log(self, base: f16) -> <Complex<f64> as FloatOutBinary<f16>>::Output

fn _hypot(self, rhs: f16) -> <Complex<f64> as FloatOutBinary<f16>>::Output

impl FloatOutBinary<Complex<f32>> for bool

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

fn _div( self, rhs: Complex<f32>, ) -> <bool as FloatOutBinary<Complex<f32>>>::Output

fn _log( self, base: Complex<f32>, ) -> <bool as FloatOutBinary<Complex<f32>>>::Output

fn _hypot( self, rhs: Complex<f32>, ) -> <bool as FloatOutBinary<Complex<f32>>>::Output

impl FloatOutBinary<Complex<f32>> for f32

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

fn _div( self, rhs: Complex<f32>, ) -> <f32 as FloatOutBinary<Complex<f32>>>::Output

fn _log( self, base: Complex<f32>, ) -> <f32 as FloatOutBinary<Complex<f32>>>::Output

fn _hypot( self, rhs: Complex<f32>, ) -> <f32 as FloatOutBinary<Complex<f32>>>::Output

impl FloatOutBinary<Complex<f32>> for f64

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

fn _div( self, rhs: Complex<f32>, ) -> <f64 as FloatOutBinary<Complex<f32>>>::Output

fn _log( self, base: Complex<f32>, ) -> <f64 as FloatOutBinary<Complex<f32>>>::Output

fn _hypot( self, rhs: Complex<f32>, ) -> <f64 as FloatOutBinary<Complex<f32>>>::Output

impl FloatOutBinary<Complex<f32>> for i8

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

fn _div(self, rhs: Complex<f32>) -> <i8 as FloatOutBinary<Complex<f32>>>::Output

fn _log( self, base: Complex<f32>, ) -> <i8 as FloatOutBinary<Complex<f32>>>::Output

fn _hypot( self, rhs: Complex<f32>, ) -> <i8 as FloatOutBinary<Complex<f32>>>::Output

impl FloatOutBinary<Complex<f32>> for i16

type Output = <i16 as FloatOutBinaryPromote<Complex<f32>>>::Output

fn _div( self, rhs: Complex<f32>, ) -> <i16 as FloatOutBinary<Complex<f32>>>::Output

fn _log( self, base: Complex<f32>, ) -> <i16 as FloatOutBinary<Complex<f32>>>::Output

fn _hypot( self, rhs: Complex<f32>, ) -> <i16 as FloatOutBinary<Complex<f32>>>::Output

impl FloatOutBinary<Complex<f32>> for i32

type Output = <i32 as FloatOutBinaryPromote<Complex<f32>>>::Output

fn _div( self, rhs: Complex<f32>, ) -> <i32 as FloatOutBinary<Complex<f32>>>::Output

fn _log( self, base: Complex<f32>, ) -> <i32 as FloatOutBinary<Complex<f32>>>::Output

fn _hypot( self, rhs: Complex<f32>, ) -> <i32 as FloatOutBinary<Complex<f32>>>::Output

impl FloatOutBinary<Complex<f32>> for i64

type Output = <i64 as FloatOutBinaryPromote<Complex<f32>>>::Output

fn _div( self, rhs: Complex<f32>, ) -> <i64 as FloatOutBinary<Complex<f32>>>::Output

fn _log( self, base: Complex<f32>, ) -> <i64 as FloatOutBinary<Complex<f32>>>::Output

fn _hypot( self, rhs: Complex<f32>, ) -> <i64 as FloatOutBinary<Complex<f32>>>::Output

impl FloatOutBinary<Complex<f32>> for isize

type Output = <isize as FloatOutBinaryPromote<Complex<f32>>>::Output

fn _div( self, rhs: Complex<f32>, ) -> <isize as FloatOutBinary<Complex<f32>>>::Output

fn _log( self, base: Complex<f32>, ) -> <isize as FloatOutBinary<Complex<f32>>>::Output

fn _hypot( self, rhs: Complex<f32>, ) -> <isize as FloatOutBinary<Complex<f32>>>::Output

impl FloatOutBinary<Complex<f32>> for u8

type Output = <u8 as FloatOutBinaryPromote<Complex<f32>>>::Output

fn _div(self, rhs: Complex<f32>) -> <u8 as FloatOutBinary<Complex<f32>>>::Output

fn _log( self, base: Complex<f32>, ) -> <u8 as FloatOutBinary<Complex<f32>>>::Output

fn _hypot( self, rhs: Complex<f32>, ) -> <u8 as FloatOutBinary<Complex<f32>>>::Output

impl FloatOutBinary<Complex<f32>> for u16

type Output = <u16 as FloatOutBinaryPromote<Complex<f32>>>::Output

fn _div( self, rhs: Complex<f32>, ) -> <u16 as FloatOutBinary<Complex<f32>>>::Output

fn _log( self, base: Complex<f32>, ) -> <u16 as FloatOutBinary<Complex<f32>>>::Output

fn _hypot( self, rhs: Complex<f32>, ) -> <u16 as FloatOutBinary<Complex<f32>>>::Output

impl FloatOutBinary<Complex<f32>> for u32

type Output = <u32 as FloatOutBinaryPromote<Complex<f32>>>::Output

fn _div( self, rhs: Complex<f32>, ) -> <u32 as FloatOutBinary<Complex<f32>>>::Output

fn _log( self, base: Complex<f32>, ) -> <u32 as FloatOutBinary<Complex<f32>>>::Output

fn _hypot( self, rhs: Complex<f32>, ) -> <u32 as FloatOutBinary<Complex<f32>>>::Output

impl FloatOutBinary<Complex<f32>> for u64

type Output = <u64 as FloatOutBinaryPromote<Complex<f32>>>::Output

fn _div( self, rhs: Complex<f32>, ) -> <u64 as FloatOutBinary<Complex<f32>>>::Output

fn _log( self, base: Complex<f32>, ) -> <u64 as FloatOutBinary<Complex<f32>>>::Output

fn _hypot( self, rhs: Complex<f32>, ) -> <u64 as FloatOutBinary<Complex<f32>>>::Output

impl FloatOutBinary<Complex<f32>> for usize

type Output = <usize as FloatOutBinaryPromote<Complex<f32>>>::Output

fn _div( self, rhs: Complex<f32>, ) -> <usize as FloatOutBinary<Complex<f32>>>::Output

fn _log( self, base: Complex<f32>, ) -> <usize as FloatOutBinary<Complex<f32>>>::Output

fn _hypot( self, rhs: Complex<f32>, ) -> <usize as FloatOutBinary<Complex<f32>>>::Output

impl FloatOutBinary<Complex<f32>> for bf16

type Output = <bf16 as FloatOutBinaryPromote<Complex<f32>>>::Output

fn _div( self, rhs: Complex<f32>, ) -> <bf16 as FloatOutBinary<Complex<f32>>>::Output

fn _log( self, base: Complex<f32>, ) -> <bf16 as FloatOutBinary<Complex<f32>>>::Output

fn _hypot( self, rhs: Complex<f32>, ) -> <bf16 as FloatOutBinary<Complex<f32>>>::Output

impl FloatOutBinary<Complex<f32>> for f16

type Output = <f16 as FloatOutBinaryPromote<Complex<f32>>>::Output

fn _div( self, rhs: Complex<f32>, ) -> <f16 as FloatOutBinary<Complex<f32>>>::Output

fn _log( self, base: Complex<f32>, ) -> <f16 as FloatOutBinary<Complex<f32>>>::Output

fn _hypot( self, rhs: Complex<f32>, ) -> <f16 as FloatOutBinary<Complex<f32>>>::Output

impl FloatOutBinary<Complex<f32>> for Complex<f64>

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

fn _div( self, rhs: Complex<f32>, ) -> <Complex<f64> as FloatOutBinary<Complex<f32>>>::Output

fn _log( self, base: Complex<f32>, ) -> <Complex<f64> as FloatOutBinary<Complex<f32>>>::Output

fn _hypot( self, rhs: Complex<f32>, ) -> <Complex<f64> as FloatOutBinary<Complex<f32>>>::Output

impl FloatOutBinary<Complex<f64>> for bool

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

fn _div( self, rhs: Complex<f64>, ) -> <bool as FloatOutBinary<Complex<f64>>>::Output

fn _log( self, base: Complex<f64>, ) -> <bool as FloatOutBinary<Complex<f64>>>::Output

fn _hypot( self, rhs: Complex<f64>, ) -> <bool as FloatOutBinary<Complex<f64>>>::Output

impl FloatOutBinary<Complex<f64>> for f32

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

fn _div( self, rhs: Complex<f64>, ) -> <f32 as FloatOutBinary<Complex<f64>>>::Output

fn _log( self, base: Complex<f64>, ) -> <f32 as FloatOutBinary<Complex<f64>>>::Output

fn _hypot( self, rhs: Complex<f64>, ) -> <f32 as FloatOutBinary<Complex<f64>>>::Output

impl FloatOutBinary<Complex<f64>> for f64

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

fn _div( self, rhs: Complex<f64>, ) -> <f64 as FloatOutBinary<Complex<f64>>>::Output

fn _log( self, base: Complex<f64>, ) -> <f64 as FloatOutBinary<Complex<f64>>>::Output

fn _hypot( self, rhs: Complex<f64>, ) -> <f64 as FloatOutBinary<Complex<f64>>>::Output

impl FloatOutBinary<Complex<f64>> for i8

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

fn _div(self, rhs: Complex<f64>) -> <i8 as FloatOutBinary<Complex<f64>>>::Output

fn _log( self, base: Complex<f64>, ) -> <i8 as FloatOutBinary<Complex<f64>>>::Output

fn _hypot( self, rhs: Complex<f64>, ) -> <i8 as FloatOutBinary<Complex<f64>>>::Output

impl FloatOutBinary<Complex<f64>> for i16

type Output = <i16 as FloatOutBinaryPromote<Complex<f64>>>::Output

fn _div( self, rhs: Complex<f64>, ) -> <i16 as FloatOutBinary<Complex<f64>>>::Output

fn _log( self, base: Complex<f64>, ) -> <i16 as FloatOutBinary<Complex<f64>>>::Output

fn _hypot( self, rhs: Complex<f64>, ) -> <i16 as FloatOutBinary<Complex<f64>>>::Output

impl FloatOutBinary<Complex<f64>> for i32

type Output = <i32 as FloatOutBinaryPromote<Complex<f64>>>::Output

fn _div( self, rhs: Complex<f64>, ) -> <i32 as FloatOutBinary<Complex<f64>>>::Output

fn _log( self, base: Complex<f64>, ) -> <i32 as FloatOutBinary<Complex<f64>>>::Output

fn _hypot( self, rhs: Complex<f64>, ) -> <i32 as FloatOutBinary<Complex<f64>>>::Output

impl FloatOutBinary<Complex<f64>> for i64

type Output = <i64 as FloatOutBinaryPromote<Complex<f64>>>::Output

fn _div( self, rhs: Complex<f64>, ) -> <i64 as FloatOutBinary<Complex<f64>>>::Output

fn _log( self, base: Complex<f64>, ) -> <i64 as FloatOutBinary<Complex<f64>>>::Output

fn _hypot( self, rhs: Complex<f64>, ) -> <i64 as FloatOutBinary<Complex<f64>>>::Output

impl FloatOutBinary<Complex<f64>> for isize

type Output = <isize as FloatOutBinaryPromote<Complex<f64>>>::Output

fn _div( self, rhs: Complex<f64>, ) -> <isize as FloatOutBinary<Complex<f64>>>::Output

fn _log( self, base: Complex<f64>, ) -> <isize as FloatOutBinary<Complex<f64>>>::Output

fn _hypot( self, rhs: Complex<f64>, ) -> <isize as FloatOutBinary<Complex<f64>>>::Output

impl FloatOutBinary<Complex<f64>> for u8

type Output = <u8 as FloatOutBinaryPromote<Complex<f64>>>::Output

fn _div(self, rhs: Complex<f64>) -> <u8 as FloatOutBinary<Complex<f64>>>::Output

fn _log( self, base: Complex<f64>, ) -> <u8 as FloatOutBinary<Complex<f64>>>::Output

fn _hypot( self, rhs: Complex<f64>, ) -> <u8 as FloatOutBinary<Complex<f64>>>::Output

impl FloatOutBinary<Complex<f64>> for u16

type Output = <u16 as FloatOutBinaryPromote<Complex<f64>>>::Output

fn _div( self, rhs: Complex<f64>, ) -> <u16 as FloatOutBinary<Complex<f64>>>::Output

fn _log( self, base: Complex<f64>, ) -> <u16 as FloatOutBinary<Complex<f64>>>::Output

fn _hypot( self, rhs: Complex<f64>, ) -> <u16 as FloatOutBinary<Complex<f64>>>::Output

impl FloatOutBinary<Complex<f64>> for u32

type Output = <u32 as FloatOutBinaryPromote<Complex<f64>>>::Output

fn _div( self, rhs: Complex<f64>, ) -> <u32 as FloatOutBinary<Complex<f64>>>::Output

fn _log( self, base: Complex<f64>, ) -> <u32 as FloatOutBinary<Complex<f64>>>::Output

fn _hypot( self, rhs: Complex<f64>, ) -> <u32 as FloatOutBinary<Complex<f64>>>::Output

impl FloatOutBinary<Complex<f64>> for u64

type Output = <u64 as FloatOutBinaryPromote<Complex<f64>>>::Output

fn _div( self, rhs: Complex<f64>, ) -> <u64 as FloatOutBinary<Complex<f64>>>::Output

fn _log( self, base: Complex<f64>, ) -> <u64 as FloatOutBinary<Complex<f64>>>::Output

fn _hypot( self, rhs: Complex<f64>, ) -> <u64 as FloatOutBinary<Complex<f64>>>::Output

impl FloatOutBinary<Complex<f64>> for usize

type Output = <usize as FloatOutBinaryPromote<Complex<f64>>>::Output

fn _div( self, rhs: Complex<f64>, ) -> <usize as FloatOutBinary<Complex<f64>>>::Output

fn _log( self, base: Complex<f64>, ) -> <usize as FloatOutBinary<Complex<f64>>>::Output

fn _hypot( self, rhs: Complex<f64>, ) -> <usize as FloatOutBinary<Complex<f64>>>::Output

impl FloatOutBinary<Complex<f64>> for bf16

type Output = <bf16 as FloatOutBinaryPromote<Complex<f64>>>::Output

fn _div( self, rhs: Complex<f64>, ) -> <bf16 as FloatOutBinary<Complex<f64>>>::Output

fn _log( self, base: Complex<f64>, ) -> <bf16 as FloatOutBinary<Complex<f64>>>::Output

fn _hypot( self, rhs: Complex<f64>, ) -> <bf16 as FloatOutBinary<Complex<f64>>>::Output

impl FloatOutBinary<Complex<f64>> for f16

type Output = <f16 as FloatOutBinaryPromote<Complex<f64>>>::Output

fn _div( self, rhs: Complex<f64>, ) -> <f16 as FloatOutBinary<Complex<f64>>>::Output

fn _log( self, base: Complex<f64>, ) -> <f16 as FloatOutBinary<Complex<f64>>>::Output

fn _hypot( self, rhs: Complex<f64>, ) -> <f16 as FloatOutBinary<Complex<f64>>>::Output

impl FloatOutBinary<Complex<f64>> for Complex<f32>

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

fn _div( self, rhs: Complex<f64>, ) -> <Complex<f32> as FloatOutBinary<Complex<f64>>>::Output

fn _log( self, base: Complex<f64>, ) -> <Complex<f32> as FloatOutBinary<Complex<f64>>>::Output

fn _hypot( self, rhs: Complex<f64>, ) -> <Complex<f32> as FloatOutBinary<Complex<f64>>>::Output

Implementors

impl FloatOutBinary for bf16x8

type Output = <bf16x8 as FloatOutBinaryPromote>::Output

impl FloatOutBinary for boolx16

type Output = <boolx16 as FloatOutBinaryPromote>::Output

impl FloatOutBinary for cplx32x2

type Output = <cplx32x2 as FloatOutBinaryPromote>::Output

impl FloatOutBinary for cplx64x1

type Output = <cplx64x1 as FloatOutBinaryPromote>::Output

impl FloatOutBinary for f16x8

type Output = <f16x8 as FloatOutBinaryPromote>::Output

impl FloatOutBinary for f32x4

type Output = <f32x4 as FloatOutBinaryPromote>::Output

impl FloatOutBinary for f64x2

type Output = <f64x2 as FloatOutBinaryPromote>::Output

impl FloatOutBinary for i8x16

type Output = <i8x16 as FloatOutBinaryPromote>::Output

impl FloatOutBinary for i16x8

type Output = <i16x8 as FloatOutBinaryPromote>::Output

impl FloatOutBinary for i32x4

type Output = <i32x4 as FloatOutBinaryPromote>::Output

impl FloatOutBinary for i64x2

type Output = <i64x2 as FloatOutBinaryPromote>::Output

impl FloatOutBinary for isizex2

type Output = <isizex2 as FloatOutBinaryPromote>::Output

impl FloatOutBinary for u8x16

type Output = <u8x16 as FloatOutBinaryPromote>::Output

impl FloatOutBinary for u16x8

type Output = <u16x8 as FloatOutBinaryPromote>::Output

impl FloatOutBinary for u32x4

type Output = <u32x4 as FloatOutBinaryPromote>::Output

impl FloatOutBinary for u64x2

type Output = <u64x2 as FloatOutBinaryPromote>::Output

impl FloatOutBinary for usizex2

type Output = <usizex2 as FloatOutBinaryPromote>::Output

impl FloatOutBinary<bool> for bf16x8

type Output = <bf16x8 as FloatOutBinaryPromote<boolx16>>::Output

impl FloatOutBinary<bool> for boolx16

type Output = <boolx16 as FloatOutBinaryPromote>::Output

impl FloatOutBinary<bool> for cplx32x2

type Output = <cplx32x2 as FloatOutBinaryPromote<boolx16>>::Output

impl FloatOutBinary<bool> for cplx64x1

type Output = <cplx64x1 as FloatOutBinaryPromote<boolx16>>::Output

impl FloatOutBinary<bool> for f16x8

type Output = <f16x8 as FloatOutBinaryPromote<boolx16>>::Output

impl FloatOutBinary<bool> for f32x4

type Output = <f32x4 as FloatOutBinaryPromote<boolx16>>::Output

impl FloatOutBinary<bool> for f64x2

type Output = <f64x2 as FloatOutBinaryPromote<boolx16>>::Output

impl FloatOutBinary<bool> for i8x16

type Output = <i8x16 as FloatOutBinaryPromote<boolx16>>::Output

impl FloatOutBinary<bool> for i16x8

type Output = <i16x8 as FloatOutBinaryPromote<boolx16>>::Output

impl FloatOutBinary<bool> for i32x4

type Output = <i32x4 as FloatOutBinaryPromote<boolx16>>::Output

impl FloatOutBinary<bool> for i64x2

type Output = <i64x2 as FloatOutBinaryPromote<boolx16>>::Output

impl FloatOutBinary<bool> for isizex2

type Output = <isizex2 as FloatOutBinaryPromote<boolx16>>::Output

impl FloatOutBinary<bool> for u8x16

type Output = <u8x16 as FloatOutBinaryPromote<boolx16>>::Output

impl FloatOutBinary<bool> for u16x8

type Output = <u16x8 as FloatOutBinaryPromote<boolx16>>::Output

impl FloatOutBinary<bool> for u32x4

type Output = <u32x4 as FloatOutBinaryPromote<boolx16>>::Output

impl FloatOutBinary<bool> for u64x2

type Output = <u64x2 as FloatOutBinaryPromote<boolx16>>::Output

impl FloatOutBinary<bool> for usizex2

type Output = <usizex2 as FloatOutBinaryPromote<boolx16>>::Output

impl FloatOutBinary<f32> for bf16x8

type Output = <bf16x8 as FloatOutBinaryPromote<f32x4>>::Output

impl FloatOutBinary<f32> for boolx16

type Output = <boolx16 as FloatOutBinaryPromote<f32x4>>::Output

impl FloatOutBinary<f32> for cplx32x2

type Output = <cplx32x2 as FloatOutBinaryPromote<f32x4>>::Output

impl FloatOutBinary<f32> for cplx64x1

type Output = <cplx64x1 as FloatOutBinaryPromote<f32x4>>::Output

impl FloatOutBinary<f32> for f16x8

type Output = <f16x8 as FloatOutBinaryPromote<f32x4>>::Output

impl FloatOutBinary<f32> for f32x4

type Output = <f32x4 as FloatOutBinaryPromote>::Output

impl FloatOutBinary<f32> for f64x2

type Output = <f64x2 as FloatOutBinaryPromote<f32x4>>::Output

impl FloatOutBinary<f32> for i8x16

type Output = <i8x16 as FloatOutBinaryPromote<f32x4>>::Output

impl FloatOutBinary<f32> for i16x8

type Output = <i16x8 as FloatOutBinaryPromote<f32x4>>::Output

impl FloatOutBinary<f32> for i32x4

type Output = <i32x4 as FloatOutBinaryPromote<f32x4>>::Output

impl FloatOutBinary<f32> for i64x2

type Output = <i64x2 as FloatOutBinaryPromote<f32x4>>::Output

impl FloatOutBinary<f32> for isizex2

type Output = <isizex2 as FloatOutBinaryPromote<f32x4>>::Output

impl FloatOutBinary<f32> for u8x16

type Output = <u8x16 as FloatOutBinaryPromote<f32x4>>::Output

impl FloatOutBinary<f32> for u16x8

type Output = <u16x8 as FloatOutBinaryPromote<f32x4>>::Output

impl FloatOutBinary<f32> for u32x4

type Output = <u32x4 as FloatOutBinaryPromote<f32x4>>::Output

impl FloatOutBinary<f32> for u64x2

type Output = <u64x2 as FloatOutBinaryPromote<f32x4>>::Output

impl FloatOutBinary<f32> for usizex2

type Output = <usizex2 as FloatOutBinaryPromote<f32x4>>::Output

impl FloatOutBinary<f64> for bf16x8

type Output = <bf16x8 as FloatOutBinaryPromote<f64x2>>::Output

impl FloatOutBinary<f64> for boolx16

type Output = <boolx16 as FloatOutBinaryPromote<f64x2>>::Output

impl FloatOutBinary<f64> for cplx32x2

type Output = <cplx32x2 as FloatOutBinaryPromote<f64x2>>::Output

impl FloatOutBinary<f64> for cplx64x1

type Output = <cplx64x1 as FloatOutBinaryPromote<f64x2>>::Output

impl FloatOutBinary<f64> for f16x8

type Output = <f16x8 as FloatOutBinaryPromote<f64x2>>::Output

impl FloatOutBinary<f64> for f32x4

type Output = <f32x4 as FloatOutBinaryPromote<f64x2>>::Output

impl FloatOutBinary<f64> for f64x2

type Output = <f64x2 as FloatOutBinaryPromote>::Output

impl FloatOutBinary<f64> for i8x16

type Output = <i8x16 as FloatOutBinaryPromote<f64x2>>::Output

impl FloatOutBinary<f64> for i16x8

type Output = <i16x8 as FloatOutBinaryPromote<f64x2>>::Output

impl FloatOutBinary<f64> for i32x4

type Output = <i32x4 as FloatOutBinaryPromote<f64x2>>::Output

impl FloatOutBinary<f64> for i64x2

type Output = <i64x2 as FloatOutBinaryPromote<f64x2>>::Output

impl FloatOutBinary<f64> for isizex2

type Output = <isizex2 as FloatOutBinaryPromote<f64x2>>::Output

impl FloatOutBinary<f64> for u8x16

type Output = <u8x16 as FloatOutBinaryPromote<f64x2>>::Output

impl FloatOutBinary<f64> for u16x8

type Output = <u16x8 as FloatOutBinaryPromote<f64x2>>::Output

impl FloatOutBinary<f64> for u32x4

type Output = <u32x4 as FloatOutBinaryPromote<f64x2>>::Output

impl FloatOutBinary<f64> for u64x2

type Output = <u64x2 as FloatOutBinaryPromote<f64x2>>::Output

impl FloatOutBinary<f64> for usizex2

type Output = <usizex2 as FloatOutBinaryPromote<f64x2>>::Output

impl FloatOutBinary<i8> for bf16x8

type Output = <bf16x8 as FloatOutBinaryPromote<i8x16>>::Output

impl FloatOutBinary<i8> for boolx16

type Output = <boolx16 as FloatOutBinaryPromote<i8x16>>::Output

impl FloatOutBinary<i8> for cplx32x2

type Output = <cplx32x2 as FloatOutBinaryPromote<i8x16>>::Output

impl FloatOutBinary<i8> for cplx64x1

type Output = <cplx64x1 as FloatOutBinaryPromote<i8x16>>::Output

impl FloatOutBinary<i8> for f16x8

type Output = <f16x8 as FloatOutBinaryPromote<i8x16>>::Output

impl FloatOutBinary<i8> for f32x4

type Output = <f32x4 as FloatOutBinaryPromote<i8x16>>::Output

impl FloatOutBinary<i8> for f64x2

type Output = <f64x2 as FloatOutBinaryPromote<i8x16>>::Output

impl FloatOutBinary<i8> for i8x16

type Output = <i8x16 as FloatOutBinaryPromote>::Output

impl FloatOutBinary<i8> for i16x8

type Output = <i16x8 as FloatOutBinaryPromote<i8x16>>::Output

impl FloatOutBinary<i8> for i32x4

type Output = <i32x4 as FloatOutBinaryPromote<i8x16>>::Output

impl FloatOutBinary<i8> for i64x2

type Output = <i64x2 as FloatOutBinaryPromote<i8x16>>::Output

impl FloatOutBinary<i8> for isizex2

type Output = <isizex2 as FloatOutBinaryPromote<i8x16>>::Output

impl FloatOutBinary<i8> for u8x16

type Output = <u8x16 as FloatOutBinaryPromote<i8x16>>::Output

impl FloatOutBinary<i8> for u16x8

type Output = <u16x8 as FloatOutBinaryPromote<i8x16>>::Output

impl FloatOutBinary<i8> for u32x4

type Output = <u32x4 as FloatOutBinaryPromote<i8x16>>::Output

impl FloatOutBinary<i8> for u64x2

type Output = <u64x2 as FloatOutBinaryPromote<i8x16>>::Output

impl FloatOutBinary<i8> for usizex2

type Output = <usizex2 as FloatOutBinaryPromote<i8x16>>::Output

impl FloatOutBinary<i16> for bf16x8

type Output = <bf16x8 as FloatOutBinaryPromote<i16x8>>::Output

impl FloatOutBinary<i16> for boolx16

type Output = <boolx16 as FloatOutBinaryPromote<i16x8>>::Output

impl FloatOutBinary<i16> for cplx32x2

type Output = <cplx32x2 as FloatOutBinaryPromote<i16x8>>::Output

impl FloatOutBinary<i16> for cplx64x1

type Output = <cplx64x1 as FloatOutBinaryPromote<i16x8>>::Output

impl FloatOutBinary<i16> for f16x8

type Output = <f16x8 as FloatOutBinaryPromote<i16x8>>::Output

impl FloatOutBinary<i16> for f32x4

type Output = <f32x4 as FloatOutBinaryPromote<i16x8>>::Output

impl FloatOutBinary<i16> for f64x2

type Output = <f64x2 as FloatOutBinaryPromote<i16x8>>::Output

impl FloatOutBinary<i16> for i8x16

type Output = <i8x16 as FloatOutBinaryPromote<i16x8>>::Output

impl FloatOutBinary<i16> for i16x8

type Output = <i16x8 as FloatOutBinaryPromote>::Output

impl FloatOutBinary<i16> for i32x4

type Output = <i32x4 as FloatOutBinaryPromote<i16x8>>::Output

impl FloatOutBinary<i16> for i64x2

type Output = <i64x2 as FloatOutBinaryPromote<i16x8>>::Output

impl FloatOutBinary<i16> for isizex2

type Output = <isizex2 as FloatOutBinaryPromote<i16x8>>::Output

impl FloatOutBinary<i16> for u8x16

type Output = <u8x16 as FloatOutBinaryPromote<i16x8>>::Output

impl FloatOutBinary<i16> for u16x8

type Output = <u16x8 as FloatOutBinaryPromote<i16x8>>::Output

impl FloatOutBinary<i16> for u32x4

type Output = <u32x4 as FloatOutBinaryPromote<i16x8>>::Output

impl FloatOutBinary<i16> for u64x2

type Output = <u64x2 as FloatOutBinaryPromote<i16x8>>::Output

impl FloatOutBinary<i16> for usizex2

type Output = <usizex2 as FloatOutBinaryPromote<i16x8>>::Output

impl FloatOutBinary<i32> for bf16x8

type Output = <bf16x8 as FloatOutBinaryPromote<i32x4>>::Output

impl FloatOutBinary<i32> for boolx16

type Output = <boolx16 as FloatOutBinaryPromote<i32x4>>::Output

impl FloatOutBinary<i32> for cplx32x2

type Output = <cplx32x2 as FloatOutBinaryPromote<i32x4>>::Output

impl FloatOutBinary<i32> for cplx64x1

type Output = <cplx64x1 as FloatOutBinaryPromote<i32x4>>::Output

impl FloatOutBinary<i32> for f16x8

type Output = <f16x8 as FloatOutBinaryPromote<i32x4>>::Output

impl FloatOutBinary<i32> for f32x4

type Output = <f32x4 as FloatOutBinaryPromote<i32x4>>::Output

impl FloatOutBinary<i32> for f64x2

type Output = <f64x2 as FloatOutBinaryPromote<i32x4>>::Output

impl FloatOutBinary<i32> for i8x16

type Output = <i8x16 as FloatOutBinaryPromote<i32x4>>::Output

impl FloatOutBinary<i32> for i16x8

type Output = <i16x8 as FloatOutBinaryPromote<i32x4>>::Output

impl FloatOutBinary<i32> for i32x4

type Output = <i32x4 as FloatOutBinaryPromote>::Output

impl FloatOutBinary<i32> for i64x2

type Output = <i64x2 as FloatOutBinaryPromote<i32x4>>::Output

impl FloatOutBinary<i32> for isizex2

type Output = <isizex2 as FloatOutBinaryPromote<i32x4>>::Output

impl FloatOutBinary<i32> for u8x16

type Output = <u8x16 as FloatOutBinaryPromote<i32x4>>::Output

impl FloatOutBinary<i32> for u16x8

type Output = <u16x8 as FloatOutBinaryPromote<i32x4>>::Output

impl FloatOutBinary<i32> for u32x4

type Output = <u32x4 as FloatOutBinaryPromote<i32x4>>::Output

impl FloatOutBinary<i32> for u64x2

type Output = <u64x2 as FloatOutBinaryPromote<i32x4>>::Output

impl FloatOutBinary<i32> for usizex2

type Output = <usizex2 as FloatOutBinaryPromote<i32x4>>::Output

impl FloatOutBinary<i64> for bf16x8

type Output = <bf16x8 as FloatOutBinaryPromote<i64x2>>::Output

impl FloatOutBinary<i64> for boolx16

type Output = <boolx16 as FloatOutBinaryPromote<i64x2>>::Output

impl FloatOutBinary<i64> for cplx32x2

type Output = <cplx32x2 as FloatOutBinaryPromote<i64x2>>::Output

impl FloatOutBinary<i64> for cplx64x1

type Output = <cplx64x1 as FloatOutBinaryPromote<i64x2>>::Output

impl FloatOutBinary<i64> for f16x8

type Output = <f16x8 as FloatOutBinaryPromote<i64x2>>::Output

impl FloatOutBinary<i64> for f32x4

type Output = <f32x4 as FloatOutBinaryPromote<i64x2>>::Output

impl FloatOutBinary<i64> for f64x2

type Output = <f64x2 as FloatOutBinaryPromote<i64x2>>::Output

impl FloatOutBinary<i64> for i8x16

type Output = <i8x16 as FloatOutBinaryPromote<i64x2>>::Output

impl FloatOutBinary<i64> for i16x8

type Output = <i16x8 as FloatOutBinaryPromote<i64x2>>::Output

impl FloatOutBinary<i64> for i32x4

type Output = <i32x4 as FloatOutBinaryPromote<i64x2>>::Output

impl FloatOutBinary<i64> for i64x2

type Output = <i64x2 as FloatOutBinaryPromote>::Output

impl FloatOutBinary<i64> for isizex2

type Output = <isizex2 as FloatOutBinaryPromote<i64x2>>::Output

impl FloatOutBinary<i64> for u8x16

type Output = <u8x16 as FloatOutBinaryPromote<i64x2>>::Output

impl FloatOutBinary<i64> for u16x8

type Output = <u16x8 as FloatOutBinaryPromote<i64x2>>::Output

impl FloatOutBinary<i64> for u32x4

type Output = <u32x4 as FloatOutBinaryPromote<i64x2>>::Output

impl FloatOutBinary<i64> for u64x2

type Output = <u64x2 as FloatOutBinaryPromote<i64x2>>::Output

impl FloatOutBinary<i64> for usizex2

type Output = <usizex2 as FloatOutBinaryPromote<i64x2>>::Output

impl FloatOutBinary<isize> for bf16x8

type Output = <bf16x8 as FloatOutBinaryPromote<isizex2>>::Output

impl FloatOutBinary<isize> for boolx16

type Output = <boolx16 as FloatOutBinaryPromote<isizex2>>::Output

impl FloatOutBinary<isize> for cplx32x2

type Output = <cplx32x2 as FloatOutBinaryPromote<isizex2>>::Output

impl FloatOutBinary<isize> for cplx64x1

type Output = <cplx64x1 as FloatOutBinaryPromote<isizex2>>::Output

impl FloatOutBinary<isize> for f16x8

type Output = <f16x8 as FloatOutBinaryPromote<isizex2>>::Output

impl FloatOutBinary<isize> for f32x4

type Output = <f32x4 as FloatOutBinaryPromote<isizex2>>::Output

impl FloatOutBinary<isize> for f64x2

type Output = <f64x2 as FloatOutBinaryPromote<isizex2>>::Output

impl FloatOutBinary<isize> for i8x16

type Output = <i8x16 as FloatOutBinaryPromote<isizex2>>::Output

impl FloatOutBinary<isize> for i16x8

type Output = <i16x8 as FloatOutBinaryPromote<isizex2>>::Output

impl FloatOutBinary<isize> for i32x4

type Output = <i32x4 as FloatOutBinaryPromote<isizex2>>::Output

impl FloatOutBinary<isize> for i64x2

type Output = <i64x2 as FloatOutBinaryPromote<isizex2>>::Output

impl FloatOutBinary<isize> for isizex2

type Output = <isizex2 as FloatOutBinaryPromote>::Output

impl FloatOutBinary<isize> for u8x16

type Output = <u8x16 as FloatOutBinaryPromote<isizex2>>::Output

impl FloatOutBinary<isize> for u16x8

type Output = <u16x8 as FloatOutBinaryPromote<isizex2>>::Output

impl FloatOutBinary<isize> for u32x4

type Output = <u32x4 as FloatOutBinaryPromote<isizex2>>::Output

impl FloatOutBinary<isize> for u64x2

type Output = <u64x2 as FloatOutBinaryPromote<isizex2>>::Output

impl FloatOutBinary<isize> for usizex2

type Output = <usizex2 as FloatOutBinaryPromote<isizex2>>::Output

impl FloatOutBinary<u8> for bf16x8

type Output = <bf16x8 as FloatOutBinaryPromote<u8x16>>::Output

impl FloatOutBinary<u8> for boolx16

type Output = <boolx16 as FloatOutBinaryPromote<u8x16>>::Output

impl FloatOutBinary<u8> for cplx32x2

type Output = <cplx32x2 as FloatOutBinaryPromote<u8x16>>::Output

impl FloatOutBinary<u8> for cplx64x1

type Output = <cplx64x1 as FloatOutBinaryPromote<u8x16>>::Output

impl FloatOutBinary<u8> for f16x8

type Output = <f16x8 as FloatOutBinaryPromote<u8x16>>::Output

impl FloatOutBinary<u8> for f32x4

type Output = <f32x4 as FloatOutBinaryPromote<u8x16>>::Output

impl FloatOutBinary<u8> for f64x2

type Output = <f64x2 as FloatOutBinaryPromote<u8x16>>::Output

impl FloatOutBinary<u8> for i8x16

type Output = <i8x16 as FloatOutBinaryPromote<u8x16>>::Output

impl FloatOutBinary<u8> for i16x8

type Output = <i16x8 as FloatOutBinaryPromote<u8x16>>::Output

impl FloatOutBinary<u8> for i32x4

type Output = <i32x4 as FloatOutBinaryPromote<u8x16>>::Output

impl FloatOutBinary<u8> for i64x2

type Output = <i64x2 as FloatOutBinaryPromote<u8x16>>::Output

impl FloatOutBinary<u8> for isizex2

type Output = <isizex2 as FloatOutBinaryPromote<u8x16>>::Output

impl FloatOutBinary<u8> for u8x16

type Output = <u8x16 as FloatOutBinaryPromote>::Output

impl FloatOutBinary<u8> for u16x8

type Output = <u16x8 as FloatOutBinaryPromote<u8x16>>::Output

impl FloatOutBinary<u8> for u32x4

type Output = <u32x4 as FloatOutBinaryPromote<u8x16>>::Output

impl FloatOutBinary<u8> for u64x2

type Output = <u64x2 as FloatOutBinaryPromote<u8x16>>::Output

impl FloatOutBinary<u8> for usizex2

type Output = <usizex2 as FloatOutBinaryPromote<u8x16>>::Output

impl FloatOutBinary<u16> for bf16x8

type Output = <bf16x8 as FloatOutBinaryPromote<u16x8>>::Output

impl FloatOutBinary<u16> for boolx16

type Output = <boolx16 as FloatOutBinaryPromote<u16x8>>::Output

impl FloatOutBinary<u16> for cplx32x2

type Output = <cplx32x2 as FloatOutBinaryPromote<u16x8>>::Output

impl FloatOutBinary<u16> for cplx64x1

type Output = <cplx64x1 as FloatOutBinaryPromote<u16x8>>::Output

impl FloatOutBinary<u16> for f16x8

type Output = <f16x8 as FloatOutBinaryPromote<u16x8>>::Output

impl FloatOutBinary<u16> for f32x4

type Output = <f32x4 as FloatOutBinaryPromote<u16x8>>::Output

impl FloatOutBinary<u16> for f64x2

type Output = <f64x2 as FloatOutBinaryPromote<u16x8>>::Output

impl FloatOutBinary<u16> for i8x16

type Output = <i8x16 as FloatOutBinaryPromote<u16x8>>::Output

impl FloatOutBinary<u16> for i16x8

type Output = <i16x8 as FloatOutBinaryPromote<u16x8>>::Output

impl FloatOutBinary<u16> for i32x4

type Output = <i32x4 as FloatOutBinaryPromote<u16x8>>::Output

impl FloatOutBinary<u16> for i64x2

type Output = <i64x2 as FloatOutBinaryPromote<u16x8>>::Output

impl FloatOutBinary<u16> for isizex2

type Output = <isizex2 as FloatOutBinaryPromote<u16x8>>::Output

impl FloatOutBinary<u16> for u8x16

type Output = <u8x16 as FloatOutBinaryPromote<u16x8>>::Output

impl FloatOutBinary<u16> for u16x8

type Output = <u16x8 as FloatOutBinaryPromote>::Output

impl FloatOutBinary<u16> for u32x4

type Output = <u32x4 as FloatOutBinaryPromote<u16x8>>::Output

impl FloatOutBinary<u16> for u64x2

type Output = <u64x2 as FloatOutBinaryPromote<u16x8>>::Output

impl FloatOutBinary<u16> for usizex2

type Output = <usizex2 as FloatOutBinaryPromote<u16x8>>::Output

impl FloatOutBinary<u32> for bf16x8

type Output = <bf16x8 as FloatOutBinaryPromote<u32x4>>::Output

impl FloatOutBinary<u32> for boolx16

type Output = <boolx16 as FloatOutBinaryPromote<u32x4>>::Output

impl FloatOutBinary<u32> for cplx32x2

type Output = <cplx32x2 as FloatOutBinaryPromote<u32x4>>::Output

impl FloatOutBinary<u32> for cplx64x1

type Output = <cplx64x1 as FloatOutBinaryPromote<u32x4>>::Output

impl FloatOutBinary<u32> for f16x8

type Output = <f16x8 as FloatOutBinaryPromote<u32x4>>::Output

impl FloatOutBinary<u32> for f32x4

type Output = <f32x4 as FloatOutBinaryPromote<u32x4>>::Output

impl FloatOutBinary<u32> for f64x2

type Output = <f64x2 as FloatOutBinaryPromote<u32x4>>::Output

impl FloatOutBinary<u32> for i8x16

type Output = <i8x16 as FloatOutBinaryPromote<u32x4>>::Output

impl FloatOutBinary<u32> for i16x8

type Output = <i16x8 as FloatOutBinaryPromote<u32x4>>::Output

impl FloatOutBinary<u32> for i32x4

type Output = <i32x4 as FloatOutBinaryPromote<u32x4>>::Output

impl FloatOutBinary<u32> for i64x2

type Output = <i64x2 as FloatOutBinaryPromote<u32x4>>::Output

impl FloatOutBinary<u32> for isizex2

type Output = <isizex2 as FloatOutBinaryPromote<u32x4>>::Output

impl FloatOutBinary<u32> for u8x16

type Output = <u8x16 as FloatOutBinaryPromote<u32x4>>::Output

impl FloatOutBinary<u32> for u16x8

type Output = <u16x8 as FloatOutBinaryPromote<u32x4>>::Output

impl FloatOutBinary<u32> for u32x4

type Output = <u32x4 as FloatOutBinaryPromote>::Output

impl FloatOutBinary<u32> for u64x2

type Output = <u64x2 as FloatOutBinaryPromote<u32x4>>::Output

impl FloatOutBinary<u32> for usizex2

type Output = <usizex2 as FloatOutBinaryPromote<u32x4>>::Output

impl FloatOutBinary<u64> for bf16x8

type Output = <bf16x8 as FloatOutBinaryPromote<u64x2>>::Output

impl FloatOutBinary<u64> for boolx16

type Output = <boolx16 as FloatOutBinaryPromote<u64x2>>::Output

impl FloatOutBinary<u64> for cplx32x2

type Output = <cplx32x2 as FloatOutBinaryPromote<u64x2>>::Output

impl FloatOutBinary<u64> for cplx64x1

type Output = <cplx64x1 as FloatOutBinaryPromote<u64x2>>::Output

impl FloatOutBinary<u64> for f16x8

type Output = <f16x8 as FloatOutBinaryPromote<u64x2>>::Output

impl FloatOutBinary<u64> for f32x4

type Output = <f32x4 as FloatOutBinaryPromote<u64x2>>::Output

impl FloatOutBinary<u64> for f64x2

type Output = <f64x2 as FloatOutBinaryPromote<u64x2>>::Output

impl FloatOutBinary<u64> for i8x16

type Output = <i8x16 as FloatOutBinaryPromote<u64x2>>::Output

impl FloatOutBinary<u64> for i16x8

type Output = <i16x8 as FloatOutBinaryPromote<u64x2>>::Output

impl FloatOutBinary<u64> for i32x4

type Output = <i32x4 as FloatOutBinaryPromote<u64x2>>::Output

impl FloatOutBinary<u64> for i64x2

type Output = <i64x2 as FloatOutBinaryPromote<u64x2>>::Output

impl FloatOutBinary<u64> for isizex2

type Output = <isizex2 as FloatOutBinaryPromote<u64x2>>::Output

impl FloatOutBinary<u64> for u8x16

type Output = <u8x16 as FloatOutBinaryPromote<u64x2>>::Output

impl FloatOutBinary<u64> for u16x8

type Output = <u16x8 as FloatOutBinaryPromote<u64x2>>::Output

impl FloatOutBinary<u64> for u32x4

type Output = <u32x4 as FloatOutBinaryPromote<u64x2>>::Output

impl FloatOutBinary<u64> for u64x2

type Output = <u64x2 as FloatOutBinaryPromote>::Output

impl FloatOutBinary<u64> for usizex2

type Output = <usizex2 as FloatOutBinaryPromote<u64x2>>::Output

impl FloatOutBinary<usize> for bf16x8

type Output = <bf16x8 as FloatOutBinaryPromote<usizex2>>::Output

impl FloatOutBinary<usize> for boolx16

type Output = <boolx16 as FloatOutBinaryPromote<usizex2>>::Output

impl FloatOutBinary<usize> for cplx32x2

type Output = <cplx32x2 as FloatOutBinaryPromote<usizex2>>::Output

impl FloatOutBinary<usize> for cplx64x1

type Output = <cplx64x1 as FloatOutBinaryPromote<usizex2>>::Output

impl FloatOutBinary<usize> for f16x8

type Output = <f16x8 as FloatOutBinaryPromote<usizex2>>::Output

impl FloatOutBinary<usize> for f32x4

type Output = <f32x4 as FloatOutBinaryPromote<usizex2>>::Output

impl FloatOutBinary<usize> for f64x2

type Output = <f64x2 as FloatOutBinaryPromote<usizex2>>::Output

impl FloatOutBinary<usize> for i8x16

type Output = <i8x16 as FloatOutBinaryPromote<usizex2>>::Output

impl FloatOutBinary<usize> for i16x8

type Output = <i16x8 as FloatOutBinaryPromote<usizex2>>::Output

impl FloatOutBinary<usize> for i32x4

type Output = <i32x4 as FloatOutBinaryPromote<usizex2>>::Output

impl FloatOutBinary<usize> for i64x2

type Output = <i64x2 as FloatOutBinaryPromote<usizex2>>::Output

impl FloatOutBinary<usize> for isizex2

type Output = <isizex2 as FloatOutBinaryPromote<usizex2>>::Output

impl FloatOutBinary<usize> for u8x16

type Output = <u8x16 as FloatOutBinaryPromote<usizex2>>::Output

impl FloatOutBinary<usize> for u16x8

type Output = <u16x8 as FloatOutBinaryPromote<usizex2>>::Output

impl FloatOutBinary<usize> for u32x4

type Output = <u32x4 as FloatOutBinaryPromote<usizex2>>::Output

impl FloatOutBinary<usize> for u64x2

type Output = <u64x2 as FloatOutBinaryPromote<usizex2>>::Output

impl FloatOutBinary<usize> for usizex2

type Output = <usizex2 as FloatOutBinaryPromote>::Output

impl FloatOutBinary<bf16x8> for boolx16

type Output = <boolx16 as FloatOutBinaryPromote<bf16x8>>::Output

impl FloatOutBinary<bf16x8> for cplx32x2

type Output = <cplx32x2 as FloatOutBinaryPromote<bf16x8>>::Output

impl FloatOutBinary<bf16x8> for cplx64x1

type Output = <cplx64x1 as FloatOutBinaryPromote<bf16x8>>::Output

impl FloatOutBinary<bf16x8> for f16x8

type Output = <f16x8 as FloatOutBinaryPromote<bf16x8>>::Output

impl FloatOutBinary<bf16x8> for f32x4

type Output = <f32x4 as FloatOutBinaryPromote<bf16x8>>::Output

impl FloatOutBinary<bf16x8> for f64x2

type Output = <f64x2 as FloatOutBinaryPromote<bf16x8>>::Output

impl FloatOutBinary<bf16x8> for i8x16

type Output = <i8x16 as FloatOutBinaryPromote<bf16x8>>::Output

impl FloatOutBinary<bf16x8> for i16x8

type Output = <i16x8 as FloatOutBinaryPromote<bf16x8>>::Output

impl FloatOutBinary<bf16x8> for i32x4

type Output = <i32x4 as FloatOutBinaryPromote<bf16x8>>::Output

impl FloatOutBinary<bf16x8> for i64x2

type Output = <i64x2 as FloatOutBinaryPromote<bf16x8>>::Output

impl FloatOutBinary<bf16x8> for isizex2

type Output = <isizex2 as FloatOutBinaryPromote<bf16x8>>::Output

impl FloatOutBinary<bf16x8> for u8x16

type Output = <u8x16 as FloatOutBinaryPromote<bf16x8>>::Output

impl FloatOutBinary<bf16x8> for u16x8

type Output = <u16x8 as FloatOutBinaryPromote<bf16x8>>::Output

impl FloatOutBinary<bf16x8> for u32x4

type Output = <u32x4 as FloatOutBinaryPromote<bf16x8>>::Output

impl FloatOutBinary<bf16x8> for u64x2

type Output = <u64x2 as FloatOutBinaryPromote<bf16x8>>::Output

impl FloatOutBinary<bf16x8> for usizex2

type Output = <usizex2 as FloatOutBinaryPromote<bf16x8>>::Output

impl FloatOutBinary<boolx16> for bf16x8

type Output = <bf16x8 as FloatOutBinaryPromote<boolx16>>::Output

impl FloatOutBinary<boolx16> for cplx32x2

type Output = <cplx32x2 as FloatOutBinaryPromote<boolx16>>::Output

impl FloatOutBinary<boolx16> for cplx64x1

type Output = <cplx64x1 as FloatOutBinaryPromote<boolx16>>::Output

impl FloatOutBinary<boolx16> for f16x8

type Output = <f16x8 as FloatOutBinaryPromote<boolx16>>::Output

impl FloatOutBinary<boolx16> for f32x4

type Output = <f32x4 as FloatOutBinaryPromote<boolx16>>::Output

impl FloatOutBinary<boolx16> for f64x2

type Output = <f64x2 as FloatOutBinaryPromote<boolx16>>::Output

impl FloatOutBinary<boolx16> for i8x16

type Output = <i8x16 as FloatOutBinaryPromote<boolx16>>::Output

impl FloatOutBinary<boolx16> for i16x8

type Output = <i16x8 as FloatOutBinaryPromote<boolx16>>::Output

impl FloatOutBinary<boolx16> for i32x4

type Output = <i32x4 as FloatOutBinaryPromote<boolx16>>::Output

impl FloatOutBinary<boolx16> for i64x2

type Output = <i64x2 as FloatOutBinaryPromote<boolx16>>::Output

impl FloatOutBinary<boolx16> for isizex2

type Output = <isizex2 as FloatOutBinaryPromote<boolx16>>::Output

impl FloatOutBinary<boolx16> for u8x16

type Output = <u8x16 as FloatOutBinaryPromote<boolx16>>::Output

impl FloatOutBinary<boolx16> for u16x8

type Output = <u16x8 as FloatOutBinaryPromote<boolx16>>::Output

impl FloatOutBinary<boolx16> for u32x4

type Output = <u32x4 as FloatOutBinaryPromote<boolx16>>::Output

impl FloatOutBinary<boolx16> for u64x2

type Output = <u64x2 as FloatOutBinaryPromote<boolx16>>::Output

impl FloatOutBinary<boolx16> for usizex2

type Output = <usizex2 as FloatOutBinaryPromote<boolx16>>::Output

impl FloatOutBinary<cplx32x2> for bf16x8

type Output = <bf16x8 as FloatOutBinaryPromote<cplx32x2>>::Output

impl FloatOutBinary<cplx32x2> for boolx16

type Output = <boolx16 as FloatOutBinaryPromote<cplx32x2>>::Output

impl FloatOutBinary<cplx32x2> for cplx64x1

type Output = <cplx64x1 as FloatOutBinaryPromote<cplx32x2>>::Output

impl FloatOutBinary<cplx32x2> for f16x8

type Output = <f16x8 as FloatOutBinaryPromote<cplx32x2>>::Output

impl FloatOutBinary<cplx32x2> for f32x4

type Output = <f32x4 as FloatOutBinaryPromote<cplx32x2>>::Output

impl FloatOutBinary<cplx32x2> for f64x2

type Output = <f64x2 as FloatOutBinaryPromote<cplx32x2>>::Output

impl FloatOutBinary<cplx32x2> for i8x16

type Output = <i8x16 as FloatOutBinaryPromote<cplx32x2>>::Output

impl FloatOutBinary<cplx32x2> for i16x8

type Output = <i16x8 as FloatOutBinaryPromote<cplx32x2>>::Output

impl FloatOutBinary<cplx32x2> for i32x4

type Output = <i32x4 as FloatOutBinaryPromote<cplx32x2>>::Output

impl FloatOutBinary<cplx32x2> for i64x2

type Output = <i64x2 as FloatOutBinaryPromote<cplx32x2>>::Output

impl FloatOutBinary<cplx32x2> for isizex2

type Output = <isizex2 as FloatOutBinaryPromote<cplx32x2>>::Output

impl FloatOutBinary<cplx32x2> for u8x16

type Output = <u8x16 as FloatOutBinaryPromote<cplx32x2>>::Output

impl FloatOutBinary<cplx32x2> for u16x8

type Output = <u16x8 as FloatOutBinaryPromote<cplx32x2>>::Output

impl FloatOutBinary<cplx32x2> for u32x4

type Output = <u32x4 as FloatOutBinaryPromote<cplx32x2>>::Output

impl FloatOutBinary<cplx32x2> for u64x2

type Output = <u64x2 as FloatOutBinaryPromote<cplx32x2>>::Output

impl FloatOutBinary<cplx32x2> for usizex2

type Output = <usizex2 as FloatOutBinaryPromote<cplx32x2>>::Output

impl FloatOutBinary<cplx64x1> for bf16x8

type Output = <bf16x8 as FloatOutBinaryPromote<cplx64x1>>::Output

impl FloatOutBinary<cplx64x1> for boolx16

type Output = <boolx16 as FloatOutBinaryPromote<cplx64x1>>::Output

impl FloatOutBinary<cplx64x1> for cplx32x2

type Output = <cplx32x2 as FloatOutBinaryPromote<cplx64x1>>::Output

impl FloatOutBinary<cplx64x1> for f16x8

type Output = <f16x8 as FloatOutBinaryPromote<cplx64x1>>::Output

impl FloatOutBinary<cplx64x1> for f32x4

type Output = <f32x4 as FloatOutBinaryPromote<cplx64x1>>::Output

impl FloatOutBinary<cplx64x1> for f64x2

type Output = <f64x2 as FloatOutBinaryPromote<cplx64x1>>::Output

impl FloatOutBinary<cplx64x1> for i8x16

type Output = <i8x16 as FloatOutBinaryPromote<cplx64x1>>::Output

impl FloatOutBinary<cplx64x1> for i16x8

type Output = <i16x8 as FloatOutBinaryPromote<cplx64x1>>::Output

impl FloatOutBinary<cplx64x1> for i32x4

type Output = <i32x4 as FloatOutBinaryPromote<cplx64x1>>::Output

impl FloatOutBinary<cplx64x1> for i64x2

type Output = <i64x2 as FloatOutBinaryPromote<cplx64x1>>::Output

impl FloatOutBinary<cplx64x1> for isizex2

type Output = <isizex2 as FloatOutBinaryPromote<cplx64x1>>::Output

impl FloatOutBinary<cplx64x1> for u8x16

type Output = <u8x16 as FloatOutBinaryPromote<cplx64x1>>::Output

impl FloatOutBinary<cplx64x1> for u16x8

type Output = <u16x8 as FloatOutBinaryPromote<cplx64x1>>::Output

impl FloatOutBinary<cplx64x1> for u32x4

type Output = <u32x4 as FloatOutBinaryPromote<cplx64x1>>::Output

impl FloatOutBinary<cplx64x1> for u64x2

type Output = <u64x2 as FloatOutBinaryPromote<cplx64x1>>::Output

impl FloatOutBinary<cplx64x1> for usizex2

type Output = <usizex2 as FloatOutBinaryPromote<cplx64x1>>::Output

impl FloatOutBinary<f16x8> for bf16x8

type Output = <bf16x8 as FloatOutBinaryPromote<f16x8>>::Output

impl FloatOutBinary<f16x8> for boolx16

type Output = <boolx16 as FloatOutBinaryPromote<f16x8>>::Output

impl FloatOutBinary<f16x8> for cplx32x2

type Output = <cplx32x2 as FloatOutBinaryPromote<f16x8>>::Output

impl FloatOutBinary<f16x8> for cplx64x1

type Output = <cplx64x1 as FloatOutBinaryPromote<f16x8>>::Output

impl FloatOutBinary<f16x8> for f32x4

type Output = <f32x4 as FloatOutBinaryPromote<f16x8>>::Output

impl FloatOutBinary<f16x8> for f64x2

type Output = <f64x2 as FloatOutBinaryPromote<f16x8>>::Output

impl FloatOutBinary<f16x8> for i8x16

type Output = <i8x16 as FloatOutBinaryPromote<f16x8>>::Output

impl FloatOutBinary<f16x8> for i16x8

type Output = <i16x8 as FloatOutBinaryPromote<f16x8>>::Output

impl FloatOutBinary<f16x8> for i32x4

type Output = <i32x4 as FloatOutBinaryPromote<f16x8>>::Output

impl FloatOutBinary<f16x8> for i64x2

type Output = <i64x2 as FloatOutBinaryPromote<f16x8>>::Output

impl FloatOutBinary<f16x8> for isizex2

type Output = <isizex2 as FloatOutBinaryPromote<f16x8>>::Output

impl FloatOutBinary<f16x8> for u8x16

type Output = <u8x16 as FloatOutBinaryPromote<f16x8>>::Output

impl FloatOutBinary<f16x8> for u16x8

type Output = <u16x8 as FloatOutBinaryPromote<f16x8>>::Output

impl FloatOutBinary<f16x8> for u32x4

type Output = <u32x4 as FloatOutBinaryPromote<f16x8>>::Output

impl FloatOutBinary<f16x8> for u64x2

type Output = <u64x2 as FloatOutBinaryPromote<f16x8>>::Output

impl FloatOutBinary<f16x8> for usizex2

type Output = <usizex2 as FloatOutBinaryPromote<f16x8>>::Output

impl FloatOutBinary<f32x4> for bf16x8

type Output = <bf16x8 as FloatOutBinaryPromote<f32x4>>::Output

impl FloatOutBinary<f32x4> for boolx16

type Output = <boolx16 as FloatOutBinaryPromote<f32x4>>::Output

impl FloatOutBinary<f32x4> for cplx32x2

type Output = <cplx32x2 as FloatOutBinaryPromote<f32x4>>::Output

impl FloatOutBinary<f32x4> for cplx64x1

type Output = <cplx64x1 as FloatOutBinaryPromote<f32x4>>::Output

impl FloatOutBinary<f32x4> for f16x8

type Output = <f16x8 as FloatOutBinaryPromote<f32x4>>::Output

impl FloatOutBinary<f32x4> for f64x2

type Output = <f64x2 as FloatOutBinaryPromote<f32x4>>::Output

impl FloatOutBinary<f32x4> for i8x16

type Output = <i8x16 as FloatOutBinaryPromote<f32x4>>::Output

impl FloatOutBinary<f32x4> for i16x8

type Output = <i16x8 as FloatOutBinaryPromote<f32x4>>::Output

impl FloatOutBinary<f32x4> for i32x4

type Output = <i32x4 as FloatOutBinaryPromote<f32x4>>::Output

impl FloatOutBinary<f32x4> for i64x2

type Output = <i64x2 as FloatOutBinaryPromote<f32x4>>::Output

impl FloatOutBinary<f32x4> for isizex2

type Output = <isizex2 as FloatOutBinaryPromote<f32x4>>::Output

impl FloatOutBinary<f32x4> for u8x16

type Output = <u8x16 as FloatOutBinaryPromote<f32x4>>::Output

impl FloatOutBinary<f32x4> for u16x8

type Output = <u16x8 as FloatOutBinaryPromote<f32x4>>::Output

impl FloatOutBinary<f32x4> for u32x4

type Output = <u32x4 as FloatOutBinaryPromote<f32x4>>::Output

impl FloatOutBinary<f32x4> for u64x2

type Output = <u64x2 as FloatOutBinaryPromote<f32x4>>::Output

impl FloatOutBinary<f32x4> for usizex2

type Output = <usizex2 as FloatOutBinaryPromote<f32x4>>::Output

impl FloatOutBinary<f64x2> for bf16x8

type Output = <bf16x8 as FloatOutBinaryPromote<f64x2>>::Output

impl FloatOutBinary<f64x2> for boolx16

type Output = <boolx16 as FloatOutBinaryPromote<f64x2>>::Output

impl FloatOutBinary<f64x2> for cplx32x2

type Output = <cplx32x2 as FloatOutBinaryPromote<f64x2>>::Output

impl FloatOutBinary<f64x2> for cplx64x1

type Output = <cplx64x1 as FloatOutBinaryPromote<f64x2>>::Output

impl FloatOutBinary<f64x2> for f16x8

type Output = <f16x8 as FloatOutBinaryPromote<f64x2>>::Output

impl FloatOutBinary<f64x2> for f32x4

type Output = <f32x4 as FloatOutBinaryPromote<f64x2>>::Output

impl FloatOutBinary<f64x2> for i8x16

type Output = <i8x16 as FloatOutBinaryPromote<f64x2>>::Output

impl FloatOutBinary<f64x2> for i16x8

type Output = <i16x8 as FloatOutBinaryPromote<f64x2>>::Output

impl FloatOutBinary<f64x2> for i32x4

type Output = <i32x4 as FloatOutBinaryPromote<f64x2>>::Output

impl FloatOutBinary<f64x2> for i64x2

type Output = <i64x2 as FloatOutBinaryPromote<f64x2>>::Output

impl FloatOutBinary<f64x2> for isizex2

type Output = <isizex2 as FloatOutBinaryPromote<f64x2>>::Output

impl FloatOutBinary<f64x2> for u8x16

type Output = <u8x16 as FloatOutBinaryPromote<f64x2>>::Output

impl FloatOutBinary<f64x2> for u16x8

type Output = <u16x8 as FloatOutBinaryPromote<f64x2>>::Output

impl FloatOutBinary<f64x2> for u32x4

type Output = <u32x4 as FloatOutBinaryPromote<f64x2>>::Output

impl FloatOutBinary<f64x2> for u64x2

type Output = <u64x2 as FloatOutBinaryPromote<f64x2>>::Output

impl FloatOutBinary<f64x2> for usizex2

type Output = <usizex2 as FloatOutBinaryPromote<f64x2>>::Output

impl FloatOutBinary<i8x16> for bf16x8

type Output = <bf16x8 as FloatOutBinaryPromote<i8x16>>::Output

impl FloatOutBinary<i8x16> for boolx16

type Output = <boolx16 as FloatOutBinaryPromote<i8x16>>::Output

impl FloatOutBinary<i8x16> for cplx32x2

type Output = <cplx32x2 as FloatOutBinaryPromote<i8x16>>::Output

impl FloatOutBinary<i8x16> for cplx64x1

type Output = <cplx64x1 as FloatOutBinaryPromote<i8x16>>::Output

impl FloatOutBinary<i8x16> for f16x8

type Output = <f16x8 as FloatOutBinaryPromote<i8x16>>::Output

impl FloatOutBinary<i8x16> for f32x4

type Output = <f32x4 as FloatOutBinaryPromote<i8x16>>::Output

impl FloatOutBinary<i8x16> for f64x2

type Output = <f64x2 as FloatOutBinaryPromote<i8x16>>::Output

impl FloatOutBinary<i8x16> for i16x8

type Output = <i16x8 as FloatOutBinaryPromote<i8x16>>::Output

impl FloatOutBinary<i8x16> for i32x4

type Output = <i32x4 as FloatOutBinaryPromote<i8x16>>::Output

impl FloatOutBinary<i8x16> for i64x2

type Output = <i64x2 as FloatOutBinaryPromote<i8x16>>::Output

impl FloatOutBinary<i8x16> for isizex2

type Output = <isizex2 as FloatOutBinaryPromote<i8x16>>::Output

impl FloatOutBinary<i8x16> for u8x16

type Output = <u8x16 as FloatOutBinaryPromote<i8x16>>::Output

impl FloatOutBinary<i8x16> for u16x8

type Output = <u16x8 as FloatOutBinaryPromote<i8x16>>::Output

impl FloatOutBinary<i8x16> for u32x4

type Output = <u32x4 as FloatOutBinaryPromote<i8x16>>::Output

impl FloatOutBinary<i8x16> for u64x2

type Output = <u64x2 as FloatOutBinaryPromote<i8x16>>::Output

impl FloatOutBinary<i8x16> for usizex2

type Output = <usizex2 as FloatOutBinaryPromote<i8x16>>::Output

impl FloatOutBinary<i16x8> for bf16x8

type Output = <bf16x8 as FloatOutBinaryPromote<i16x8>>::Output

impl FloatOutBinary<i16x8> for boolx16

type Output = <boolx16 as FloatOutBinaryPromote<i16x8>>::Output

impl FloatOutBinary<i16x8> for cplx32x2

type Output = <cplx32x2 as FloatOutBinaryPromote<i16x8>>::Output

impl FloatOutBinary<i16x8> for cplx64x1

type Output = <cplx64x1 as FloatOutBinaryPromote<i16x8>>::Output

impl FloatOutBinary<i16x8> for f16x8

type Output = <f16x8 as FloatOutBinaryPromote<i16x8>>::Output

impl FloatOutBinary<i16x8> for f32x4

type Output = <f32x4 as FloatOutBinaryPromote<i16x8>>::Output

impl FloatOutBinary<i16x8> for f64x2

type Output = <f64x2 as FloatOutBinaryPromote<i16x8>>::Output

impl FloatOutBinary<i16x8> for i8x16

type Output = <i8x16 as FloatOutBinaryPromote<i16x8>>::Output

impl FloatOutBinary<i16x8> for i32x4

type Output = <i32x4 as FloatOutBinaryPromote<i16x8>>::Output

impl FloatOutBinary<i16x8> for i64x2

type Output = <i64x2 as FloatOutBinaryPromote<i16x8>>::Output

impl FloatOutBinary<i16x8> for isizex2

type Output = <isizex2 as FloatOutBinaryPromote<i16x8>>::Output

impl FloatOutBinary<i16x8> for u8x16

type Output = <u8x16 as FloatOutBinaryPromote<i16x8>>::Output

impl FloatOutBinary<i16x8> for u16x8

type Output = <u16x8 as FloatOutBinaryPromote<i16x8>>::Output

impl FloatOutBinary<i16x8> for u32x4

type Output = <u32x4 as FloatOutBinaryPromote<i16x8>>::Output

impl FloatOutBinary<i16x8> for u64x2

type Output = <u64x2 as FloatOutBinaryPromote<i16x8>>::Output

impl FloatOutBinary<i16x8> for usizex2

type Output = <usizex2 as FloatOutBinaryPromote<i16x8>>::Output

impl FloatOutBinary<i32x4> for bf16x8

type Output = <bf16x8 as FloatOutBinaryPromote<i32x4>>::Output

impl FloatOutBinary<i32x4> for boolx16

type Output = <boolx16 as FloatOutBinaryPromote<i32x4>>::Output

impl FloatOutBinary<i32x4> for cplx32x2

type Output = <cplx32x2 as FloatOutBinaryPromote<i32x4>>::Output

impl FloatOutBinary<i32x4> for cplx64x1

type Output = <cplx64x1 as FloatOutBinaryPromote<i32x4>>::Output

impl FloatOutBinary<i32x4> for f16x8

type Output = <f16x8 as FloatOutBinaryPromote<i32x4>>::Output

impl FloatOutBinary<i32x4> for f32x4

type Output = <f32x4 as FloatOutBinaryPromote<i32x4>>::Output

impl FloatOutBinary<i32x4> for f64x2

type Output = <f64x2 as FloatOutBinaryPromote<i32x4>>::Output

impl FloatOutBinary<i32x4> for i8x16

type Output = <i8x16 as FloatOutBinaryPromote<i32x4>>::Output

impl FloatOutBinary<i32x4> for i16x8

type Output = <i16x8 as FloatOutBinaryPromote<i32x4>>::Output

impl FloatOutBinary<i32x4> for i64x2

type Output = <i64x2 as FloatOutBinaryPromote<i32x4>>::Output

impl FloatOutBinary<i32x4> for isizex2

type Output = <isizex2 as FloatOutBinaryPromote<i32x4>>::Output

impl FloatOutBinary<i32x4> for u8x16

type Output = <u8x16 as FloatOutBinaryPromote<i32x4>>::Output

impl FloatOutBinary<i32x4> for u16x8

type Output = <u16x8 as FloatOutBinaryPromote<i32x4>>::Output

impl FloatOutBinary<i32x4> for u32x4

type Output = <u32x4 as FloatOutBinaryPromote<i32x4>>::Output

impl FloatOutBinary<i32x4> for u64x2

type Output = <u64x2 as FloatOutBinaryPromote<i32x4>>::Output

impl FloatOutBinary<i32x4> for usizex2

type Output = <usizex2 as FloatOutBinaryPromote<i32x4>>::Output

impl FloatOutBinary<i64x2> for bf16x8

type Output = <bf16x8 as FloatOutBinaryPromote<i64x2>>::Output

impl FloatOutBinary<i64x2> for boolx16

type Output = <boolx16 as FloatOutBinaryPromote<i64x2>>::Output

impl FloatOutBinary<i64x2> for cplx32x2

type Output = <cplx32x2 as FloatOutBinaryPromote<i64x2>>::Output

impl FloatOutBinary<i64x2> for cplx64x1

type Output = <cplx64x1 as FloatOutBinaryPromote<i64x2>>::Output

impl FloatOutBinary<i64x2> for f16x8

type Output = <f16x8 as FloatOutBinaryPromote<i64x2>>::Output

impl FloatOutBinary<i64x2> for f32x4

type Output = <f32x4 as FloatOutBinaryPromote<i64x2>>::Output

impl FloatOutBinary<i64x2> for f64x2

type Output = <f64x2 as FloatOutBinaryPromote<i64x2>>::Output

impl FloatOutBinary<i64x2> for i8x16

type Output = <i8x16 as FloatOutBinaryPromote<i64x2>>::Output

impl FloatOutBinary<i64x2> for i16x8

type Output = <i16x8 as FloatOutBinaryPromote<i64x2>>::Output

impl FloatOutBinary<i64x2> for i32x4

type Output = <i32x4 as FloatOutBinaryPromote<i64x2>>::Output

impl FloatOutBinary<i64x2> for isizex2

type Output = <isizex2 as FloatOutBinaryPromote<i64x2>>::Output

impl FloatOutBinary<i64x2> for u8x16

type Output = <u8x16 as FloatOutBinaryPromote<i64x2>>::Output

impl FloatOutBinary<i64x2> for u16x8

type Output = <u16x8 as FloatOutBinaryPromote<i64x2>>::Output

impl FloatOutBinary<i64x2> for u32x4

type Output = <u32x4 as FloatOutBinaryPromote<i64x2>>::Output

impl FloatOutBinary<i64x2> for u64x2

type Output = <u64x2 as FloatOutBinaryPromote<i64x2>>::Output

impl FloatOutBinary<i64x2> for usizex2

type Output = <usizex2 as FloatOutBinaryPromote<i64x2>>::Output

impl FloatOutBinary<isizex2> for bf16x8

type Output = <bf16x8 as FloatOutBinaryPromote<isizex2>>::Output

impl FloatOutBinary<isizex2> for boolx16

type Output = <boolx16 as FloatOutBinaryPromote<isizex2>>::Output

impl FloatOutBinary<isizex2> for cplx32x2

type Output = <cplx32x2 as FloatOutBinaryPromote<isizex2>>::Output

impl FloatOutBinary<isizex2> for cplx64x1

type Output = <cplx64x1 as FloatOutBinaryPromote<isizex2>>::Output

impl FloatOutBinary<isizex2> for f16x8

type Output = <f16x8 as FloatOutBinaryPromote<isizex2>>::Output

impl FloatOutBinary<isizex2> for f32x4

type Output = <f32x4 as FloatOutBinaryPromote<isizex2>>::Output

impl FloatOutBinary<isizex2> for f64x2

type Output = <f64x2 as FloatOutBinaryPromote<isizex2>>::Output

impl FloatOutBinary<isizex2> for i8x16

type Output = <i8x16 as FloatOutBinaryPromote<isizex2>>::Output

impl FloatOutBinary<isizex2> for i16x8

type Output = <i16x8 as FloatOutBinaryPromote<isizex2>>::Output

impl FloatOutBinary<isizex2> for i32x4

type Output = <i32x4 as FloatOutBinaryPromote<isizex2>>::Output

impl FloatOutBinary<isizex2> for i64x2

type Output = <i64x2 as FloatOutBinaryPromote<isizex2>>::Output

impl FloatOutBinary<isizex2> for u8x16

type Output = <u8x16 as FloatOutBinaryPromote<isizex2>>::Output

impl FloatOutBinary<isizex2> for u16x8

type Output = <u16x8 as FloatOutBinaryPromote<isizex2>>::Output

impl FloatOutBinary<isizex2> for u32x4

type Output = <u32x4 as FloatOutBinaryPromote<isizex2>>::Output

impl FloatOutBinary<isizex2> for u64x2

type Output = <u64x2 as FloatOutBinaryPromote<isizex2>>::Output

impl FloatOutBinary<isizex2> for usizex2

type Output = <usizex2 as FloatOutBinaryPromote<isizex2>>::Output

impl FloatOutBinary<u8x16> for bf16x8

type Output = <bf16x8 as FloatOutBinaryPromote<u8x16>>::Output

impl FloatOutBinary<u8x16> for boolx16

type Output = <boolx16 as FloatOutBinaryPromote<u8x16>>::Output

impl FloatOutBinary<u8x16> for cplx32x2

type Output = <cplx32x2 as FloatOutBinaryPromote<u8x16>>::Output

impl FloatOutBinary<u8x16> for cplx64x1

type Output = <cplx64x1 as FloatOutBinaryPromote<u8x16>>::Output

impl FloatOutBinary<u8x16> for f16x8

type Output = <f16x8 as FloatOutBinaryPromote<u8x16>>::Output

impl FloatOutBinary<u8x16> for f32x4

type Output = <f32x4 as FloatOutBinaryPromote<u8x16>>::Output

impl FloatOutBinary<u8x16> for f64x2

type Output = <f64x2 as FloatOutBinaryPromote<u8x16>>::Output

impl FloatOutBinary<u8x16> for i8x16

type Output = <i8x16 as FloatOutBinaryPromote<u8x16>>::Output

impl FloatOutBinary<u8x16> for i16x8

type Output = <i16x8 as FloatOutBinaryPromote<u8x16>>::Output

impl FloatOutBinary<u8x16> for i32x4

type Output = <i32x4 as FloatOutBinaryPromote<u8x16>>::Output

impl FloatOutBinary<u8x16> for i64x2

type Output = <i64x2 as FloatOutBinaryPromote<u8x16>>::Output

impl FloatOutBinary<u8x16> for isizex2

type Output = <isizex2 as FloatOutBinaryPromote<u8x16>>::Output

impl FloatOutBinary<u8x16> for u16x8

type Output = <u16x8 as FloatOutBinaryPromote<u8x16>>::Output

impl FloatOutBinary<u8x16> for u32x4

type Output = <u32x4 as FloatOutBinaryPromote<u8x16>>::Output

impl FloatOutBinary<u8x16> for u64x2

type Output = <u64x2 as FloatOutBinaryPromote<u8x16>>::Output

impl FloatOutBinary<u8x16> for usizex2

type Output = <usizex2 as FloatOutBinaryPromote<u8x16>>::Output

impl FloatOutBinary<u16x8> for bf16x8

type Output = <bf16x8 as FloatOutBinaryPromote<u16x8>>::Output

impl FloatOutBinary<u16x8> for boolx16

type Output = <boolx16 as FloatOutBinaryPromote<u16x8>>::Output

impl FloatOutBinary<u16x8> for cplx32x2

type Output = <cplx32x2 as FloatOutBinaryPromote<u16x8>>::Output

impl FloatOutBinary<u16x8> for cplx64x1

type Output = <cplx64x1 as FloatOutBinaryPromote<u16x8>>::Output

impl FloatOutBinary<u16x8> for f16x8

type Output = <f16x8 as FloatOutBinaryPromote<u16x8>>::Output

impl FloatOutBinary<u16x8> for f32x4

type Output = <f32x4 as FloatOutBinaryPromote<u16x8>>::Output

impl FloatOutBinary<u16x8> for f64x2

type Output = <f64x2 as FloatOutBinaryPromote<u16x8>>::Output

impl FloatOutBinary<u16x8> for i8x16

type Output = <i8x16 as FloatOutBinaryPromote<u16x8>>::Output

impl FloatOutBinary<u16x8> for i16x8

type Output = <i16x8 as FloatOutBinaryPromote<u16x8>>::Output

impl FloatOutBinary<u16x8> for i32x4

type Output = <i32x4 as FloatOutBinaryPromote<u16x8>>::Output

impl FloatOutBinary<u16x8> for i64x2

type Output = <i64x2 as FloatOutBinaryPromote<u16x8>>::Output

impl FloatOutBinary<u16x8> for isizex2

type Output = <isizex2 as FloatOutBinaryPromote<u16x8>>::Output

impl FloatOutBinary<u16x8> for u8x16

type Output = <u8x16 as FloatOutBinaryPromote<u16x8>>::Output

impl FloatOutBinary<u16x8> for u32x4

type Output = <u32x4 as FloatOutBinaryPromote<u16x8>>::Output

impl FloatOutBinary<u16x8> for u64x2

type Output = <u64x2 as FloatOutBinaryPromote<u16x8>>::Output

impl FloatOutBinary<u16x8> for usizex2

type Output = <usizex2 as FloatOutBinaryPromote<u16x8>>::Output

impl FloatOutBinary<u32x4> for bf16x8

type Output = <bf16x8 as FloatOutBinaryPromote<u32x4>>::Output

impl FloatOutBinary<u32x4> for boolx16

type Output = <boolx16 as FloatOutBinaryPromote<u32x4>>::Output

impl FloatOutBinary<u32x4> for cplx32x2

type Output = <cplx32x2 as FloatOutBinaryPromote<u32x4>>::Output

impl FloatOutBinary<u32x4> for cplx64x1

type Output = <cplx64x1 as FloatOutBinaryPromote<u32x4>>::Output

impl FloatOutBinary<u32x4> for f16x8

type Output = <f16x8 as FloatOutBinaryPromote<u32x4>>::Output

impl FloatOutBinary<u32x4> for f32x4

type Output = <f32x4 as FloatOutBinaryPromote<u32x4>>::Output

impl FloatOutBinary<u32x4> for f64x2

type Output = <f64x2 as FloatOutBinaryPromote<u32x4>>::Output

impl FloatOutBinary<u32x4> for i8x16

type Output = <i8x16 as FloatOutBinaryPromote<u32x4>>::Output

impl FloatOutBinary<u32x4> for i16x8

type Output = <i16x8 as FloatOutBinaryPromote<u32x4>>::Output

impl FloatOutBinary<u32x4> for i32x4

type Output = <i32x4 as FloatOutBinaryPromote<u32x4>>::Output

impl FloatOutBinary<u32x4> for i64x2

type Output = <i64x2 as FloatOutBinaryPromote<u32x4>>::Output

impl FloatOutBinary<u32x4> for isizex2

type Output = <isizex2 as FloatOutBinaryPromote<u32x4>>::Output

impl FloatOutBinary<u32x4> for u8x16

type Output = <u8x16 as FloatOutBinaryPromote<u32x4>>::Output

impl FloatOutBinary<u32x4> for u16x8

type Output = <u16x8 as FloatOutBinaryPromote<u32x4>>::Output

impl FloatOutBinary<u32x4> for u64x2

type Output = <u64x2 as FloatOutBinaryPromote<u32x4>>::Output

impl FloatOutBinary<u32x4> for usizex2

type Output = <usizex2 as FloatOutBinaryPromote<u32x4>>::Output

impl FloatOutBinary<u64x2> for bf16x8

type Output = <bf16x8 as FloatOutBinaryPromote<u64x2>>::Output

impl FloatOutBinary<u64x2> for boolx16

type Output = <boolx16 as FloatOutBinaryPromote<u64x2>>::Output

impl FloatOutBinary<u64x2> for cplx32x2

type Output = <cplx32x2 as FloatOutBinaryPromote<u64x2>>::Output

impl FloatOutBinary<u64x2> for cplx64x1

type Output = <cplx64x1 as FloatOutBinaryPromote<u64x2>>::Output

impl FloatOutBinary<u64x2> for f16x8

type Output = <f16x8 as FloatOutBinaryPromote<u64x2>>::Output

impl FloatOutBinary<u64x2> for f32x4

type Output = <f32x4 as FloatOutBinaryPromote<u64x2>>::Output

impl FloatOutBinary<u64x2> for f64x2

type Output = <f64x2 as FloatOutBinaryPromote<u64x2>>::Output

impl FloatOutBinary<u64x2> for i8x16

type Output = <i8x16 as FloatOutBinaryPromote<u64x2>>::Output

impl FloatOutBinary<u64x2> for i16x8

type Output = <i16x8 as FloatOutBinaryPromote<u64x2>>::Output

impl FloatOutBinary<u64x2> for i32x4

type Output = <i32x4 as FloatOutBinaryPromote<u64x2>>::Output

impl FloatOutBinary<u64x2> for i64x2

type Output = <i64x2 as FloatOutBinaryPromote<u64x2>>::Output

impl FloatOutBinary<u64x2> for isizex2

type Output = <isizex2 as FloatOutBinaryPromote<u64x2>>::Output

impl FloatOutBinary<u64x2> for u8x16

type Output = <u8x16 as FloatOutBinaryPromote<u64x2>>::Output

impl FloatOutBinary<u64x2> for u16x8

type Output = <u16x8 as FloatOutBinaryPromote<u64x2>>::Output

impl FloatOutBinary<u64x2> for u32x4

type Output = <u32x4 as FloatOutBinaryPromote<u64x2>>::Output

impl FloatOutBinary<u64x2> for usizex2

type Output = <usizex2 as FloatOutBinaryPromote<u64x2>>::Output

impl FloatOutBinary<usizex2> for bf16x8

type Output = <bf16x8 as FloatOutBinaryPromote<usizex2>>::Output

impl FloatOutBinary<usizex2> for boolx16

type Output = <boolx16 as FloatOutBinaryPromote<usizex2>>::Output

impl FloatOutBinary<usizex2> for cplx32x2

type Output = <cplx32x2 as FloatOutBinaryPromote<usizex2>>::Output

impl FloatOutBinary<usizex2> for cplx64x1

type Output = <cplx64x1 as FloatOutBinaryPromote<usizex2>>::Output

impl FloatOutBinary<usizex2> for f16x8

type Output = <f16x8 as FloatOutBinaryPromote<usizex2>>::Output

impl FloatOutBinary<usizex2> for f32x4

type Output = <f32x4 as FloatOutBinaryPromote<usizex2>>::Output

impl FloatOutBinary<usizex2> for f64x2

type Output = <f64x2 as FloatOutBinaryPromote<usizex2>>::Output

impl FloatOutBinary<usizex2> for i8x16

type Output = <i8x16 as FloatOutBinaryPromote<usizex2>>::Output

impl FloatOutBinary<usizex2> for i16x8

type Output = <i16x8 as FloatOutBinaryPromote<usizex2>>::Output

impl FloatOutBinary<usizex2> for i32x4

type Output = <i32x4 as FloatOutBinaryPromote<usizex2>>::Output

impl FloatOutBinary<usizex2> for i64x2

type Output = <i64x2 as FloatOutBinaryPromote<usizex2>>::Output

impl FloatOutBinary<usizex2> for isizex2

type Output = <isizex2 as FloatOutBinaryPromote<usizex2>>::Output

impl FloatOutBinary<usizex2> for u8x16

type Output = <u8x16 as FloatOutBinaryPromote<usizex2>>::Output

impl FloatOutBinary<usizex2> for u16x8

type Output = <u16x8 as FloatOutBinaryPromote<usizex2>>::Output

impl FloatOutBinary<usizex2> for u32x4

type Output = <u32x4 as FloatOutBinaryPromote<usizex2>>::Output

impl FloatOutBinary<usizex2> for u64x2

type Output = <u64x2 as FloatOutBinaryPromote<usizex2>>::Output

impl FloatOutBinary<bf16> for bf16x8

type Output = <bf16x8 as FloatOutBinaryPromote>::Output

impl FloatOutBinary<bf16> for boolx16

type Output = <boolx16 as FloatOutBinaryPromote<bf16x8>>::Output

impl FloatOutBinary<bf16> for cplx32x2

type Output = <cplx32x2 as FloatOutBinaryPromote<bf16x8>>::Output

impl FloatOutBinary<bf16> for cplx64x1

type Output = <cplx64x1 as FloatOutBinaryPromote<bf16x8>>::Output

impl FloatOutBinary<bf16> for f16x8

type Output = <f16x8 as FloatOutBinaryPromote<bf16x8>>::Output

impl FloatOutBinary<bf16> for f32x4

type Output = <f32x4 as FloatOutBinaryPromote<bf16x8>>::Output

impl FloatOutBinary<bf16> for f64x2

type Output = <f64x2 as FloatOutBinaryPromote<bf16x8>>::Output

impl FloatOutBinary<bf16> for i8x16

type Output = <i8x16 as FloatOutBinaryPromote<bf16x8>>::Output

impl FloatOutBinary<bf16> for i16x8

type Output = <i16x8 as FloatOutBinaryPromote<bf16x8>>::Output

impl FloatOutBinary<bf16> for i32x4

type Output = <i32x4 as FloatOutBinaryPromote<bf16x8>>::Output

impl FloatOutBinary<bf16> for i64x2

type Output = <i64x2 as FloatOutBinaryPromote<bf16x8>>::Output

impl FloatOutBinary<bf16> for isizex2

type Output = <isizex2 as FloatOutBinaryPromote<bf16x8>>::Output

impl FloatOutBinary<bf16> for u8x16

type Output = <u8x16 as FloatOutBinaryPromote<bf16x8>>::Output

impl FloatOutBinary<bf16> for u16x8

type Output = <u16x8 as FloatOutBinaryPromote<bf16x8>>::Output

impl FloatOutBinary<bf16> for u32x4

type Output = <u32x4 as FloatOutBinaryPromote<bf16x8>>::Output

impl FloatOutBinary<bf16> for u64x2

type Output = <u64x2 as FloatOutBinaryPromote<bf16x8>>::Output

impl FloatOutBinary<bf16> for usizex2

type Output = <usizex2 as FloatOutBinaryPromote<bf16x8>>::Output

impl FloatOutBinary<f16> for bf16x8

type Output = <bf16x8 as FloatOutBinaryPromote<f16x8>>::Output

impl FloatOutBinary<f16> for boolx16

type Output = <boolx16 as FloatOutBinaryPromote<f16x8>>::Output

impl FloatOutBinary<f16> for cplx32x2

type Output = <cplx32x2 as FloatOutBinaryPromote<f16x8>>::Output

impl FloatOutBinary<f16> for cplx64x1

type Output = <cplx64x1 as FloatOutBinaryPromote<f16x8>>::Output

impl FloatOutBinary<f16> for f16x8

type Output = <f16x8 as FloatOutBinaryPromote>::Output

impl FloatOutBinary<f16> for f32x4

type Output = <f32x4 as FloatOutBinaryPromote<f16x8>>::Output

impl FloatOutBinary<f16> for f64x2

type Output = <f64x2 as FloatOutBinaryPromote<f16x8>>::Output

impl FloatOutBinary<f16> for i8x16

type Output = <i8x16 as FloatOutBinaryPromote<f16x8>>::Output

impl FloatOutBinary<f16> for i16x8

type Output = <i16x8 as FloatOutBinaryPromote<f16x8>>::Output

impl FloatOutBinary<f16> for i32x4

type Output = <i32x4 as FloatOutBinaryPromote<f16x8>>::Output

impl FloatOutBinary<f16> for i64x2

type Output = <i64x2 as FloatOutBinaryPromote<f16x8>>::Output

impl FloatOutBinary<f16> for isizex2

type Output = <isizex2 as FloatOutBinaryPromote<f16x8>>::Output

impl FloatOutBinary<f16> for u8x16

type Output = <u8x16 as FloatOutBinaryPromote<f16x8>>::Output

impl FloatOutBinary<f16> for u16x8

type Output = <u16x8 as FloatOutBinaryPromote<f16x8>>::Output

impl FloatOutBinary<f16> for u32x4

type Output = <u32x4 as FloatOutBinaryPromote<f16x8>>::Output

impl FloatOutBinary<f16> for u64x2

type Output = <u64x2 as FloatOutBinaryPromote<f16x8>>::Output

impl FloatOutBinary<f16> for usizex2

type Output = <usizex2 as FloatOutBinaryPromote<f16x8>>::Output

impl FloatOutBinary<Complex<f32>> for bf16x8

type Output = <bf16x8 as FloatOutBinaryPromote<cplx32x2>>::Output

impl FloatOutBinary<Complex<f32>> for boolx16

type Output = <boolx16 as FloatOutBinaryPromote<cplx32x2>>::Output

impl FloatOutBinary<Complex<f32>> for cplx32x2

type Output = <cplx32x2 as FloatOutBinaryPromote>::Output

impl FloatOutBinary<Complex<f32>> for cplx64x1

type Output = <cplx64x1 as FloatOutBinaryPromote<cplx32x2>>::Output

impl FloatOutBinary<Complex<f32>> for f16x8

type Output = <f16x8 as FloatOutBinaryPromote<cplx32x2>>::Output

impl FloatOutBinary<Complex<f32>> for f32x4

type Output = <f32x4 as FloatOutBinaryPromote<cplx32x2>>::Output

impl FloatOutBinary<Complex<f32>> for f64x2

type Output = <f64x2 as FloatOutBinaryPromote<cplx32x2>>::Output

impl FloatOutBinary<Complex<f32>> for i8x16

type Output = <i8x16 as FloatOutBinaryPromote<cplx32x2>>::Output

impl FloatOutBinary<Complex<f32>> for i16x8

type Output = <i16x8 as FloatOutBinaryPromote<cplx32x2>>::Output

impl FloatOutBinary<Complex<f32>> for i32x4

type Output = <i32x4 as FloatOutBinaryPromote<cplx32x2>>::Output

impl FloatOutBinary<Complex<f32>> for i64x2

type Output = <i64x2 as FloatOutBinaryPromote<cplx32x2>>::Output

impl FloatOutBinary<Complex<f32>> for isizex2

type Output = <isizex2 as FloatOutBinaryPromote<cplx32x2>>::Output

impl FloatOutBinary<Complex<f32>> for u8x16

type Output = <u8x16 as FloatOutBinaryPromote<cplx32x2>>::Output

impl FloatOutBinary<Complex<f32>> for u16x8

type Output = <u16x8 as FloatOutBinaryPromote<cplx32x2>>::Output

impl FloatOutBinary<Complex<f32>> for u32x4

type Output = <u32x4 as FloatOutBinaryPromote<cplx32x2>>::Output

impl FloatOutBinary<Complex<f32>> for u64x2

type Output = <u64x2 as FloatOutBinaryPromote<cplx32x2>>::Output

impl FloatOutBinary<Complex<f32>> for usizex2

type Output = <usizex2 as FloatOutBinaryPromote<cplx32x2>>::Output

impl FloatOutBinary<Complex<f64>> for bf16x8

type Output = <bf16x8 as FloatOutBinaryPromote<cplx64x1>>::Output

impl FloatOutBinary<Complex<f64>> for boolx16

type Output = <boolx16 as FloatOutBinaryPromote<cplx64x1>>::Output

impl FloatOutBinary<Complex<f64>> for cplx32x2

type Output = <cplx32x2 as FloatOutBinaryPromote<cplx64x1>>::Output

impl FloatOutBinary<Complex<f64>> for cplx64x1

type Output = <cplx64x1 as FloatOutBinaryPromote>::Output

impl FloatOutBinary<Complex<f64>> for f16x8

type Output = <f16x8 as FloatOutBinaryPromote<cplx64x1>>::Output

impl FloatOutBinary<Complex<f64>> for f32x4

type Output = <f32x4 as FloatOutBinaryPromote<cplx64x1>>::Output

impl FloatOutBinary<Complex<f64>> for f64x2

type Output = <f64x2 as FloatOutBinaryPromote<cplx64x1>>::Output

impl FloatOutBinary<Complex<f64>> for i8x16

type Output = <i8x16 as FloatOutBinaryPromote<cplx64x1>>::Output

impl FloatOutBinary<Complex<f64>> for i16x8

type Output = <i16x8 as FloatOutBinaryPromote<cplx64x1>>::Output

impl FloatOutBinary<Complex<f64>> for i32x4

type Output = <i32x4 as FloatOutBinaryPromote<cplx64x1>>::Output

impl FloatOutBinary<Complex<f64>> for i64x2

type Output = <i64x2 as FloatOutBinaryPromote<cplx64x1>>::Output

impl FloatOutBinary<Complex<f64>> for isizex2

type Output = <isizex2 as FloatOutBinaryPromote<cplx64x1>>::Output

impl FloatOutBinary<Complex<f64>> for u8x16

type Output = <u8x16 as FloatOutBinaryPromote<cplx64x1>>::Output

impl FloatOutBinary<Complex<f64>> for u16x8

type Output = <u16x8 as FloatOutBinaryPromote<cplx64x1>>::Output

impl FloatOutBinary<Complex<f64>> for u32x4

type Output = <u32x4 as FloatOutBinaryPromote<cplx64x1>>::Output

impl FloatOutBinary<Complex<f64>> for u64x2

type Output = <u64x2 as FloatOutBinaryPromote<cplx64x1>>::Output

impl FloatOutBinary<Complex<f64>> for usizex2

type Output = <usizex2 as FloatOutBinaryPromote<cplx64x1>>::Output