Trait lnkit::prelude::SimdPartialOrd[−]

pub trait SimdPartialOrd: SimdValue {
    pub fn simd_gt(self, other: Self) -> Self::SimdBool;
    pub fn simd_lt(self, other: Self) -> Self::SimdBool;
    pub fn simd_ge(self, other: Self) -> Self::SimdBool;
    pub fn simd_le(self, other: Self) -> Self::SimdBool;
    pub fn simd_eq(self, other: Self) -> Self::SimdBool;
    pub fn simd_ne(self, other: Self) -> Self::SimdBool;
    pub fn simd_max(self, other: Self) -> Self;
    pub fn simd_min(self, other: Self) -> Self;
    pub fn simd_clamp(self, min: Self, max: Self) -> Self;
    pub fn simd_horizontal_min(self) -> Self::Element;
    pub fn simd_horizontal_max(self) -> Self::Element;
}

Lane-wise generalization of the standard PartialOrd for SIMD values.

Required methods

`pub fn simd_gt(self, other: Self) -> Self::SimdBool`

Lanewise greater than > comparison.

`pub fn simd_lt(self, other: Self) -> Self::SimdBool`

Lanewise less than < comparison.

`pub fn simd_ge(self, other: Self) -> Self::SimdBool`

Lanewise greater or equal >= comparison.

`pub fn simd_le(self, other: Self) -> Self::SimdBool`

Lanewise less or equal <= comparison.

`pub fn simd_eq(self, other: Self) -> Self::SimdBool`

Lanewise equal == comparison.

`pub fn simd_ne(self, other: Self) -> Self::SimdBool`

Lanewise not equal != comparison.

`pub fn simd_max(self, other: Self) -> Self`

Lanewise max value.

`pub fn simd_min(self, other: Self) -> Self`

Lanewise min value.

`pub fn simd_clamp(self, min: Self, max: Self) -> Self`

Clamps each lane of self between the corresponding lane of min and max.

`pub fn simd_horizontal_min(self) -> Self::Element`

The min value among all lanes of self.

`pub fn simd_horizontal_max(self) -> Self::Element`

The max value among all lanes of self.

Loading content...

Implementations on Foreign Types

`impl SimdPartialOrd for Simd<Simd<[usize; 4]>>`

`pub fn simd_gt( self, other: Simd<Simd<[usize; 4]>> ) -> <Simd<Simd<[usize; 4]>> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: Simd<Simd<[usize; 4]>> ) -> <Simd<Simd<[usize; 4]>> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: Simd<Simd<[usize; 4]>> ) -> <Simd<Simd<[usize; 4]>> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: Simd<Simd<[usize; 4]>> ) -> <Simd<Simd<[usize; 4]>> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: Simd<Simd<[usize; 4]>> ) -> <Simd<Simd<[usize; 4]>> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: Simd<Simd<[usize; 4]>> ) -> <Simd<Simd<[usize; 4]>> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: Simd<Simd<[usize; 4]>>) -> Simd<Simd<[usize; 4]>>`

`pub fn simd_min(self, other: Simd<Simd<[usize; 4]>>) -> Simd<Simd<[usize; 4]>>`

`pub fn simd_clamp( self, min: Simd<Simd<[usize; 4]>>, max: Simd<Simd<[usize; 4]>> ) -> Simd<Simd<[usize; 4]>>`

`pub fn simd_horizontal_min( self ) -> <Simd<Simd<[usize; 4]>> as SimdValue>::Element`

`pub fn simd_horizontal_max( self ) -> <Simd<Simd<[usize; 4]>> as SimdValue>::Element`

`impl SimdPartialOrd for AutoSimd<[f32; 2]>`

`pub fn simd_gt( self, other: AutoSimd<[f32; 2]> ) -> <AutoSimd<[f32; 2]> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: AutoSimd<[f32; 2]> ) -> <AutoSimd<[f32; 2]> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: AutoSimd<[f32; 2]> ) -> <AutoSimd<[f32; 2]> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: AutoSimd<[f32; 2]> ) -> <AutoSimd<[f32; 2]> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: AutoSimd<[f32; 2]> ) -> <AutoSimd<[f32; 2]> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: AutoSimd<[f32; 2]> ) -> <AutoSimd<[f32; 2]> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: AutoSimd<[f32; 2]>) -> AutoSimd<[f32; 2]>`

`pub fn simd_min(self, other: AutoSimd<[f32; 2]>) -> AutoSimd<[f32; 2]>`

`pub fn simd_clamp( self, min: AutoSimd<[f32; 2]>, max: AutoSimd<[f32; 2]> ) -> AutoSimd<[f32; 2]>`

`pub fn simd_horizontal_min(self) -> <AutoSimd<[f32; 2]> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <AutoSimd<[f32; 2]> as SimdValue>::Element`

`impl SimdPartialOrd for AutoSimd<[isize; 2]>`

`pub fn simd_gt( self, other: AutoSimd<[isize; 2]> ) -> <AutoSimd<[isize; 2]> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: AutoSimd<[isize; 2]> ) -> <AutoSimd<[isize; 2]> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: AutoSimd<[isize; 2]> ) -> <AutoSimd<[isize; 2]> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: AutoSimd<[isize; 2]> ) -> <AutoSimd<[isize; 2]> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: AutoSimd<[isize; 2]> ) -> <AutoSimd<[isize; 2]> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: AutoSimd<[isize; 2]> ) -> <AutoSimd<[isize; 2]> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: AutoSimd<[isize; 2]>) -> AutoSimd<[isize; 2]>`

`pub fn simd_min(self, other: AutoSimd<[isize; 2]>) -> AutoSimd<[isize; 2]>`

`pub fn simd_clamp( self, min: AutoSimd<[isize; 2]>, max: AutoSimd<[isize; 2]> ) -> AutoSimd<[isize; 2]>`

`pub fn simd_horizontal_min(self) -> <AutoSimd<[isize; 2]> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <AutoSimd<[isize; 2]> as SimdValue>::Element`

`impl SimdPartialOrd for Simd<Simd<[u16; 4]>>`

`pub fn simd_gt( self, other: Simd<Simd<[u16; 4]>> ) -> <Simd<Simd<[u16; 4]>> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: Simd<Simd<[u16; 4]>> ) -> <Simd<Simd<[u16; 4]>> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: Simd<Simd<[u16; 4]>> ) -> <Simd<Simd<[u16; 4]>> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: Simd<Simd<[u16; 4]>> ) -> <Simd<Simd<[u16; 4]>> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: Simd<Simd<[u16; 4]>> ) -> <Simd<Simd<[u16; 4]>> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: Simd<Simd<[u16; 4]>> ) -> <Simd<Simd<[u16; 4]>> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: Simd<Simd<[u16; 4]>>) -> Simd<Simd<[u16; 4]>>`

`pub fn simd_min(self, other: Simd<Simd<[u16; 4]>>) -> Simd<Simd<[u16; 4]>>`

`pub fn simd_clamp( self, min: Simd<Simd<[u16; 4]>>, max: Simd<Simd<[u16; 4]>> ) -> Simd<Simd<[u16; 4]>>`

`pub fn simd_horizontal_min(self) -> <Simd<Simd<[u16; 4]>> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <Simd<Simd<[u16; 4]>> as SimdValue>::Element`

`impl SimdPartialOrd for Simd<Simd<[u128; 4]>>`

`pub fn simd_gt( self, other: Simd<Simd<[u128; 4]>> ) -> <Simd<Simd<[u128; 4]>> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: Simd<Simd<[u128; 4]>> ) -> <Simd<Simd<[u128; 4]>> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: Simd<Simd<[u128; 4]>> ) -> <Simd<Simd<[u128; 4]>> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: Simd<Simd<[u128; 4]>> ) -> <Simd<Simd<[u128; 4]>> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: Simd<Simd<[u128; 4]>> ) -> <Simd<Simd<[u128; 4]>> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: Simd<Simd<[u128; 4]>> ) -> <Simd<Simd<[u128; 4]>> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: Simd<Simd<[u128; 4]>>) -> Simd<Simd<[u128; 4]>>`

`pub fn simd_min(self, other: Simd<Simd<[u128; 4]>>) -> Simd<Simd<[u128; 4]>>`

`pub fn simd_clamp( self, min: Simd<Simd<[u128; 4]>>, max: Simd<Simd<[u128; 4]>> ) -> Simd<Simd<[u128; 4]>>`

`pub fn simd_horizontal_min( self ) -> <Simd<Simd<[u128; 4]>> as SimdValue>::Element`

`pub fn simd_horizontal_max( self ) -> <Simd<Simd<[u128; 4]>> as SimdValue>::Element`

`impl SimdPartialOrd for AutoSimd<[u32; 2]>`

`pub fn simd_gt( self, other: AutoSimd<[u32; 2]> ) -> <AutoSimd<[u32; 2]> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: AutoSimd<[u32; 2]> ) -> <AutoSimd<[u32; 2]> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: AutoSimd<[u32; 2]> ) -> <AutoSimd<[u32; 2]> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: AutoSimd<[u32; 2]> ) -> <AutoSimd<[u32; 2]> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: AutoSimd<[u32; 2]> ) -> <AutoSimd<[u32; 2]> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: AutoSimd<[u32; 2]> ) -> <AutoSimd<[u32; 2]> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: AutoSimd<[u32; 2]>) -> AutoSimd<[u32; 2]>`

`pub fn simd_min(self, other: AutoSimd<[u32; 2]>) -> AutoSimd<[u32; 2]>`

`pub fn simd_clamp( self, min: AutoSimd<[u32; 2]>, max: AutoSimd<[u32; 2]> ) -> AutoSimd<[u32; 2]>`

`pub fn simd_horizontal_min(self) -> <AutoSimd<[u32; 2]> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <AutoSimd<[u32; 2]> as SimdValue>::Element`

`impl SimdPartialOrd for AutoSimd<[f64; 4]>`

`pub fn simd_gt( self, other: AutoSimd<[f64; 4]> ) -> <AutoSimd<[f64; 4]> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: AutoSimd<[f64; 4]> ) -> <AutoSimd<[f64; 4]> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: AutoSimd<[f64; 4]> ) -> <AutoSimd<[f64; 4]> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: AutoSimd<[f64; 4]> ) -> <AutoSimd<[f64; 4]> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: AutoSimd<[f64; 4]> ) -> <AutoSimd<[f64; 4]> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: AutoSimd<[f64; 4]> ) -> <AutoSimd<[f64; 4]> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: AutoSimd<[f64; 4]>) -> AutoSimd<[f64; 4]>`

`pub fn simd_min(self, other: AutoSimd<[f64; 4]>) -> AutoSimd<[f64; 4]>`

`pub fn simd_clamp( self, min: AutoSimd<[f64; 4]>, max: AutoSimd<[f64; 4]> ) -> AutoSimd<[f64; 4]>`

`pub fn simd_horizontal_min(self) -> <AutoSimd<[f64; 4]> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <AutoSimd<[f64; 4]> as SimdValue>::Element`

`impl SimdPartialOrd for AutoSimd<[u16; 8]>`

`pub fn simd_gt( self, other: AutoSimd<[u16; 8]> ) -> <AutoSimd<[u16; 8]> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: AutoSimd<[u16; 8]> ) -> <AutoSimd<[u16; 8]> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: AutoSimd<[u16; 8]> ) -> <AutoSimd<[u16; 8]> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: AutoSimd<[u16; 8]> ) -> <AutoSimd<[u16; 8]> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: AutoSimd<[u16; 8]> ) -> <AutoSimd<[u16; 8]> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: AutoSimd<[u16; 8]> ) -> <AutoSimd<[u16; 8]> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: AutoSimd<[u16; 8]>) -> AutoSimd<[u16; 8]>`

`pub fn simd_min(self, other: AutoSimd<[u16; 8]>) -> AutoSimd<[u16; 8]>`

`pub fn simd_clamp( self, min: AutoSimd<[u16; 8]>, max: AutoSimd<[u16; 8]> ) -> AutoSimd<[u16; 8]>`

`pub fn simd_horizontal_min(self) -> <AutoSimd<[u16; 8]> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <AutoSimd<[u16; 8]> as SimdValue>::Element`

`impl SimdPartialOrd for Simd<Simd<[u8; 16]>>`

`pub fn simd_gt( self, other: Simd<Simd<[u8; 16]>> ) -> <Simd<Simd<[u8; 16]>> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: Simd<Simd<[u8; 16]>> ) -> <Simd<Simd<[u8; 16]>> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: Simd<Simd<[u8; 16]>> ) -> <Simd<Simd<[u8; 16]>> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: Simd<Simd<[u8; 16]>> ) -> <Simd<Simd<[u8; 16]>> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: Simd<Simd<[u8; 16]>> ) -> <Simd<Simd<[u8; 16]>> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: Simd<Simd<[u8; 16]>> ) -> <Simd<Simd<[u8; 16]>> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: Simd<Simd<[u8; 16]>>) -> Simd<Simd<[u8; 16]>>`

`pub fn simd_min(self, other: Simd<Simd<[u8; 16]>>) -> Simd<Simd<[u8; 16]>>`

`pub fn simd_clamp( self, min: Simd<Simd<[u8; 16]>>, max: Simd<Simd<[u8; 16]>> ) -> Simd<Simd<[u8; 16]>>`

`pub fn simd_horizontal_min(self) -> <Simd<Simd<[u8; 16]>> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <Simd<Simd<[u8; 16]>> as SimdValue>::Element`

`impl SimdPartialOrd for Simd<Simd<[u32; 8]>>`

`pub fn simd_gt( self, other: Simd<Simd<[u32; 8]>> ) -> <Simd<Simd<[u32; 8]>> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: Simd<Simd<[u32; 8]>> ) -> <Simd<Simd<[u32; 8]>> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: Simd<Simd<[u32; 8]>> ) -> <Simd<Simd<[u32; 8]>> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: Simd<Simd<[u32; 8]>> ) -> <Simd<Simd<[u32; 8]>> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: Simd<Simd<[u32; 8]>> ) -> <Simd<Simd<[u32; 8]>> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: Simd<Simd<[u32; 8]>> ) -> <Simd<Simd<[u32; 8]>> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: Simd<Simd<[u32; 8]>>) -> Simd<Simd<[u32; 8]>>`

`pub fn simd_min(self, other: Simd<Simd<[u32; 8]>>) -> Simd<Simd<[u32; 8]>>`

`pub fn simd_clamp( self, min: Simd<Simd<[u32; 8]>>, max: Simd<Simd<[u32; 8]>> ) -> Simd<Simd<[u32; 8]>>`

`pub fn simd_horizontal_min(self) -> <Simd<Simd<[u32; 8]>> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <Simd<Simd<[u32; 8]>> as SimdValue>::Element`

`impl SimdPartialOrd for Simd<Simd<[u8; 2]>>`

`pub fn simd_gt( self, other: Simd<Simd<[u8; 2]>> ) -> <Simd<Simd<[u8; 2]>> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: Simd<Simd<[u8; 2]>> ) -> <Simd<Simd<[u8; 2]>> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: Simd<Simd<[u8; 2]>> ) -> <Simd<Simd<[u8; 2]>> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: Simd<Simd<[u8; 2]>> ) -> <Simd<Simd<[u8; 2]>> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: Simd<Simd<[u8; 2]>> ) -> <Simd<Simd<[u8; 2]>> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: Simd<Simd<[u8; 2]>> ) -> <Simd<Simd<[u8; 2]>> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: Simd<Simd<[u8; 2]>>) -> Simd<Simd<[u8; 2]>>`

`pub fn simd_min(self, other: Simd<Simd<[u8; 2]>>) -> Simd<Simd<[u8; 2]>>`

`pub fn simd_clamp( self, min: Simd<Simd<[u8; 2]>>, max: Simd<Simd<[u8; 2]>> ) -> Simd<Simd<[u8; 2]>>`

`pub fn simd_horizontal_min(self) -> <Simd<Simd<[u8; 2]>> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <Simd<Simd<[u8; 2]>> as SimdValue>::Element`

`impl SimdPartialOrd for Simd<Simd<[u16; 32]>>`

`pub fn simd_gt( self, other: Simd<Simd<[u16; 32]>> ) -> <Simd<Simd<[u16; 32]>> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: Simd<Simd<[u16; 32]>> ) -> <Simd<Simd<[u16; 32]>> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: Simd<Simd<[u16; 32]>> ) -> <Simd<Simd<[u16; 32]>> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: Simd<Simd<[u16; 32]>> ) -> <Simd<Simd<[u16; 32]>> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: Simd<Simd<[u16; 32]>> ) -> <Simd<Simd<[u16; 32]>> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: Simd<Simd<[u16; 32]>> ) -> <Simd<Simd<[u16; 32]>> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: Simd<Simd<[u16; 32]>>) -> Simd<Simd<[u16; 32]>>`

`pub fn simd_min(self, other: Simd<Simd<[u16; 32]>>) -> Simd<Simd<[u16; 32]>>`

`pub fn simd_clamp( self, min: Simd<Simd<[u16; 32]>>, max: Simd<Simd<[u16; 32]>> ) -> Simd<Simd<[u16; 32]>>`

`pub fn simd_horizontal_min( self ) -> <Simd<Simd<[u16; 32]>> as SimdValue>::Element`

`pub fn simd_horizontal_max( self ) -> <Simd<Simd<[u16; 32]>> as SimdValue>::Element`

`impl SimdPartialOrd for Simd<Simd<[i16; 4]>>`

`pub fn simd_gt( self, other: Simd<Simd<[i16; 4]>> ) -> <Simd<Simd<[i16; 4]>> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: Simd<Simd<[i16; 4]>> ) -> <Simd<Simd<[i16; 4]>> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: Simd<Simd<[i16; 4]>> ) -> <Simd<Simd<[i16; 4]>> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: Simd<Simd<[i16; 4]>> ) -> <Simd<Simd<[i16; 4]>> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: Simd<Simd<[i16; 4]>> ) -> <Simd<Simd<[i16; 4]>> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: Simd<Simd<[i16; 4]>> ) -> <Simd<Simd<[i16; 4]>> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: Simd<Simd<[i16; 4]>>) -> Simd<Simd<[i16; 4]>>`

`pub fn simd_min(self, other: Simd<Simd<[i16; 4]>>) -> Simd<Simd<[i16; 4]>>`

`pub fn simd_clamp( self, min: Simd<Simd<[i16; 4]>>, max: Simd<Simd<[i16; 4]>> ) -> Simd<Simd<[i16; 4]>>`

`pub fn simd_horizontal_min(self) -> <Simd<Simd<[i16; 4]>> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <Simd<Simd<[i16; 4]>> as SimdValue>::Element`

`impl SimdPartialOrd for Simd<Simd<[i32; 4]>>`

`pub fn simd_gt( self, other: Simd<Simd<[i32; 4]>> ) -> <Simd<Simd<[i32; 4]>> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: Simd<Simd<[i32; 4]>> ) -> <Simd<Simd<[i32; 4]>> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: Simd<Simd<[i32; 4]>> ) -> <Simd<Simd<[i32; 4]>> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: Simd<Simd<[i32; 4]>> ) -> <Simd<Simd<[i32; 4]>> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: Simd<Simd<[i32; 4]>> ) -> <Simd<Simd<[i32; 4]>> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: Simd<Simd<[i32; 4]>> ) -> <Simd<Simd<[i32; 4]>> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: Simd<Simd<[i32; 4]>>) -> Simd<Simd<[i32; 4]>>`

`pub fn simd_min(self, other: Simd<Simd<[i32; 4]>>) -> Simd<Simd<[i32; 4]>>`

`pub fn simd_clamp( self, min: Simd<Simd<[i32; 4]>>, max: Simd<Simd<[i32; 4]>> ) -> Simd<Simd<[i32; 4]>>`

`pub fn simd_horizontal_min(self) -> <Simd<Simd<[i32; 4]>> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <Simd<Simd<[i32; 4]>> as SimdValue>::Element`

`impl SimdPartialOrd for Simd<Simd<[i16; 2]>>`

`pub fn simd_gt( self, other: Simd<Simd<[i16; 2]>> ) -> <Simd<Simd<[i16; 2]>> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: Simd<Simd<[i16; 2]>> ) -> <Simd<Simd<[i16; 2]>> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: Simd<Simd<[i16; 2]>> ) -> <Simd<Simd<[i16; 2]>> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: Simd<Simd<[i16; 2]>> ) -> <Simd<Simd<[i16; 2]>> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: Simd<Simd<[i16; 2]>> ) -> <Simd<Simd<[i16; 2]>> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: Simd<Simd<[i16; 2]>> ) -> <Simd<Simd<[i16; 2]>> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: Simd<Simd<[i16; 2]>>) -> Simd<Simd<[i16; 2]>>`

`pub fn simd_min(self, other: Simd<Simd<[i16; 2]>>) -> Simd<Simd<[i16; 2]>>`

`pub fn simd_clamp( self, min: Simd<Simd<[i16; 2]>>, max: Simd<Simd<[i16; 2]>> ) -> Simd<Simd<[i16; 2]>>`

`pub fn simd_horizontal_min(self) -> <Simd<Simd<[i16; 2]>> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <Simd<Simd<[i16; 2]>> as SimdValue>::Element`

`impl SimdPartialOrd for AutoSimd<[u64; 8]>`

`pub fn simd_gt( self, other: AutoSimd<[u64; 8]> ) -> <AutoSimd<[u64; 8]> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: AutoSimd<[u64; 8]> ) -> <AutoSimd<[u64; 8]> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: AutoSimd<[u64; 8]> ) -> <AutoSimd<[u64; 8]> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: AutoSimd<[u64; 8]> ) -> <AutoSimd<[u64; 8]> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: AutoSimd<[u64; 8]> ) -> <AutoSimd<[u64; 8]> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: AutoSimd<[u64; 8]> ) -> <AutoSimd<[u64; 8]> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: AutoSimd<[u64; 8]>) -> AutoSimd<[u64; 8]>`

`pub fn simd_min(self, other: AutoSimd<[u64; 8]>) -> AutoSimd<[u64; 8]>`

`pub fn simd_clamp( self, min: AutoSimd<[u64; 8]>, max: AutoSimd<[u64; 8]> ) -> AutoSimd<[u64; 8]>`

`pub fn simd_horizontal_min(self) -> <AutoSimd<[u64; 8]> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <AutoSimd<[u64; 8]> as SimdValue>::Element`

`impl SimdPartialOrd for Simd<Simd<[usize; 2]>>`

`pub fn simd_gt( self, other: Simd<Simd<[usize; 2]>> ) -> <Simd<Simd<[usize; 2]>> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: Simd<Simd<[usize; 2]>> ) -> <Simd<Simd<[usize; 2]>> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: Simd<Simd<[usize; 2]>> ) -> <Simd<Simd<[usize; 2]>> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: Simd<Simd<[usize; 2]>> ) -> <Simd<Simd<[usize; 2]>> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: Simd<Simd<[usize; 2]>> ) -> <Simd<Simd<[usize; 2]>> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: Simd<Simd<[usize; 2]>> ) -> <Simd<Simd<[usize; 2]>> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: Simd<Simd<[usize; 2]>>) -> Simd<Simd<[usize; 2]>>`

`pub fn simd_min(self, other: Simd<Simd<[usize; 2]>>) -> Simd<Simd<[usize; 2]>>`

`pub fn simd_clamp( self, min: Simd<Simd<[usize; 2]>>, max: Simd<Simd<[usize; 2]>> ) -> Simd<Simd<[usize; 2]>>`

`pub fn simd_horizontal_min( self ) -> <Simd<Simd<[usize; 2]>> as SimdValue>::Element`

`pub fn simd_horizontal_max( self ) -> <Simd<Simd<[usize; 2]>> as SimdValue>::Element`

`impl SimdPartialOrd for AutoSimd<[i64; 2]>`

`pub fn simd_gt( self, other: AutoSimd<[i64; 2]> ) -> <AutoSimd<[i64; 2]> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: AutoSimd<[i64; 2]> ) -> <AutoSimd<[i64; 2]> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: AutoSimd<[i64; 2]> ) -> <AutoSimd<[i64; 2]> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: AutoSimd<[i64; 2]> ) -> <AutoSimd<[i64; 2]> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: AutoSimd<[i64; 2]> ) -> <AutoSimd<[i64; 2]> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: AutoSimd<[i64; 2]> ) -> <AutoSimd<[i64; 2]> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: AutoSimd<[i64; 2]>) -> AutoSimd<[i64; 2]>`

`pub fn simd_min(self, other: AutoSimd<[i64; 2]>) -> AutoSimd<[i64; 2]>`

`pub fn simd_clamp( self, min: AutoSimd<[i64; 2]>, max: AutoSimd<[i64; 2]> ) -> AutoSimd<[i64; 2]>`

`pub fn simd_horizontal_min(self) -> <AutoSimd<[i64; 2]> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <AutoSimd<[i64; 2]> as SimdValue>::Element`

`impl SimdPartialOrd for AutoSimd<[i8; 4]>`

`pub fn simd_gt( self, other: AutoSimd<[i8; 4]> ) -> <AutoSimd<[i8; 4]> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: AutoSimd<[i8; 4]> ) -> <AutoSimd<[i8; 4]> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: AutoSimd<[i8; 4]> ) -> <AutoSimd<[i8; 4]> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: AutoSimd<[i8; 4]> ) -> <AutoSimd<[i8; 4]> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: AutoSimd<[i8; 4]> ) -> <AutoSimd<[i8; 4]> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: AutoSimd<[i8; 4]> ) -> <AutoSimd<[i8; 4]> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: AutoSimd<[i8; 4]>) -> AutoSimd<[i8; 4]>`

`pub fn simd_min(self, other: AutoSimd<[i8; 4]>) -> AutoSimd<[i8; 4]>`

`pub fn simd_clamp( self, min: AutoSimd<[i8; 4]>, max: AutoSimd<[i8; 4]> ) -> AutoSimd<[i8; 4]>`

`pub fn simd_horizontal_min(self) -> <AutoSimd<[i8; 4]> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <AutoSimd<[i8; 4]> as SimdValue>::Element`

`impl SimdPartialOrd for AutoSimd<[i32; 8]>`

`pub fn simd_gt( self, other: AutoSimd<[i32; 8]> ) -> <AutoSimd<[i32; 8]> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: AutoSimd<[i32; 8]> ) -> <AutoSimd<[i32; 8]> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: AutoSimd<[i32; 8]> ) -> <AutoSimd<[i32; 8]> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: AutoSimd<[i32; 8]> ) -> <AutoSimd<[i32; 8]> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: AutoSimd<[i32; 8]> ) -> <AutoSimd<[i32; 8]> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: AutoSimd<[i32; 8]> ) -> <AutoSimd<[i32; 8]> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: AutoSimd<[i32; 8]>) -> AutoSimd<[i32; 8]>`

`pub fn simd_min(self, other: AutoSimd<[i32; 8]>) -> AutoSimd<[i32; 8]>`

`pub fn simd_clamp( self, min: AutoSimd<[i32; 8]>, max: AutoSimd<[i32; 8]> ) -> AutoSimd<[i32; 8]>`

`pub fn simd_horizontal_min(self) -> <AutoSimd<[i32; 8]> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <AutoSimd<[i32; 8]> as SimdValue>::Element`

`impl SimdPartialOrd for AutoSimd<[u64; 4]>`

`pub fn simd_gt( self, other: AutoSimd<[u64; 4]> ) -> <AutoSimd<[u64; 4]> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: AutoSimd<[u64; 4]> ) -> <AutoSimd<[u64; 4]> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: AutoSimd<[u64; 4]> ) -> <AutoSimd<[u64; 4]> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: AutoSimd<[u64; 4]> ) -> <AutoSimd<[u64; 4]> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: AutoSimd<[u64; 4]> ) -> <AutoSimd<[u64; 4]> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: AutoSimd<[u64; 4]> ) -> <AutoSimd<[u64; 4]> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: AutoSimd<[u64; 4]>) -> AutoSimd<[u64; 4]>`

`pub fn simd_min(self, other: AutoSimd<[u64; 4]>) -> AutoSimd<[u64; 4]>`

`pub fn simd_clamp( self, min: AutoSimd<[u64; 4]>, max: AutoSimd<[u64; 4]> ) -> AutoSimd<[u64; 4]>`

`pub fn simd_horizontal_min(self) -> <AutoSimd<[u64; 4]> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <AutoSimd<[u64; 4]> as SimdValue>::Element`

`impl SimdPartialOrd for Simd<Simd<[i16; 32]>>`

`pub fn simd_gt( self, other: Simd<Simd<[i16; 32]>> ) -> <Simd<Simd<[i16; 32]>> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: Simd<Simd<[i16; 32]>> ) -> <Simd<Simd<[i16; 32]>> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: Simd<Simd<[i16; 32]>> ) -> <Simd<Simd<[i16; 32]>> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: Simd<Simd<[i16; 32]>> ) -> <Simd<Simd<[i16; 32]>> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: Simd<Simd<[i16; 32]>> ) -> <Simd<Simd<[i16; 32]>> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: Simd<Simd<[i16; 32]>> ) -> <Simd<Simd<[i16; 32]>> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: Simd<Simd<[i16; 32]>>) -> Simd<Simd<[i16; 32]>>`

`pub fn simd_min(self, other: Simd<Simd<[i16; 32]>>) -> Simd<Simd<[i16; 32]>>`

`pub fn simd_clamp( self, min: Simd<Simd<[i16; 32]>>, max: Simd<Simd<[i16; 32]>> ) -> Simd<Simd<[i16; 32]>>`

`pub fn simd_horizontal_min( self ) -> <Simd<Simd<[i16; 32]>> as SimdValue>::Element`

`pub fn simd_horizontal_max( self ) -> <Simd<Simd<[i16; 32]>> as SimdValue>::Element`

`impl SimdPartialOrd for Simd<Simd<[f32; 16]>>`

`pub fn simd_gt( self, other: Simd<Simd<[f32; 16]>> ) -> <Simd<Simd<[f32; 16]>> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: Simd<Simd<[f32; 16]>> ) -> <Simd<Simd<[f32; 16]>> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: Simd<Simd<[f32; 16]>> ) -> <Simd<Simd<[f32; 16]>> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: Simd<Simd<[f32; 16]>> ) -> <Simd<Simd<[f32; 16]>> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: Simd<Simd<[f32; 16]>> ) -> <Simd<Simd<[f32; 16]>> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: Simd<Simd<[f32; 16]>> ) -> <Simd<Simd<[f32; 16]>> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: Simd<Simd<[f32; 16]>>) -> Simd<Simd<[f32; 16]>>`

`pub fn simd_min(self, other: Simd<Simd<[f32; 16]>>) -> Simd<Simd<[f32; 16]>>`

`pub fn simd_clamp( self, min: Simd<Simd<[f32; 16]>>, max: Simd<Simd<[f32; 16]>> ) -> Simd<Simd<[f32; 16]>>`

`pub fn simd_horizontal_min( self ) -> <Simd<Simd<[f32; 16]>> as SimdValue>::Element`

`pub fn simd_horizontal_max( self ) -> <Simd<Simd<[f32; 16]>> as SimdValue>::Element`

`impl SimdPartialOrd for Simd<Simd<[usize; 8]>>`

`pub fn simd_gt( self, other: Simd<Simd<[usize; 8]>> ) -> <Simd<Simd<[usize; 8]>> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: Simd<Simd<[usize; 8]>> ) -> <Simd<Simd<[usize; 8]>> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: Simd<Simd<[usize; 8]>> ) -> <Simd<Simd<[usize; 8]>> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: Simd<Simd<[usize; 8]>> ) -> <Simd<Simd<[usize; 8]>> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: Simd<Simd<[usize; 8]>> ) -> <Simd<Simd<[usize; 8]>> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: Simd<Simd<[usize; 8]>> ) -> <Simd<Simd<[usize; 8]>> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: Simd<Simd<[usize; 8]>>) -> Simd<Simd<[usize; 8]>>`

`pub fn simd_min(self, other: Simd<Simd<[usize; 8]>>) -> Simd<Simd<[usize; 8]>>`

`pub fn simd_clamp( self, min: Simd<Simd<[usize; 8]>>, max: Simd<Simd<[usize; 8]>> ) -> Simd<Simd<[usize; 8]>>`

`pub fn simd_horizontal_min( self ) -> <Simd<Simd<[usize; 8]>> as SimdValue>::Element`

`pub fn simd_horizontal_max( self ) -> <Simd<Simd<[usize; 8]>> as SimdValue>::Element`

`impl SimdPartialOrd for Simd<Simd<[i16; 16]>>`

`pub fn simd_gt( self, other: Simd<Simd<[i16; 16]>> ) -> <Simd<Simd<[i16; 16]>> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: Simd<Simd<[i16; 16]>> ) -> <Simd<Simd<[i16; 16]>> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: Simd<Simd<[i16; 16]>> ) -> <Simd<Simd<[i16; 16]>> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: Simd<Simd<[i16; 16]>> ) -> <Simd<Simd<[i16; 16]>> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: Simd<Simd<[i16; 16]>> ) -> <Simd<Simd<[i16; 16]>> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: Simd<Simd<[i16; 16]>> ) -> <Simd<Simd<[i16; 16]>> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: Simd<Simd<[i16; 16]>>) -> Simd<Simd<[i16; 16]>>`

`pub fn simd_min(self, other: Simd<Simd<[i16; 16]>>) -> Simd<Simd<[i16; 16]>>`

`pub fn simd_clamp( self, min: Simd<Simd<[i16; 16]>>, max: Simd<Simd<[i16; 16]>> ) -> Simd<Simd<[i16; 16]>>`

`pub fn simd_horizontal_min( self ) -> <Simd<Simd<[i16; 16]>> as SimdValue>::Element`

`pub fn simd_horizontal_max( self ) -> <Simd<Simd<[i16; 16]>> as SimdValue>::Element`

`impl SimdPartialOrd for AutoSimd<[i16; 8]>`

`pub fn simd_gt( self, other: AutoSimd<[i16; 8]> ) -> <AutoSimd<[i16; 8]> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: AutoSimd<[i16; 8]> ) -> <AutoSimd<[i16; 8]> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: AutoSimd<[i16; 8]> ) -> <AutoSimd<[i16; 8]> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: AutoSimd<[i16; 8]> ) -> <AutoSimd<[i16; 8]> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: AutoSimd<[i16; 8]> ) -> <AutoSimd<[i16; 8]> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: AutoSimd<[i16; 8]> ) -> <AutoSimd<[i16; 8]> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: AutoSimd<[i16; 8]>) -> AutoSimd<[i16; 8]>`

`pub fn simd_min(self, other: AutoSimd<[i16; 8]>) -> AutoSimd<[i16; 8]>`

`pub fn simd_clamp( self, min: AutoSimd<[i16; 8]>, max: AutoSimd<[i16; 8]> ) -> AutoSimd<[i16; 8]>`

`pub fn simd_horizontal_min(self) -> <AutoSimd<[i16; 8]> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <AutoSimd<[i16; 8]> as SimdValue>::Element`

`impl SimdPartialOrd for AutoSimd<[isize; 8]>`

`pub fn simd_gt( self, other: AutoSimd<[isize; 8]> ) -> <AutoSimd<[isize; 8]> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: AutoSimd<[isize; 8]> ) -> <AutoSimd<[isize; 8]> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: AutoSimd<[isize; 8]> ) -> <AutoSimd<[isize; 8]> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: AutoSimd<[isize; 8]> ) -> <AutoSimd<[isize; 8]> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: AutoSimd<[isize; 8]> ) -> <AutoSimd<[isize; 8]> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: AutoSimd<[isize; 8]> ) -> <AutoSimd<[isize; 8]> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: AutoSimd<[isize; 8]>) -> AutoSimd<[isize; 8]>`

`pub fn simd_min(self, other: AutoSimd<[isize; 8]>) -> AutoSimd<[isize; 8]>`

`pub fn simd_clamp( self, min: AutoSimd<[isize; 8]>, max: AutoSimd<[isize; 8]> ) -> AutoSimd<[isize; 8]>`

`pub fn simd_horizontal_min(self) -> <AutoSimd<[isize; 8]> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <AutoSimd<[isize; 8]> as SimdValue>::Element`

`impl SimdPartialOrd for AutoSimd<[u16; 2]>`

`pub fn simd_gt( self, other: AutoSimd<[u16; 2]> ) -> <AutoSimd<[u16; 2]> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: AutoSimd<[u16; 2]> ) -> <AutoSimd<[u16; 2]> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: AutoSimd<[u16; 2]> ) -> <AutoSimd<[u16; 2]> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: AutoSimd<[u16; 2]> ) -> <AutoSimd<[u16; 2]> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: AutoSimd<[u16; 2]> ) -> <AutoSimd<[u16; 2]> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: AutoSimd<[u16; 2]> ) -> <AutoSimd<[u16; 2]> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: AutoSimd<[u16; 2]>) -> AutoSimd<[u16; 2]>`

`pub fn simd_min(self, other: AutoSimd<[u16; 2]>) -> AutoSimd<[u16; 2]>`

`pub fn simd_clamp( self, min: AutoSimd<[u16; 2]>, max: AutoSimd<[u16; 2]> ) -> AutoSimd<[u16; 2]>`

`pub fn simd_horizontal_min(self) -> <AutoSimd<[u16; 2]> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <AutoSimd<[u16; 2]> as SimdValue>::Element`

`impl SimdPartialOrd for Simd<Simd<[i128; 2]>>`

`pub fn simd_gt( self, other: Simd<Simd<[i128; 2]>> ) -> <Simd<Simd<[i128; 2]>> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: Simd<Simd<[i128; 2]>> ) -> <Simd<Simd<[i128; 2]>> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: Simd<Simd<[i128; 2]>> ) -> <Simd<Simd<[i128; 2]>> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: Simd<Simd<[i128; 2]>> ) -> <Simd<Simd<[i128; 2]>> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: Simd<Simd<[i128; 2]>> ) -> <Simd<Simd<[i128; 2]>> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: Simd<Simd<[i128; 2]>> ) -> <Simd<Simd<[i128; 2]>> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: Simd<Simd<[i128; 2]>>) -> Simd<Simd<[i128; 2]>>`

`pub fn simd_min(self, other: Simd<Simd<[i128; 2]>>) -> Simd<Simd<[i128; 2]>>`

`pub fn simd_clamp( self, min: Simd<Simd<[i128; 2]>>, max: Simd<Simd<[i128; 2]>> ) -> Simd<Simd<[i128; 2]>>`

`pub fn simd_horizontal_min( self ) -> <Simd<Simd<[i128; 2]>> as SimdValue>::Element`

`pub fn simd_horizontal_max( self ) -> <Simd<Simd<[i128; 2]>> as SimdValue>::Element`

`impl SimdPartialOrd for AutoSimd<[f32; 4]>`

`pub fn simd_gt( self, other: AutoSimd<[f32; 4]> ) -> <AutoSimd<[f32; 4]> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: AutoSimd<[f32; 4]> ) -> <AutoSimd<[f32; 4]> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: AutoSimd<[f32; 4]> ) -> <AutoSimd<[f32; 4]> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: AutoSimd<[f32; 4]> ) -> <AutoSimd<[f32; 4]> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: AutoSimd<[f32; 4]> ) -> <AutoSimd<[f32; 4]> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: AutoSimd<[f32; 4]> ) -> <AutoSimd<[f32; 4]> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: AutoSimd<[f32; 4]>) -> AutoSimd<[f32; 4]>`

`pub fn simd_min(self, other: AutoSimd<[f32; 4]>) -> AutoSimd<[f32; 4]>`

`pub fn simd_clamp( self, min: AutoSimd<[f32; 4]>, max: AutoSimd<[f32; 4]> ) -> AutoSimd<[f32; 4]>`

`pub fn simd_horizontal_min(self) -> <AutoSimd<[f32; 4]> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <AutoSimd<[f32; 4]> as SimdValue>::Element`

`impl SimdPartialOrd for AutoSimd<[f64; 2]>`

`pub fn simd_gt( self, other: AutoSimd<[f64; 2]> ) -> <AutoSimd<[f64; 2]> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: AutoSimd<[f64; 2]> ) -> <AutoSimd<[f64; 2]> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: AutoSimd<[f64; 2]> ) -> <AutoSimd<[f64; 2]> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: AutoSimd<[f64; 2]> ) -> <AutoSimd<[f64; 2]> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: AutoSimd<[f64; 2]> ) -> <AutoSimd<[f64; 2]> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: AutoSimd<[f64; 2]> ) -> <AutoSimd<[f64; 2]> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: AutoSimd<[f64; 2]>) -> AutoSimd<[f64; 2]>`

`pub fn simd_min(self, other: AutoSimd<[f64; 2]>) -> AutoSimd<[f64; 2]>`

`pub fn simd_clamp( self, min: AutoSimd<[f64; 2]>, max: AutoSimd<[f64; 2]> ) -> AutoSimd<[f64; 2]>`

`pub fn simd_horizontal_min(self) -> <AutoSimd<[f64; 2]> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <AutoSimd<[f64; 2]> as SimdValue>::Element`

`impl SimdPartialOrd for Simd<Simd<[isize; 8]>>`

`pub fn simd_gt( self, other: Simd<Simd<[isize; 8]>> ) -> <Simd<Simd<[isize; 8]>> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: Simd<Simd<[isize; 8]>> ) -> <Simd<Simd<[isize; 8]>> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: Simd<Simd<[isize; 8]>> ) -> <Simd<Simd<[isize; 8]>> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: Simd<Simd<[isize; 8]>> ) -> <Simd<Simd<[isize; 8]>> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: Simd<Simd<[isize; 8]>> ) -> <Simd<Simd<[isize; 8]>> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: Simd<Simd<[isize; 8]>> ) -> <Simd<Simd<[isize; 8]>> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: Simd<Simd<[isize; 8]>>) -> Simd<Simd<[isize; 8]>>`

`pub fn simd_min(self, other: Simd<Simd<[isize; 8]>>) -> Simd<Simd<[isize; 8]>>`

`pub fn simd_clamp( self, min: Simd<Simd<[isize; 8]>>, max: Simd<Simd<[isize; 8]>> ) -> Simd<Simd<[isize; 8]>>`

`pub fn simd_horizontal_min( self ) -> <Simd<Simd<[isize; 8]>> as SimdValue>::Element`

`pub fn simd_horizontal_max( self ) -> <Simd<Simd<[isize; 8]>> as SimdValue>::Element`

`impl SimdPartialOrd for Simd<Simd<[i32; 2]>>`

`pub fn simd_gt( self, other: Simd<Simd<[i32; 2]>> ) -> <Simd<Simd<[i32; 2]>> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: Simd<Simd<[i32; 2]>> ) -> <Simd<Simd<[i32; 2]>> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: Simd<Simd<[i32; 2]>> ) -> <Simd<Simd<[i32; 2]>> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: Simd<Simd<[i32; 2]>> ) -> <Simd<Simd<[i32; 2]>> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: Simd<Simd<[i32; 2]>> ) -> <Simd<Simd<[i32; 2]>> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: Simd<Simd<[i32; 2]>> ) -> <Simd<Simd<[i32; 2]>> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: Simd<Simd<[i32; 2]>>) -> Simd<Simd<[i32; 2]>>`

`pub fn simd_min(self, other: Simd<Simd<[i32; 2]>>) -> Simd<Simd<[i32; 2]>>`

`pub fn simd_clamp( self, min: Simd<Simd<[i32; 2]>>, max: Simd<Simd<[i32; 2]>> ) -> Simd<Simd<[i32; 2]>>`

`pub fn simd_horizontal_min(self) -> <Simd<Simd<[i32; 2]>> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <Simd<Simd<[i32; 2]>> as SimdValue>::Element`

`impl SimdPartialOrd for AutoSimd<[u128; 1]>`

`pub fn simd_gt( self, other: AutoSimd<[u128; 1]> ) -> <AutoSimd<[u128; 1]> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: AutoSimd<[u128; 1]> ) -> <AutoSimd<[u128; 1]> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: AutoSimd<[u128; 1]> ) -> <AutoSimd<[u128; 1]> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: AutoSimd<[u128; 1]> ) -> <AutoSimd<[u128; 1]> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: AutoSimd<[u128; 1]> ) -> <AutoSimd<[u128; 1]> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: AutoSimd<[u128; 1]> ) -> <AutoSimd<[u128; 1]> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: AutoSimd<[u128; 1]>) -> AutoSimd<[u128; 1]>`

`pub fn simd_min(self, other: AutoSimd<[u128; 1]>) -> AutoSimd<[u128; 1]>`

`pub fn simd_clamp( self, min: AutoSimd<[u128; 1]>, max: AutoSimd<[u128; 1]> ) -> AutoSimd<[u128; 1]>`

`pub fn simd_horizontal_min(self) -> <AutoSimd<[u128; 1]> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <AutoSimd<[u128; 1]> as SimdValue>::Element`

`impl SimdPartialOrd for Simd<Simd<[i128; 4]>>`

`pub fn simd_gt( self, other: Simd<Simd<[i128; 4]>> ) -> <Simd<Simd<[i128; 4]>> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: Simd<Simd<[i128; 4]>> ) -> <Simd<Simd<[i128; 4]>> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: Simd<Simd<[i128; 4]>> ) -> <Simd<Simd<[i128; 4]>> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: Simd<Simd<[i128; 4]>> ) -> <Simd<Simd<[i128; 4]>> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: Simd<Simd<[i128; 4]>> ) -> <Simd<Simd<[i128; 4]>> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: Simd<Simd<[i128; 4]>> ) -> <Simd<Simd<[i128; 4]>> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: Simd<Simd<[i128; 4]>>) -> Simd<Simd<[i128; 4]>>`

`pub fn simd_min(self, other: Simd<Simd<[i128; 4]>>) -> Simd<Simd<[i128; 4]>>`

`pub fn simd_clamp( self, min: Simd<Simd<[i128; 4]>>, max: Simd<Simd<[i128; 4]>> ) -> Simd<Simd<[i128; 4]>>`

`pub fn simd_horizontal_min( self ) -> <Simd<Simd<[i128; 4]>> as SimdValue>::Element`

`pub fn simd_horizontal_max( self ) -> <Simd<Simd<[i128; 4]>> as SimdValue>::Element`

`impl SimdPartialOrd for Simd<Simd<[i8; 16]>>`

`pub fn simd_gt( self, other: Simd<Simd<[i8; 16]>> ) -> <Simd<Simd<[i8; 16]>> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: Simd<Simd<[i8; 16]>> ) -> <Simd<Simd<[i8; 16]>> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: Simd<Simd<[i8; 16]>> ) -> <Simd<Simd<[i8; 16]>> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: Simd<Simd<[i8; 16]>> ) -> <Simd<Simd<[i8; 16]>> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: Simd<Simd<[i8; 16]>> ) -> <Simd<Simd<[i8; 16]>> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: Simd<Simd<[i8; 16]>> ) -> <Simd<Simd<[i8; 16]>> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: Simd<Simd<[i8; 16]>>) -> Simd<Simd<[i8; 16]>>`

`pub fn simd_min(self, other: Simd<Simd<[i8; 16]>>) -> Simd<Simd<[i8; 16]>>`

`pub fn simd_clamp( self, min: Simd<Simd<[i8; 16]>>, max: Simd<Simd<[i8; 16]>> ) -> Simd<Simd<[i8; 16]>>`

`pub fn simd_horizontal_min(self) -> <Simd<Simd<[i8; 16]>> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <Simd<Simd<[i8; 16]>> as SimdValue>::Element`

`impl SimdPartialOrd for AutoSimd<[i128; 2]>`

`pub fn simd_gt( self, other: AutoSimd<[i128; 2]> ) -> <AutoSimd<[i128; 2]> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: AutoSimd<[i128; 2]> ) -> <AutoSimd<[i128; 2]> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: AutoSimd<[i128; 2]> ) -> <AutoSimd<[i128; 2]> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: AutoSimd<[i128; 2]> ) -> <AutoSimd<[i128; 2]> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: AutoSimd<[i128; 2]> ) -> <AutoSimd<[i128; 2]> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: AutoSimd<[i128; 2]> ) -> <AutoSimd<[i128; 2]> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: AutoSimd<[i128; 2]>) -> AutoSimd<[i128; 2]>`

`pub fn simd_min(self, other: AutoSimd<[i128; 2]>) -> AutoSimd<[i128; 2]>`

`pub fn simd_clamp( self, min: AutoSimd<[i128; 2]>, max: AutoSimd<[i128; 2]> ) -> AutoSimd<[i128; 2]>`

`pub fn simd_horizontal_min(self) -> <AutoSimd<[i128; 2]> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <AutoSimd<[i128; 2]> as SimdValue>::Element`

`impl SimdPartialOrd for AutoSimd<[i16; 2]>`

`pub fn simd_gt( self, other: AutoSimd<[i16; 2]> ) -> <AutoSimd<[i16; 2]> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: AutoSimd<[i16; 2]> ) -> <AutoSimd<[i16; 2]> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: AutoSimd<[i16; 2]> ) -> <AutoSimd<[i16; 2]> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: AutoSimd<[i16; 2]> ) -> <AutoSimd<[i16; 2]> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: AutoSimd<[i16; 2]> ) -> <AutoSimd<[i16; 2]> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: AutoSimd<[i16; 2]> ) -> <AutoSimd<[i16; 2]> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: AutoSimd<[i16; 2]>) -> AutoSimd<[i16; 2]>`

`pub fn simd_min(self, other: AutoSimd<[i16; 2]>) -> AutoSimd<[i16; 2]>`

`pub fn simd_clamp( self, min: AutoSimd<[i16; 2]>, max: AutoSimd<[i16; 2]> ) -> AutoSimd<[i16; 2]>`

`pub fn simd_horizontal_min(self) -> <AutoSimd<[i16; 2]> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <AutoSimd<[i16; 2]> as SimdValue>::Element`

`impl SimdPartialOrd for Simd<Simd<[i8; 2]>>`

`pub fn simd_gt( self, other: Simd<Simd<[i8; 2]>> ) -> <Simd<Simd<[i8; 2]>> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: Simd<Simd<[i8; 2]>> ) -> <Simd<Simd<[i8; 2]>> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: Simd<Simd<[i8; 2]>> ) -> <Simd<Simd<[i8; 2]>> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: Simd<Simd<[i8; 2]>> ) -> <Simd<Simd<[i8; 2]>> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: Simd<Simd<[i8; 2]>> ) -> <Simd<Simd<[i8; 2]>> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: Simd<Simd<[i8; 2]>> ) -> <Simd<Simd<[i8; 2]>> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: Simd<Simd<[i8; 2]>>) -> Simd<Simd<[i8; 2]>>`

`pub fn simd_min(self, other: Simd<Simd<[i8; 2]>>) -> Simd<Simd<[i8; 2]>>`

`pub fn simd_clamp( self, min: Simd<Simd<[i8; 2]>>, max: Simd<Simd<[i8; 2]>> ) -> Simd<Simd<[i8; 2]>>`

`pub fn simd_horizontal_min(self) -> <Simd<Simd<[i8; 2]>> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <Simd<Simd<[i8; 2]>> as SimdValue>::Element`

`impl SimdPartialOrd for Simd<Simd<[i16; 8]>>`

`pub fn simd_gt( self, other: Simd<Simd<[i16; 8]>> ) -> <Simd<Simd<[i16; 8]>> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: Simd<Simd<[i16; 8]>> ) -> <Simd<Simd<[i16; 8]>> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: Simd<Simd<[i16; 8]>> ) -> <Simd<Simd<[i16; 8]>> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: Simd<Simd<[i16; 8]>> ) -> <Simd<Simd<[i16; 8]>> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: Simd<Simd<[i16; 8]>> ) -> <Simd<Simd<[i16; 8]>> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: Simd<Simd<[i16; 8]>> ) -> <Simd<Simd<[i16; 8]>> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: Simd<Simd<[i16; 8]>>) -> Simd<Simd<[i16; 8]>>`

`pub fn simd_min(self, other: Simd<Simd<[i16; 8]>>) -> Simd<Simd<[i16; 8]>>`

`pub fn simd_clamp( self, min: Simd<Simd<[i16; 8]>>, max: Simd<Simd<[i16; 8]>> ) -> Simd<Simd<[i16; 8]>>`

`pub fn simd_horizontal_min(self) -> <Simd<Simd<[i16; 8]>> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <Simd<Simd<[i16; 8]>> as SimdValue>::Element`

`impl SimdPartialOrd for Simd<Simd<[u8; 32]>>`

`pub fn simd_gt( self, other: Simd<Simd<[u8; 32]>> ) -> <Simd<Simd<[u8; 32]>> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: Simd<Simd<[u8; 32]>> ) -> <Simd<Simd<[u8; 32]>> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: Simd<Simd<[u8; 32]>> ) -> <Simd<Simd<[u8; 32]>> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: Simd<Simd<[u8; 32]>> ) -> <Simd<Simd<[u8; 32]>> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: Simd<Simd<[u8; 32]>> ) -> <Simd<Simd<[u8; 32]>> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: Simd<Simd<[u8; 32]>> ) -> <Simd<Simd<[u8; 32]>> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: Simd<Simd<[u8; 32]>>) -> Simd<Simd<[u8; 32]>>`

`pub fn simd_min(self, other: Simd<Simd<[u8; 32]>>) -> Simd<Simd<[u8; 32]>>`

`pub fn simd_clamp( self, min: Simd<Simd<[u8; 32]>>, max: Simd<Simd<[u8; 32]>> ) -> Simd<Simd<[u8; 32]>>`

`pub fn simd_horizontal_min(self) -> <Simd<Simd<[u8; 32]>> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <Simd<Simd<[u8; 32]>> as SimdValue>::Element`

`impl SimdPartialOrd for Simd<Simd<[u64; 4]>>`

`pub fn simd_gt( self, other: Simd<Simd<[u64; 4]>> ) -> <Simd<Simd<[u64; 4]>> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: Simd<Simd<[u64; 4]>> ) -> <Simd<Simd<[u64; 4]>> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: Simd<Simd<[u64; 4]>> ) -> <Simd<Simd<[u64; 4]>> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: Simd<Simd<[u64; 4]>> ) -> <Simd<Simd<[u64; 4]>> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: Simd<Simd<[u64; 4]>> ) -> <Simd<Simd<[u64; 4]>> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: Simd<Simd<[u64; 4]>> ) -> <Simd<Simd<[u64; 4]>> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: Simd<Simd<[u64; 4]>>) -> Simd<Simd<[u64; 4]>>`

`pub fn simd_min(self, other: Simd<Simd<[u64; 4]>>) -> Simd<Simd<[u64; 4]>>`

`pub fn simd_clamp( self, min: Simd<Simd<[u64; 4]>>, max: Simd<Simd<[u64; 4]>> ) -> Simd<Simd<[u64; 4]>>`

`pub fn simd_horizontal_min(self) -> <Simd<Simd<[u64; 4]>> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <Simd<Simd<[u64; 4]>> as SimdValue>::Element`

`impl SimdPartialOrd for AutoSimd<[i8; 32]>`

`pub fn simd_gt( self, other: AutoSimd<[i8; 32]> ) -> <AutoSimd<[i8; 32]> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: AutoSimd<[i8; 32]> ) -> <AutoSimd<[i8; 32]> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: AutoSimd<[i8; 32]> ) -> <AutoSimd<[i8; 32]> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: AutoSimd<[i8; 32]> ) -> <AutoSimd<[i8; 32]> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: AutoSimd<[i8; 32]> ) -> <AutoSimd<[i8; 32]> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: AutoSimd<[i8; 32]> ) -> <AutoSimd<[i8; 32]> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: AutoSimd<[i8; 32]>) -> AutoSimd<[i8; 32]>`

`pub fn simd_min(self, other: AutoSimd<[i8; 32]>) -> AutoSimd<[i8; 32]>`

`pub fn simd_clamp( self, min: AutoSimd<[i8; 32]>, max: AutoSimd<[i8; 32]> ) -> AutoSimd<[i8; 32]>`

`pub fn simd_horizontal_min(self) -> <AutoSimd<[i8; 32]> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <AutoSimd<[i8; 32]> as SimdValue>::Element`

`impl SimdPartialOrd for Simd<Simd<[isize; 2]>>`

`pub fn simd_gt( self, other: Simd<Simd<[isize; 2]>> ) -> <Simd<Simd<[isize; 2]>> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: Simd<Simd<[isize; 2]>> ) -> <Simd<Simd<[isize; 2]>> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: Simd<Simd<[isize; 2]>> ) -> <Simd<Simd<[isize; 2]>> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: Simd<Simd<[isize; 2]>> ) -> <Simd<Simd<[isize; 2]>> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: Simd<Simd<[isize; 2]>> ) -> <Simd<Simd<[isize; 2]>> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: Simd<Simd<[isize; 2]>> ) -> <Simd<Simd<[isize; 2]>> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: Simd<Simd<[isize; 2]>>) -> Simd<Simd<[isize; 2]>>`

`pub fn simd_min(self, other: Simd<Simd<[isize; 2]>>) -> Simd<Simd<[isize; 2]>>`

`pub fn simd_clamp( self, min: Simd<Simd<[isize; 2]>>, max: Simd<Simd<[isize; 2]>> ) -> Simd<Simd<[isize; 2]>>`

`pub fn simd_horizontal_min( self ) -> <Simd<Simd<[isize; 2]>> as SimdValue>::Element`

`pub fn simd_horizontal_max( self ) -> <Simd<Simd<[isize; 2]>> as SimdValue>::Element`

`impl SimdPartialOrd for Simd<Simd<[i64; 2]>>`

`pub fn simd_gt( self, other: Simd<Simd<[i64; 2]>> ) -> <Simd<Simd<[i64; 2]>> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: Simd<Simd<[i64; 2]>> ) -> <Simd<Simd<[i64; 2]>> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: Simd<Simd<[i64; 2]>> ) -> <Simd<Simd<[i64; 2]>> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: Simd<Simd<[i64; 2]>> ) -> <Simd<Simd<[i64; 2]>> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: Simd<Simd<[i64; 2]>> ) -> <Simd<Simd<[i64; 2]>> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: Simd<Simd<[i64; 2]>> ) -> <Simd<Simd<[i64; 2]>> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: Simd<Simd<[i64; 2]>>) -> Simd<Simd<[i64; 2]>>`

`pub fn simd_min(self, other: Simd<Simd<[i64; 2]>>) -> Simd<Simd<[i64; 2]>>`

`pub fn simd_clamp( self, min: Simd<Simd<[i64; 2]>>, max: Simd<Simd<[i64; 2]>> ) -> Simd<Simd<[i64; 2]>>`

`pub fn simd_horizontal_min(self) -> <Simd<Simd<[i64; 2]>> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <Simd<Simd<[i64; 2]>> as SimdValue>::Element`

`impl SimdPartialOrd for Simd<Simd<[i128; 1]>>`

`pub fn simd_gt( self, other: Simd<Simd<[i128; 1]>> ) -> <Simd<Simd<[i128; 1]>> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: Simd<Simd<[i128; 1]>> ) -> <Simd<Simd<[i128; 1]>> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: Simd<Simd<[i128; 1]>> ) -> <Simd<Simd<[i128; 1]>> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: Simd<Simd<[i128; 1]>> ) -> <Simd<Simd<[i128; 1]>> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: Simd<Simd<[i128; 1]>> ) -> <Simd<Simd<[i128; 1]>> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: Simd<Simd<[i128; 1]>> ) -> <Simd<Simd<[i128; 1]>> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: Simd<Simd<[i128; 1]>>) -> Simd<Simd<[i128; 1]>>`

`pub fn simd_min(self, other: Simd<Simd<[i128; 1]>>) -> Simd<Simd<[i128; 1]>>`

`pub fn simd_clamp( self, min: Simd<Simd<[i128; 1]>>, max: Simd<Simd<[i128; 1]>> ) -> Simd<Simd<[i128; 1]>>`

`pub fn simd_horizontal_min( self ) -> <Simd<Simd<[i128; 1]>> as SimdValue>::Element`

`pub fn simd_horizontal_max( self ) -> <Simd<Simd<[i128; 1]>> as SimdValue>::Element`

`impl SimdPartialOrd for AutoSimd<[u16; 16]>`

`pub fn simd_gt( self, other: AutoSimd<[u16; 16]> ) -> <AutoSimd<[u16; 16]> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: AutoSimd<[u16; 16]> ) -> <AutoSimd<[u16; 16]> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: AutoSimd<[u16; 16]> ) -> <AutoSimd<[u16; 16]> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: AutoSimd<[u16; 16]> ) -> <AutoSimd<[u16; 16]> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: AutoSimd<[u16; 16]> ) -> <AutoSimd<[u16; 16]> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: AutoSimd<[u16; 16]> ) -> <AutoSimd<[u16; 16]> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: AutoSimd<[u16; 16]>) -> AutoSimd<[u16; 16]>`

`pub fn simd_min(self, other: AutoSimd<[u16; 16]>) -> AutoSimd<[u16; 16]>`

`pub fn simd_clamp( self, min: AutoSimd<[u16; 16]>, max: AutoSimd<[u16; 16]> ) -> AutoSimd<[u16; 16]>`

`pub fn simd_horizontal_min(self) -> <AutoSimd<[u16; 16]> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <AutoSimd<[u16; 16]> as SimdValue>::Element`

`impl SimdPartialOrd for AutoSimd<[i128; 1]>`

`pub fn simd_gt( self, other: AutoSimd<[i128; 1]> ) -> <AutoSimd<[i128; 1]> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: AutoSimd<[i128; 1]> ) -> <AutoSimd<[i128; 1]> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: AutoSimd<[i128; 1]> ) -> <AutoSimd<[i128; 1]> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: AutoSimd<[i128; 1]> ) -> <AutoSimd<[i128; 1]> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: AutoSimd<[i128; 1]> ) -> <AutoSimd<[i128; 1]> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: AutoSimd<[i128; 1]> ) -> <AutoSimd<[i128; 1]> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: AutoSimd<[i128; 1]>) -> AutoSimd<[i128; 1]>`

`pub fn simd_min(self, other: AutoSimd<[i128; 1]>) -> AutoSimd<[i128; 1]>`

`pub fn simd_clamp( self, min: AutoSimd<[i128; 1]>, max: AutoSimd<[i128; 1]> ) -> AutoSimd<[i128; 1]>`

`pub fn simd_horizontal_min(self) -> <AutoSimd<[i128; 1]> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <AutoSimd<[i128; 1]> as SimdValue>::Element`

`impl SimdPartialOrd for AutoSimd<[f32; 8]>`

`pub fn simd_gt( self, other: AutoSimd<[f32; 8]> ) -> <AutoSimd<[f32; 8]> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: AutoSimd<[f32; 8]> ) -> <AutoSimd<[f32; 8]> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: AutoSimd<[f32; 8]> ) -> <AutoSimd<[f32; 8]> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: AutoSimd<[f32; 8]> ) -> <AutoSimd<[f32; 8]> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: AutoSimd<[f32; 8]> ) -> <AutoSimd<[f32; 8]> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: AutoSimd<[f32; 8]> ) -> <AutoSimd<[f32; 8]> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: AutoSimd<[f32; 8]>) -> AutoSimd<[f32; 8]>`

`pub fn simd_min(self, other: AutoSimd<[f32; 8]>) -> AutoSimd<[f32; 8]>`

`pub fn simd_clamp( self, min: AutoSimd<[f32; 8]>, max: AutoSimd<[f32; 8]> ) -> AutoSimd<[f32; 8]>`

`pub fn simd_horizontal_min(self) -> <AutoSimd<[f32; 8]> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <AutoSimd<[f32; 8]> as SimdValue>::Element`

`impl SimdPartialOrd for Simd<Simd<[i8; 32]>>`

`pub fn simd_gt( self, other: Simd<Simd<[i8; 32]>> ) -> <Simd<Simd<[i8; 32]>> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: Simd<Simd<[i8; 32]>> ) -> <Simd<Simd<[i8; 32]>> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: Simd<Simd<[i8; 32]>> ) -> <Simd<Simd<[i8; 32]>> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: Simd<Simd<[i8; 32]>> ) -> <Simd<Simd<[i8; 32]>> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: Simd<Simd<[i8; 32]>> ) -> <Simd<Simd<[i8; 32]>> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: Simd<Simd<[i8; 32]>> ) -> <Simd<Simd<[i8; 32]>> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: Simd<Simd<[i8; 32]>>) -> Simd<Simd<[i8; 32]>>`

`pub fn simd_min(self, other: Simd<Simd<[i8; 32]>>) -> Simd<Simd<[i8; 32]>>`

`pub fn simd_clamp( self, min: Simd<Simd<[i8; 32]>>, max: Simd<Simd<[i8; 32]>> ) -> Simd<Simd<[i8; 32]>>`

`pub fn simd_horizontal_min(self) -> <Simd<Simd<[i8; 32]>> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <Simd<Simd<[i8; 32]>> as SimdValue>::Element`

`impl SimdPartialOrd for AutoSimd<[u16; 32]>`

`pub fn simd_gt( self, other: AutoSimd<[u16; 32]> ) -> <AutoSimd<[u16; 32]> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: AutoSimd<[u16; 32]> ) -> <AutoSimd<[u16; 32]> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: AutoSimd<[u16; 32]> ) -> <AutoSimd<[u16; 32]> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: AutoSimd<[u16; 32]> ) -> <AutoSimd<[u16; 32]> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: AutoSimd<[u16; 32]> ) -> <AutoSimd<[u16; 32]> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: AutoSimd<[u16; 32]> ) -> <AutoSimd<[u16; 32]> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: AutoSimd<[u16; 32]>) -> AutoSimd<[u16; 32]>`

`pub fn simd_min(self, other: AutoSimd<[u16; 32]>) -> AutoSimd<[u16; 32]>`

`pub fn simd_clamp( self, min: AutoSimd<[u16; 32]>, max: AutoSimd<[u16; 32]> ) -> AutoSimd<[u16; 32]>`

`pub fn simd_horizontal_min(self) -> <AutoSimd<[u16; 32]> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <AutoSimd<[u16; 32]> as SimdValue>::Element`

`impl SimdPartialOrd for AutoSimd<[i32; 2]>`

`pub fn simd_gt( self, other: AutoSimd<[i32; 2]> ) -> <AutoSimd<[i32; 2]> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: AutoSimd<[i32; 2]> ) -> <AutoSimd<[i32; 2]> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: AutoSimd<[i32; 2]> ) -> <AutoSimd<[i32; 2]> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: AutoSimd<[i32; 2]> ) -> <AutoSimd<[i32; 2]> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: AutoSimd<[i32; 2]> ) -> <AutoSimd<[i32; 2]> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: AutoSimd<[i32; 2]> ) -> <AutoSimd<[i32; 2]> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: AutoSimd<[i32; 2]>) -> AutoSimd<[i32; 2]>`

`pub fn simd_min(self, other: AutoSimd<[i32; 2]>) -> AutoSimd<[i32; 2]>`

`pub fn simd_clamp( self, min: AutoSimd<[i32; 2]>, max: AutoSimd<[i32; 2]> ) -> AutoSimd<[i32; 2]>`

`pub fn simd_horizontal_min(self) -> <AutoSimd<[i32; 2]> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <AutoSimd<[i32; 2]> as SimdValue>::Element`

`impl SimdPartialOrd for Simd<Simd<[i8; 4]>>`

`pub fn simd_gt( self, other: Simd<Simd<[i8; 4]>> ) -> <Simd<Simd<[i8; 4]>> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: Simd<Simd<[i8; 4]>> ) -> <Simd<Simd<[i8; 4]>> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: Simd<Simd<[i8; 4]>> ) -> <Simd<Simd<[i8; 4]>> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: Simd<Simd<[i8; 4]>> ) -> <Simd<Simd<[i8; 4]>> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: Simd<Simd<[i8; 4]>> ) -> <Simd<Simd<[i8; 4]>> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: Simd<Simd<[i8; 4]>> ) -> <Simd<Simd<[i8; 4]>> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: Simd<Simd<[i8; 4]>>) -> Simd<Simd<[i8; 4]>>`

`pub fn simd_min(self, other: Simd<Simd<[i8; 4]>>) -> Simd<Simd<[i8; 4]>>`

`pub fn simd_clamp( self, min: Simd<Simd<[i8; 4]>>, max: Simd<Simd<[i8; 4]>> ) -> Simd<Simd<[i8; 4]>>`

`pub fn simd_horizontal_min(self) -> <Simd<Simd<[i8; 4]>> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <Simd<Simd<[i8; 4]>> as SimdValue>::Element`

`impl SimdPartialOrd for AutoSimd<[u32; 16]>`

`pub fn simd_gt( self, other: AutoSimd<[u32; 16]> ) -> <AutoSimd<[u32; 16]> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: AutoSimd<[u32; 16]> ) -> <AutoSimd<[u32; 16]> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: AutoSimd<[u32; 16]> ) -> <AutoSimd<[u32; 16]> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: AutoSimd<[u32; 16]> ) -> <AutoSimd<[u32; 16]> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: AutoSimd<[u32; 16]> ) -> <AutoSimd<[u32; 16]> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: AutoSimd<[u32; 16]> ) -> <AutoSimd<[u32; 16]> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: AutoSimd<[u32; 16]>) -> AutoSimd<[u32; 16]>`

`pub fn simd_min(self, other: AutoSimd<[u32; 16]>) -> AutoSimd<[u32; 16]>`

`pub fn simd_clamp( self, min: AutoSimd<[u32; 16]>, max: AutoSimd<[u32; 16]> ) -> AutoSimd<[u32; 16]>`

`pub fn simd_horizontal_min(self) -> <AutoSimd<[u32; 16]> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <AutoSimd<[u32; 16]> as SimdValue>::Element`

`impl SimdPartialOrd for AutoSimd<[isize; 4]>`

`pub fn simd_gt( self, other: AutoSimd<[isize; 4]> ) -> <AutoSimd<[isize; 4]> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: AutoSimd<[isize; 4]> ) -> <AutoSimd<[isize; 4]> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: AutoSimd<[isize; 4]> ) -> <AutoSimd<[isize; 4]> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: AutoSimd<[isize; 4]> ) -> <AutoSimd<[isize; 4]> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: AutoSimd<[isize; 4]> ) -> <AutoSimd<[isize; 4]> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: AutoSimd<[isize; 4]> ) -> <AutoSimd<[isize; 4]> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: AutoSimd<[isize; 4]>) -> AutoSimd<[isize; 4]>`

`pub fn simd_min(self, other: AutoSimd<[isize; 4]>) -> AutoSimd<[isize; 4]>`

`pub fn simd_clamp( self, min: AutoSimd<[isize; 4]>, max: AutoSimd<[isize; 4]> ) -> AutoSimd<[isize; 4]>`

`pub fn simd_horizontal_min(self) -> <AutoSimd<[isize; 4]> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <AutoSimd<[isize; 4]> as SimdValue>::Element`

`impl SimdPartialOrd for AutoSimd<[i32; 16]>`

`pub fn simd_gt( self, other: AutoSimd<[i32; 16]> ) -> <AutoSimd<[i32; 16]> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: AutoSimd<[i32; 16]> ) -> <AutoSimd<[i32; 16]> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: AutoSimd<[i32; 16]> ) -> <AutoSimd<[i32; 16]> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: AutoSimd<[i32; 16]> ) -> <AutoSimd<[i32; 16]> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: AutoSimd<[i32; 16]> ) -> <AutoSimd<[i32; 16]> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: AutoSimd<[i32; 16]> ) -> <AutoSimd<[i32; 16]> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: AutoSimd<[i32; 16]>) -> AutoSimd<[i32; 16]>`

`pub fn simd_min(self, other: AutoSimd<[i32; 16]>) -> AutoSimd<[i32; 16]>`

`pub fn simd_clamp( self, min: AutoSimd<[i32; 16]>, max: AutoSimd<[i32; 16]> ) -> AutoSimd<[i32; 16]>`

`pub fn simd_horizontal_min(self) -> <AutoSimd<[i32; 16]> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <AutoSimd<[i32; 16]> as SimdValue>::Element`

`impl SimdPartialOrd for Simd<Simd<[i64; 8]>>`

`pub fn simd_gt( self, other: Simd<Simd<[i64; 8]>> ) -> <Simd<Simd<[i64; 8]>> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: Simd<Simd<[i64; 8]>> ) -> <Simd<Simd<[i64; 8]>> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: Simd<Simd<[i64; 8]>> ) -> <Simd<Simd<[i64; 8]>> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: Simd<Simd<[i64; 8]>> ) -> <Simd<Simd<[i64; 8]>> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: Simd<Simd<[i64; 8]>> ) -> <Simd<Simd<[i64; 8]>> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: Simd<Simd<[i64; 8]>> ) -> <Simd<Simd<[i64; 8]>> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: Simd<Simd<[i64; 8]>>) -> Simd<Simd<[i64; 8]>>`

`pub fn simd_min(self, other: Simd<Simd<[i64; 8]>>) -> Simd<Simd<[i64; 8]>>`

`pub fn simd_clamp( self, min: Simd<Simd<[i64; 8]>>, max: Simd<Simd<[i64; 8]>> ) -> Simd<Simd<[i64; 8]>>`

`pub fn simd_horizontal_min(self) -> <Simd<Simd<[i64; 8]>> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <Simd<Simd<[i64; 8]>> as SimdValue>::Element`

`impl SimdPartialOrd for Simd<Simd<[f64; 8]>>`

`pub fn simd_gt( self, other: Simd<Simd<[f64; 8]>> ) -> <Simd<Simd<[f64; 8]>> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: Simd<Simd<[f64; 8]>> ) -> <Simd<Simd<[f64; 8]>> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: Simd<Simd<[f64; 8]>> ) -> <Simd<Simd<[f64; 8]>> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: Simd<Simd<[f64; 8]>> ) -> <Simd<Simd<[f64; 8]>> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: Simd<Simd<[f64; 8]>> ) -> <Simd<Simd<[f64; 8]>> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: Simd<Simd<[f64; 8]>> ) -> <Simd<Simd<[f64; 8]>> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: Simd<Simd<[f64; 8]>>) -> Simd<Simd<[f64; 8]>>`

`pub fn simd_min(self, other: Simd<Simd<[f64; 8]>>) -> Simd<Simd<[f64; 8]>>`

`pub fn simd_clamp( self, min: Simd<Simd<[f64; 8]>>, max: Simd<Simd<[f64; 8]>> ) -> Simd<Simd<[f64; 8]>>`

`pub fn simd_horizontal_min(self) -> <Simd<Simd<[f64; 8]>> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <Simd<Simd<[f64; 8]>> as SimdValue>::Element`

`impl SimdPartialOrd for AutoSimd<[i64; 4]>`

`pub fn simd_gt( self, other: AutoSimd<[i64; 4]> ) -> <AutoSimd<[i64; 4]> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: AutoSimd<[i64; 4]> ) -> <AutoSimd<[i64; 4]> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: AutoSimd<[i64; 4]> ) -> <AutoSimd<[i64; 4]> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: AutoSimd<[i64; 4]> ) -> <AutoSimd<[i64; 4]> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: AutoSimd<[i64; 4]> ) -> <AutoSimd<[i64; 4]> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: AutoSimd<[i64; 4]> ) -> <AutoSimd<[i64; 4]> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: AutoSimd<[i64; 4]>) -> AutoSimd<[i64; 4]>`

`pub fn simd_min(self, other: AutoSimd<[i64; 4]>) -> AutoSimd<[i64; 4]>`

`pub fn simd_clamp( self, min: AutoSimd<[i64; 4]>, max: AutoSimd<[i64; 4]> ) -> AutoSimd<[i64; 4]>`

`pub fn simd_horizontal_min(self) -> <AutoSimd<[i64; 4]> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <AutoSimd<[i64; 4]> as SimdValue>::Element`

`impl SimdPartialOrd for Simd<Simd<[u128; 2]>>`

`pub fn simd_gt( self, other: Simd<Simd<[u128; 2]>> ) -> <Simd<Simd<[u128; 2]>> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: Simd<Simd<[u128; 2]>> ) -> <Simd<Simd<[u128; 2]>> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: Simd<Simd<[u128; 2]>> ) -> <Simd<Simd<[u128; 2]>> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: Simd<Simd<[u128; 2]>> ) -> <Simd<Simd<[u128; 2]>> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: Simd<Simd<[u128; 2]>> ) -> <Simd<Simd<[u128; 2]>> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: Simd<Simd<[u128; 2]>> ) -> <Simd<Simd<[u128; 2]>> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: Simd<Simd<[u128; 2]>>) -> Simd<Simd<[u128; 2]>>`

`pub fn simd_min(self, other: Simd<Simd<[u128; 2]>>) -> Simd<Simd<[u128; 2]>>`

`pub fn simd_clamp( self, min: Simd<Simd<[u128; 2]>>, max: Simd<Simd<[u128; 2]>> ) -> Simd<Simd<[u128; 2]>>`

`pub fn simd_horizontal_min( self ) -> <Simd<Simd<[u128; 2]>> as SimdValue>::Element`

`pub fn simd_horizontal_max( self ) -> <Simd<Simd<[u128; 2]>> as SimdValue>::Element`

`impl SimdPartialOrd for AutoSimd<[u64; 2]>`

`pub fn simd_gt( self, other: AutoSimd<[u64; 2]> ) -> <AutoSimd<[u64; 2]> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: AutoSimd<[u64; 2]> ) -> <AutoSimd<[u64; 2]> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: AutoSimd<[u64; 2]> ) -> <AutoSimd<[u64; 2]> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: AutoSimd<[u64; 2]> ) -> <AutoSimd<[u64; 2]> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: AutoSimd<[u64; 2]> ) -> <AutoSimd<[u64; 2]> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: AutoSimd<[u64; 2]> ) -> <AutoSimd<[u64; 2]> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: AutoSimd<[u64; 2]>) -> AutoSimd<[u64; 2]>`

`pub fn simd_min(self, other: AutoSimd<[u64; 2]>) -> AutoSimd<[u64; 2]>`

`pub fn simd_clamp( self, min: AutoSimd<[u64; 2]>, max: AutoSimd<[u64; 2]> ) -> AutoSimd<[u64; 2]>`

`pub fn simd_horizontal_min(self) -> <AutoSimd<[u64; 2]> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <AutoSimd<[u64; 2]> as SimdValue>::Element`

`impl SimdPartialOrd for Simd<Simd<[u16; 16]>>`

`pub fn simd_gt( self, other: Simd<Simd<[u16; 16]>> ) -> <Simd<Simd<[u16; 16]>> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: Simd<Simd<[u16; 16]>> ) -> <Simd<Simd<[u16; 16]>> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: Simd<Simd<[u16; 16]>> ) -> <Simd<Simd<[u16; 16]>> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: Simd<Simd<[u16; 16]>> ) -> <Simd<Simd<[u16; 16]>> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: Simd<Simd<[u16; 16]>> ) -> <Simd<Simd<[u16; 16]>> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: Simd<Simd<[u16; 16]>> ) -> <Simd<Simd<[u16; 16]>> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: Simd<Simd<[u16; 16]>>) -> Simd<Simd<[u16; 16]>>`

`pub fn simd_min(self, other: Simd<Simd<[u16; 16]>>) -> Simd<Simd<[u16; 16]>>`

`pub fn simd_clamp( self, min: Simd<Simd<[u16; 16]>>, max: Simd<Simd<[u16; 16]>> ) -> Simd<Simd<[u16; 16]>>`

`pub fn simd_horizontal_min( self ) -> <Simd<Simd<[u16; 16]>> as SimdValue>::Element`

`pub fn simd_horizontal_max( self ) -> <Simd<Simd<[u16; 16]>> as SimdValue>::Element`

`impl SimdPartialOrd for Simd<Simd<[f32; 2]>>`

`pub fn simd_gt( self, other: Simd<Simd<[f32; 2]>> ) -> <Simd<Simd<[f32; 2]>> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: Simd<Simd<[f32; 2]>> ) -> <Simd<Simd<[f32; 2]>> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: Simd<Simd<[f32; 2]>> ) -> <Simd<Simd<[f32; 2]>> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: Simd<Simd<[f32; 2]>> ) -> <Simd<Simd<[f32; 2]>> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: Simd<Simd<[f32; 2]>> ) -> <Simd<Simd<[f32; 2]>> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: Simd<Simd<[f32; 2]>> ) -> <Simd<Simd<[f32; 2]>> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: Simd<Simd<[f32; 2]>>) -> Simd<Simd<[f32; 2]>>`

`pub fn simd_min(self, other: Simd<Simd<[f32; 2]>>) -> Simd<Simd<[f32; 2]>>`

`pub fn simd_clamp( self, min: Simd<Simd<[f32; 2]>>, max: Simd<Simd<[f32; 2]>> ) -> Simd<Simd<[f32; 2]>>`

`pub fn simd_horizontal_min(self) -> <Simd<Simd<[f32; 2]>> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <Simd<Simd<[f32; 2]>> as SimdValue>::Element`

`impl SimdPartialOrd for AutoSimd<[i128; 4]>`

`pub fn simd_gt( self, other: AutoSimd<[i128; 4]> ) -> <AutoSimd<[i128; 4]> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: AutoSimd<[i128; 4]> ) -> <AutoSimd<[i128; 4]> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: AutoSimd<[i128; 4]> ) -> <AutoSimd<[i128; 4]> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: AutoSimd<[i128; 4]> ) -> <AutoSimd<[i128; 4]> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: AutoSimd<[i128; 4]> ) -> <AutoSimd<[i128; 4]> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: AutoSimd<[i128; 4]> ) -> <AutoSimd<[i128; 4]> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: AutoSimd<[i128; 4]>) -> AutoSimd<[i128; 4]>`

`pub fn simd_min(self, other: AutoSimd<[i128; 4]>) -> AutoSimd<[i128; 4]>`

`pub fn simd_clamp( self, min: AutoSimd<[i128; 4]>, max: AutoSimd<[i128; 4]> ) -> AutoSimd<[i128; 4]>`

`pub fn simd_horizontal_min(self) -> <AutoSimd<[i128; 4]> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <AutoSimd<[i128; 4]> as SimdValue>::Element`

`impl SimdPartialOrd for AutoSimd<[i8; 16]>`

`pub fn simd_gt( self, other: AutoSimd<[i8; 16]> ) -> <AutoSimd<[i8; 16]> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: AutoSimd<[i8; 16]> ) -> <AutoSimd<[i8; 16]> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: AutoSimd<[i8; 16]> ) -> <AutoSimd<[i8; 16]> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: AutoSimd<[i8; 16]> ) -> <AutoSimd<[i8; 16]> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: AutoSimd<[i8; 16]> ) -> <AutoSimd<[i8; 16]> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: AutoSimd<[i8; 16]> ) -> <AutoSimd<[i8; 16]> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: AutoSimd<[i8; 16]>) -> AutoSimd<[i8; 16]>`

`pub fn simd_min(self, other: AutoSimd<[i8; 16]>) -> AutoSimd<[i8; 16]>`

`pub fn simd_clamp( self, min: AutoSimd<[i8; 16]>, max: AutoSimd<[i8; 16]> ) -> AutoSimd<[i8; 16]>`

`pub fn simd_horizontal_min(self) -> <AutoSimd<[i8; 16]> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <AutoSimd<[i8; 16]> as SimdValue>::Element`

`impl SimdPartialOrd for AutoSimd<[f32; 16]>`

`pub fn simd_gt( self, other: AutoSimd<[f32; 16]> ) -> <AutoSimd<[f32; 16]> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: AutoSimd<[f32; 16]> ) -> <AutoSimd<[f32; 16]> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: AutoSimd<[f32; 16]> ) -> <AutoSimd<[f32; 16]> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: AutoSimd<[f32; 16]> ) -> <AutoSimd<[f32; 16]> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: AutoSimd<[f32; 16]> ) -> <AutoSimd<[f32; 16]> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: AutoSimd<[f32; 16]> ) -> <AutoSimd<[f32; 16]> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: AutoSimd<[f32; 16]>) -> AutoSimd<[f32; 16]>`

`pub fn simd_min(self, other: AutoSimd<[f32; 16]>) -> AutoSimd<[f32; 16]>`

`pub fn simd_clamp( self, min: AutoSimd<[f32; 16]>, max: AutoSimd<[f32; 16]> ) -> AutoSimd<[f32; 16]>`

`pub fn simd_horizontal_min(self) -> <AutoSimd<[f32; 16]> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <AutoSimd<[f32; 16]> as SimdValue>::Element`

`impl SimdPartialOrd for Simd<Simd<[u8; 64]>>`

`pub fn simd_gt( self, other: Simd<Simd<[u8; 64]>> ) -> <Simd<Simd<[u8; 64]>> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: Simd<Simd<[u8; 64]>> ) -> <Simd<Simd<[u8; 64]>> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: Simd<Simd<[u8; 64]>> ) -> <Simd<Simd<[u8; 64]>> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: Simd<Simd<[u8; 64]>> ) -> <Simd<Simd<[u8; 64]>> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: Simd<Simd<[u8; 64]>> ) -> <Simd<Simd<[u8; 64]>> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: Simd<Simd<[u8; 64]>> ) -> <Simd<Simd<[u8; 64]>> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: Simd<Simd<[u8; 64]>>) -> Simd<Simd<[u8; 64]>>`

`pub fn simd_min(self, other: Simd<Simd<[u8; 64]>>) -> Simd<Simd<[u8; 64]>>`

`pub fn simd_clamp( self, min: Simd<Simd<[u8; 64]>>, max: Simd<Simd<[u8; 64]>> ) -> Simd<Simd<[u8; 64]>>`

`pub fn simd_horizontal_min(self) -> <Simd<Simd<[u8; 64]>> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <Simd<Simd<[u8; 64]>> as SimdValue>::Element`

`impl SimdPartialOrd for AutoSimd<[u128; 2]>`

`pub fn simd_gt( self, other: AutoSimd<[u128; 2]> ) -> <AutoSimd<[u128; 2]> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: AutoSimd<[u128; 2]> ) -> <AutoSimd<[u128; 2]> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: AutoSimd<[u128; 2]> ) -> <AutoSimd<[u128; 2]> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: AutoSimd<[u128; 2]> ) -> <AutoSimd<[u128; 2]> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: AutoSimd<[u128; 2]> ) -> <AutoSimd<[u128; 2]> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: AutoSimd<[u128; 2]> ) -> <AutoSimd<[u128; 2]> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: AutoSimd<[u128; 2]>) -> AutoSimd<[u128; 2]>`

`pub fn simd_min(self, other: AutoSimd<[u128; 2]>) -> AutoSimd<[u128; 2]>`

`pub fn simd_clamp( self, min: AutoSimd<[u128; 2]>, max: AutoSimd<[u128; 2]> ) -> AutoSimd<[u128; 2]>`

`pub fn simd_horizontal_min(self) -> <AutoSimd<[u128; 2]> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <AutoSimd<[u128; 2]> as SimdValue>::Element`

`impl SimdPartialOrd for Simd<Simd<[i8; 8]>>`

`pub fn simd_gt( self, other: Simd<Simd<[i8; 8]>> ) -> <Simd<Simd<[i8; 8]>> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: Simd<Simd<[i8; 8]>> ) -> <Simd<Simd<[i8; 8]>> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: Simd<Simd<[i8; 8]>> ) -> <Simd<Simd<[i8; 8]>> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: Simd<Simd<[i8; 8]>> ) -> <Simd<Simd<[i8; 8]>> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: Simd<Simd<[i8; 8]>> ) -> <Simd<Simd<[i8; 8]>> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: Simd<Simd<[i8; 8]>> ) -> <Simd<Simd<[i8; 8]>> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: Simd<Simd<[i8; 8]>>) -> Simd<Simd<[i8; 8]>>`

`pub fn simd_min(self, other: Simd<Simd<[i8; 8]>>) -> Simd<Simd<[i8; 8]>>`

`pub fn simd_clamp( self, min: Simd<Simd<[i8; 8]>>, max: Simd<Simd<[i8; 8]>> ) -> Simd<Simd<[i8; 8]>>`

`pub fn simd_horizontal_min(self) -> <Simd<Simd<[i8; 8]>> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <Simd<Simd<[i8; 8]>> as SimdValue>::Element`

`impl SimdPartialOrd for Simd<Simd<[u16; 8]>>`

`pub fn simd_gt( self, other: Simd<Simd<[u16; 8]>> ) -> <Simd<Simd<[u16; 8]>> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: Simd<Simd<[u16; 8]>> ) -> <Simd<Simd<[u16; 8]>> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: Simd<Simd<[u16; 8]>> ) -> <Simd<Simd<[u16; 8]>> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: Simd<Simd<[u16; 8]>> ) -> <Simd<Simd<[u16; 8]>> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: Simd<Simd<[u16; 8]>> ) -> <Simd<Simd<[u16; 8]>> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: Simd<Simd<[u16; 8]>> ) -> <Simd<Simd<[u16; 8]>> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: Simd<Simd<[u16; 8]>>) -> Simd<Simd<[u16; 8]>>`

`pub fn simd_min(self, other: Simd<Simd<[u16; 8]>>) -> Simd<Simd<[u16; 8]>>`

`pub fn simd_clamp( self, min: Simd<Simd<[u16; 8]>>, max: Simd<Simd<[u16; 8]>> ) -> Simd<Simd<[u16; 8]>>`

`pub fn simd_horizontal_min(self) -> <Simd<Simd<[u16; 8]>> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <Simd<Simd<[u16; 8]>> as SimdValue>::Element`

`impl SimdPartialOrd for AutoSimd<[u128; 4]>`

`pub fn simd_gt( self, other: AutoSimd<[u128; 4]> ) -> <AutoSimd<[u128; 4]> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: AutoSimd<[u128; 4]> ) -> <AutoSimd<[u128; 4]> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: AutoSimd<[u128; 4]> ) -> <AutoSimd<[u128; 4]> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: AutoSimd<[u128; 4]> ) -> <AutoSimd<[u128; 4]> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: AutoSimd<[u128; 4]> ) -> <AutoSimd<[u128; 4]> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: AutoSimd<[u128; 4]> ) -> <AutoSimd<[u128; 4]> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: AutoSimd<[u128; 4]>) -> AutoSimd<[u128; 4]>`

`pub fn simd_min(self, other: AutoSimd<[u128; 4]>) -> AutoSimd<[u128; 4]>`

`pub fn simd_clamp( self, min: AutoSimd<[u128; 4]>, max: AutoSimd<[u128; 4]> ) -> AutoSimd<[u128; 4]>`

`pub fn simd_horizontal_min(self) -> <AutoSimd<[u128; 4]> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <AutoSimd<[u128; 4]> as SimdValue>::Element`

`impl SimdPartialOrd for AutoSimd<[i8; 2]>`

`pub fn simd_gt( self, other: AutoSimd<[i8; 2]> ) -> <AutoSimd<[i8; 2]> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: AutoSimd<[i8; 2]> ) -> <AutoSimd<[i8; 2]> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: AutoSimd<[i8; 2]> ) -> <AutoSimd<[i8; 2]> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: AutoSimd<[i8; 2]> ) -> <AutoSimd<[i8; 2]> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: AutoSimd<[i8; 2]> ) -> <AutoSimd<[i8; 2]> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: AutoSimd<[i8; 2]> ) -> <AutoSimd<[i8; 2]> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: AutoSimd<[i8; 2]>) -> AutoSimd<[i8; 2]>`

`pub fn simd_min(self, other: AutoSimd<[i8; 2]>) -> AutoSimd<[i8; 2]>`

`pub fn simd_clamp( self, min: AutoSimd<[i8; 2]>, max: AutoSimd<[i8; 2]> ) -> AutoSimd<[i8; 2]>`

`pub fn simd_horizontal_min(self) -> <AutoSimd<[i8; 2]> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <AutoSimd<[i8; 2]> as SimdValue>::Element`

`impl SimdPartialOrd for AutoSimd<[u8; 8]>`

`pub fn simd_gt( self, other: AutoSimd<[u8; 8]> ) -> <AutoSimd<[u8; 8]> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: AutoSimd<[u8; 8]> ) -> <AutoSimd<[u8; 8]> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: AutoSimd<[u8; 8]> ) -> <AutoSimd<[u8; 8]> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: AutoSimd<[u8; 8]> ) -> <AutoSimd<[u8; 8]> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: AutoSimd<[u8; 8]> ) -> <AutoSimd<[u8; 8]> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: AutoSimd<[u8; 8]> ) -> <AutoSimd<[u8; 8]> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: AutoSimd<[u8; 8]>) -> AutoSimd<[u8; 8]>`

`pub fn simd_min(self, other: AutoSimd<[u8; 8]>) -> AutoSimd<[u8; 8]>`

`pub fn simd_clamp( self, min: AutoSimd<[u8; 8]>, max: AutoSimd<[u8; 8]> ) -> AutoSimd<[u8; 8]>`

`pub fn simd_horizontal_min(self) -> <AutoSimd<[u8; 8]> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <AutoSimd<[u8; 8]> as SimdValue>::Element`

`impl SimdPartialOrd for Simd<Simd<[u8; 4]>>`

`pub fn simd_gt( self, other: Simd<Simd<[u8; 4]>> ) -> <Simd<Simd<[u8; 4]>> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: Simd<Simd<[u8; 4]>> ) -> <Simd<Simd<[u8; 4]>> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: Simd<Simd<[u8; 4]>> ) -> <Simd<Simd<[u8; 4]>> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: Simd<Simd<[u8; 4]>> ) -> <Simd<Simd<[u8; 4]>> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: Simd<Simd<[u8; 4]>> ) -> <Simd<Simd<[u8; 4]>> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: Simd<Simd<[u8; 4]>> ) -> <Simd<Simd<[u8; 4]>> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: Simd<Simd<[u8; 4]>>) -> Simd<Simd<[u8; 4]>>`

`pub fn simd_min(self, other: Simd<Simd<[u8; 4]>>) -> Simd<Simd<[u8; 4]>>`

`pub fn simd_clamp( self, min: Simd<Simd<[u8; 4]>>, max: Simd<Simd<[u8; 4]>> ) -> Simd<Simd<[u8; 4]>>`

`pub fn simd_horizontal_min(self) -> <Simd<Simd<[u8; 4]>> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <Simd<Simd<[u8; 4]>> as SimdValue>::Element`

`impl SimdPartialOrd for Simd<Simd<[f64; 2]>>`

`pub fn simd_gt( self, other: Simd<Simd<[f64; 2]>> ) -> <Simd<Simd<[f64; 2]>> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: Simd<Simd<[f64; 2]>> ) -> <Simd<Simd<[f64; 2]>> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: Simd<Simd<[f64; 2]>> ) -> <Simd<Simd<[f64; 2]>> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: Simd<Simd<[f64; 2]>> ) -> <Simd<Simd<[f64; 2]>> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: Simd<Simd<[f64; 2]>> ) -> <Simd<Simd<[f64; 2]>> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: Simd<Simd<[f64; 2]>> ) -> <Simd<Simd<[f64; 2]>> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: Simd<Simd<[f64; 2]>>) -> Simd<Simd<[f64; 2]>>`

`pub fn simd_min(self, other: Simd<Simd<[f64; 2]>>) -> Simd<Simd<[f64; 2]>>`

`pub fn simd_clamp( self, min: Simd<Simd<[f64; 2]>>, max: Simd<Simd<[f64; 2]>> ) -> Simd<Simd<[f64; 2]>>`

`pub fn simd_horizontal_min(self) -> <Simd<Simd<[f64; 2]>> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <Simd<Simd<[f64; 2]>> as SimdValue>::Element`

`impl SimdPartialOrd for Simd<Simd<[i8; 64]>>`

`pub fn simd_gt( self, other: Simd<Simd<[i8; 64]>> ) -> <Simd<Simd<[i8; 64]>> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: Simd<Simd<[i8; 64]>> ) -> <Simd<Simd<[i8; 64]>> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: Simd<Simd<[i8; 64]>> ) -> <Simd<Simd<[i8; 64]>> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: Simd<Simd<[i8; 64]>> ) -> <Simd<Simd<[i8; 64]>> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: Simd<Simd<[i8; 64]>> ) -> <Simd<Simd<[i8; 64]>> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: Simd<Simd<[i8; 64]>> ) -> <Simd<Simd<[i8; 64]>> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: Simd<Simd<[i8; 64]>>) -> Simd<Simd<[i8; 64]>>`

`pub fn simd_min(self, other: Simd<Simd<[i8; 64]>>) -> Simd<Simd<[i8; 64]>>`

`pub fn simd_clamp( self, min: Simd<Simd<[i8; 64]>>, max: Simd<Simd<[i8; 64]>> ) -> Simd<Simd<[i8; 64]>>`

`pub fn simd_horizontal_min(self) -> <Simd<Simd<[i8; 64]>> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <Simd<Simd<[i8; 64]>> as SimdValue>::Element`

`impl SimdPartialOrd for AutoSimd<[usize; 2]>`

`pub fn simd_gt( self, other: AutoSimd<[usize; 2]> ) -> <AutoSimd<[usize; 2]> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: AutoSimd<[usize; 2]> ) -> <AutoSimd<[usize; 2]> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: AutoSimd<[usize; 2]> ) -> <AutoSimd<[usize; 2]> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: AutoSimd<[usize; 2]> ) -> <AutoSimd<[usize; 2]> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: AutoSimd<[usize; 2]> ) -> <AutoSimd<[usize; 2]> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: AutoSimd<[usize; 2]> ) -> <AutoSimd<[usize; 2]> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: AutoSimd<[usize; 2]>) -> AutoSimd<[usize; 2]>`

`pub fn simd_min(self, other: AutoSimd<[usize; 2]>) -> AutoSimd<[usize; 2]>`

`pub fn simd_clamp( self, min: AutoSimd<[usize; 2]>, max: AutoSimd<[usize; 2]> ) -> AutoSimd<[usize; 2]>`

`pub fn simd_horizontal_min(self) -> <AutoSimd<[usize; 2]> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <AutoSimd<[usize; 2]> as SimdValue>::Element`

`impl SimdPartialOrd for Simd<Simd<[u32; 16]>>`

`pub fn simd_gt( self, other: Simd<Simd<[u32; 16]>> ) -> <Simd<Simd<[u32; 16]>> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: Simd<Simd<[u32; 16]>> ) -> <Simd<Simd<[u32; 16]>> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: Simd<Simd<[u32; 16]>> ) -> <Simd<Simd<[u32; 16]>> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: Simd<Simd<[u32; 16]>> ) -> <Simd<Simd<[u32; 16]>> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: Simd<Simd<[u32; 16]>> ) -> <Simd<Simd<[u32; 16]>> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: Simd<Simd<[u32; 16]>> ) -> <Simd<Simd<[u32; 16]>> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: Simd<Simd<[u32; 16]>>) -> Simd<Simd<[u32; 16]>>`

`pub fn simd_min(self, other: Simd<Simd<[u32; 16]>>) -> Simd<Simd<[u32; 16]>>`

`pub fn simd_clamp( self, min: Simd<Simd<[u32; 16]>>, max: Simd<Simd<[u32; 16]>> ) -> Simd<Simd<[u32; 16]>>`

`pub fn simd_horizontal_min( self ) -> <Simd<Simd<[u32; 16]>> as SimdValue>::Element`

`pub fn simd_horizontal_max( self ) -> <Simd<Simd<[u32; 16]>> as SimdValue>::Element`

`impl SimdPartialOrd for AutoSimd<[u16; 4]>`

`pub fn simd_gt( self, other: AutoSimd<[u16; 4]> ) -> <AutoSimd<[u16; 4]> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: AutoSimd<[u16; 4]> ) -> <AutoSimd<[u16; 4]> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: AutoSimd<[u16; 4]> ) -> <AutoSimd<[u16; 4]> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: AutoSimd<[u16; 4]> ) -> <AutoSimd<[u16; 4]> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: AutoSimd<[u16; 4]> ) -> <AutoSimd<[u16; 4]> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: AutoSimd<[u16; 4]> ) -> <AutoSimd<[u16; 4]> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: AutoSimd<[u16; 4]>) -> AutoSimd<[u16; 4]>`

`pub fn simd_min(self, other: AutoSimd<[u16; 4]>) -> AutoSimd<[u16; 4]>`

`pub fn simd_clamp( self, min: AutoSimd<[u16; 4]>, max: AutoSimd<[u16; 4]> ) -> AutoSimd<[u16; 4]>`

`pub fn simd_horizontal_min(self) -> <AutoSimd<[u16; 4]> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <AutoSimd<[u16; 4]> as SimdValue>::Element`

`impl SimdPartialOrd for Simd<Simd<[i32; 8]>>`

`pub fn simd_gt( self, other: Simd<Simd<[i32; 8]>> ) -> <Simd<Simd<[i32; 8]>> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: Simd<Simd<[i32; 8]>> ) -> <Simd<Simd<[i32; 8]>> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: Simd<Simd<[i32; 8]>> ) -> <Simd<Simd<[i32; 8]>> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: Simd<Simd<[i32; 8]>> ) -> <Simd<Simd<[i32; 8]>> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: Simd<Simd<[i32; 8]>> ) -> <Simd<Simd<[i32; 8]>> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: Simd<Simd<[i32; 8]>> ) -> <Simd<Simd<[i32; 8]>> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: Simd<Simd<[i32; 8]>>) -> Simd<Simd<[i32; 8]>>`

`pub fn simd_min(self, other: Simd<Simd<[i32; 8]>>) -> Simd<Simd<[i32; 8]>>`

`pub fn simd_clamp( self, min: Simd<Simd<[i32; 8]>>, max: Simd<Simd<[i32; 8]>> ) -> Simd<Simd<[i32; 8]>>`

`pub fn simd_horizontal_min(self) -> <Simd<Simd<[i32; 8]>> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <Simd<Simd<[i32; 8]>> as SimdValue>::Element`

`impl SimdPartialOrd for AutoSimd<[usize; 8]>`

`pub fn simd_gt( self, other: AutoSimd<[usize; 8]> ) -> <AutoSimd<[usize; 8]> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: AutoSimd<[usize; 8]> ) -> <AutoSimd<[usize; 8]> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: AutoSimd<[usize; 8]> ) -> <AutoSimd<[usize; 8]> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: AutoSimd<[usize; 8]> ) -> <AutoSimd<[usize; 8]> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: AutoSimd<[usize; 8]> ) -> <AutoSimd<[usize; 8]> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: AutoSimd<[usize; 8]> ) -> <AutoSimd<[usize; 8]> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: AutoSimd<[usize; 8]>) -> AutoSimd<[usize; 8]>`

`pub fn simd_min(self, other: AutoSimd<[usize; 8]>) -> AutoSimd<[usize; 8]>`

`pub fn simd_clamp( self, min: AutoSimd<[usize; 8]>, max: AutoSimd<[usize; 8]> ) -> AutoSimd<[usize; 8]>`

`pub fn simd_horizontal_min(self) -> <AutoSimd<[usize; 8]> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <AutoSimd<[usize; 8]> as SimdValue>::Element`

`impl SimdPartialOrd for Simd<Simd<[f64; 4]>>`

`pub fn simd_gt( self, other: Simd<Simd<[f64; 4]>> ) -> <Simd<Simd<[f64; 4]>> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: Simd<Simd<[f64; 4]>> ) -> <Simd<Simd<[f64; 4]>> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: Simd<Simd<[f64; 4]>> ) -> <Simd<Simd<[f64; 4]>> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: Simd<Simd<[f64; 4]>> ) -> <Simd<Simd<[f64; 4]>> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: Simd<Simd<[f64; 4]>> ) -> <Simd<Simd<[f64; 4]>> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: Simd<Simd<[f64; 4]>> ) -> <Simd<Simd<[f64; 4]>> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: Simd<Simd<[f64; 4]>>) -> Simd<Simd<[f64; 4]>>`

`pub fn simd_min(self, other: Simd<Simd<[f64; 4]>>) -> Simd<Simd<[f64; 4]>>`

`pub fn simd_clamp( self, min: Simd<Simd<[f64; 4]>>, max: Simd<Simd<[f64; 4]>> ) -> Simd<Simd<[f64; 4]>>`

`pub fn simd_horizontal_min(self) -> <Simd<Simd<[f64; 4]>> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <Simd<Simd<[f64; 4]>> as SimdValue>::Element`

`impl SimdPartialOrd for Simd<Simd<[isize; 4]>>`

`pub fn simd_gt( self, other: Simd<Simd<[isize; 4]>> ) -> <Simd<Simd<[isize; 4]>> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: Simd<Simd<[isize; 4]>> ) -> <Simd<Simd<[isize; 4]>> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: Simd<Simd<[isize; 4]>> ) -> <Simd<Simd<[isize; 4]>> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: Simd<Simd<[isize; 4]>> ) -> <Simd<Simd<[isize; 4]>> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: Simd<Simd<[isize; 4]>> ) -> <Simd<Simd<[isize; 4]>> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: Simd<Simd<[isize; 4]>> ) -> <Simd<Simd<[isize; 4]>> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: Simd<Simd<[isize; 4]>>) -> Simd<Simd<[isize; 4]>>`

`pub fn simd_min(self, other: Simd<Simd<[isize; 4]>>) -> Simd<Simd<[isize; 4]>>`

`pub fn simd_clamp( self, min: Simd<Simd<[isize; 4]>>, max: Simd<Simd<[isize; 4]>> ) -> Simd<Simd<[isize; 4]>>`

`pub fn simd_horizontal_min( self ) -> <Simd<Simd<[isize; 4]>> as SimdValue>::Element`

`pub fn simd_horizontal_max( self ) -> <Simd<Simd<[isize; 4]>> as SimdValue>::Element`

`impl SimdPartialOrd for Simd<Simd<[u64; 8]>>`

`pub fn simd_gt( self, other: Simd<Simd<[u64; 8]>> ) -> <Simd<Simd<[u64; 8]>> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: Simd<Simd<[u64; 8]>> ) -> <Simd<Simd<[u64; 8]>> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: Simd<Simd<[u64; 8]>> ) -> <Simd<Simd<[u64; 8]>> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: Simd<Simd<[u64; 8]>> ) -> <Simd<Simd<[u64; 8]>> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: Simd<Simd<[u64; 8]>> ) -> <Simd<Simd<[u64; 8]>> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: Simd<Simd<[u64; 8]>> ) -> <Simd<Simd<[u64; 8]>> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: Simd<Simd<[u64; 8]>>) -> Simd<Simd<[u64; 8]>>`

`pub fn simd_min(self, other: Simd<Simd<[u64; 8]>>) -> Simd<Simd<[u64; 8]>>`

`pub fn simd_clamp( self, min: Simd<Simd<[u64; 8]>>, max: Simd<Simd<[u64; 8]>> ) -> Simd<Simd<[u64; 8]>>`

`pub fn simd_horizontal_min(self) -> <Simd<Simd<[u64; 8]>> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <Simd<Simd<[u64; 8]>> as SimdValue>::Element`

`impl SimdPartialOrd for AutoSimd<[u8; 2]>`

`pub fn simd_gt( self, other: AutoSimd<[u8; 2]> ) -> <AutoSimd<[u8; 2]> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: AutoSimd<[u8; 2]> ) -> <AutoSimd<[u8; 2]> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: AutoSimd<[u8; 2]> ) -> <AutoSimd<[u8; 2]> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: AutoSimd<[u8; 2]> ) -> <AutoSimd<[u8; 2]> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: AutoSimd<[u8; 2]> ) -> <AutoSimd<[u8; 2]> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: AutoSimd<[u8; 2]> ) -> <AutoSimd<[u8; 2]> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: AutoSimd<[u8; 2]>) -> AutoSimd<[u8; 2]>`

`pub fn simd_min(self, other: AutoSimd<[u8; 2]>) -> AutoSimd<[u8; 2]>`

`pub fn simd_clamp( self, min: AutoSimd<[u8; 2]>, max: AutoSimd<[u8; 2]> ) -> AutoSimd<[u8; 2]>`

`pub fn simd_horizontal_min(self) -> <AutoSimd<[u8; 2]> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <AutoSimd<[u8; 2]> as SimdValue>::Element`

`impl SimdPartialOrd for AutoSimd<[u8; 4]>`

`pub fn simd_gt( self, other: AutoSimd<[u8; 4]> ) -> <AutoSimd<[u8; 4]> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: AutoSimd<[u8; 4]> ) -> <AutoSimd<[u8; 4]> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: AutoSimd<[u8; 4]> ) -> <AutoSimd<[u8; 4]> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: AutoSimd<[u8; 4]> ) -> <AutoSimd<[u8; 4]> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: AutoSimd<[u8; 4]> ) -> <AutoSimd<[u8; 4]> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: AutoSimd<[u8; 4]> ) -> <AutoSimd<[u8; 4]> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: AutoSimd<[u8; 4]>) -> AutoSimd<[u8; 4]>`

`pub fn simd_min(self, other: AutoSimd<[u8; 4]>) -> AutoSimd<[u8; 4]>`

`pub fn simd_clamp( self, min: AutoSimd<[u8; 4]>, max: AutoSimd<[u8; 4]> ) -> AutoSimd<[u8; 4]>`

`pub fn simd_horizontal_min(self) -> <AutoSimd<[u8; 4]> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <AutoSimd<[u8; 4]> as SimdValue>::Element`

`impl SimdPartialOrd for Simd<Simd<[u32; 4]>>`

`pub fn simd_gt( self, other: Simd<Simd<[u32; 4]>> ) -> <Simd<Simd<[u32; 4]>> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: Simd<Simd<[u32; 4]>> ) -> <Simd<Simd<[u32; 4]>> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: Simd<Simd<[u32; 4]>> ) -> <Simd<Simd<[u32; 4]>> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: Simd<Simd<[u32; 4]>> ) -> <Simd<Simd<[u32; 4]>> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: Simd<Simd<[u32; 4]>> ) -> <Simd<Simd<[u32; 4]>> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: Simd<Simd<[u32; 4]>> ) -> <Simd<Simd<[u32; 4]>> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: Simd<Simd<[u32; 4]>>) -> Simd<Simd<[u32; 4]>>`

`pub fn simd_min(self, other: Simd<Simd<[u32; 4]>>) -> Simd<Simd<[u32; 4]>>`

`pub fn simd_clamp( self, min: Simd<Simd<[u32; 4]>>, max: Simd<Simd<[u32; 4]>> ) -> Simd<Simd<[u32; 4]>>`

`pub fn simd_horizontal_min(self) -> <Simd<Simd<[u32; 4]>> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <Simd<Simd<[u32; 4]>> as SimdValue>::Element`

`impl SimdPartialOrd for AutoSimd<[i64; 8]>`

`pub fn simd_gt( self, other: AutoSimd<[i64; 8]> ) -> <AutoSimd<[i64; 8]> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: AutoSimd<[i64; 8]> ) -> <AutoSimd<[i64; 8]> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: AutoSimd<[i64; 8]> ) -> <AutoSimd<[i64; 8]> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: AutoSimd<[i64; 8]> ) -> <AutoSimd<[i64; 8]> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: AutoSimd<[i64; 8]> ) -> <AutoSimd<[i64; 8]> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: AutoSimd<[i64; 8]> ) -> <AutoSimd<[i64; 8]> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: AutoSimd<[i64; 8]>) -> AutoSimd<[i64; 8]>`

`pub fn simd_min(self, other: AutoSimd<[i64; 8]>) -> AutoSimd<[i64; 8]>`

`pub fn simd_clamp( self, min: AutoSimd<[i64; 8]>, max: AutoSimd<[i64; 8]> ) -> AutoSimd<[i64; 8]>`

`pub fn simd_horizontal_min(self) -> <AutoSimd<[i64; 8]> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <AutoSimd<[i64; 8]> as SimdValue>::Element`

`impl SimdPartialOrd for AutoSimd<[f64; 8]>`

`pub fn simd_gt( self, other: AutoSimd<[f64; 8]> ) -> <AutoSimd<[f64; 8]> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: AutoSimd<[f64; 8]> ) -> <AutoSimd<[f64; 8]> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: AutoSimd<[f64; 8]> ) -> <AutoSimd<[f64; 8]> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: AutoSimd<[f64; 8]> ) -> <AutoSimd<[f64; 8]> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: AutoSimd<[f64; 8]> ) -> <AutoSimd<[f64; 8]> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: AutoSimd<[f64; 8]> ) -> <AutoSimd<[f64; 8]> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: AutoSimd<[f64; 8]>) -> AutoSimd<[f64; 8]>`

`pub fn simd_min(self, other: AutoSimd<[f64; 8]>) -> AutoSimd<[f64; 8]>`

`pub fn simd_clamp( self, min: AutoSimd<[f64; 8]>, max: AutoSimd<[f64; 8]> ) -> AutoSimd<[f64; 8]>`

`pub fn simd_horizontal_min(self) -> <AutoSimd<[f64; 8]> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <AutoSimd<[f64; 8]> as SimdValue>::Element`

`impl SimdPartialOrd for AutoSimd<[i16; 4]>`

`pub fn simd_gt( self, other: AutoSimd<[i16; 4]> ) -> <AutoSimd<[i16; 4]> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: AutoSimd<[i16; 4]> ) -> <AutoSimd<[i16; 4]> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: AutoSimd<[i16; 4]> ) -> <AutoSimd<[i16; 4]> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: AutoSimd<[i16; 4]> ) -> <AutoSimd<[i16; 4]> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: AutoSimd<[i16; 4]> ) -> <AutoSimd<[i16; 4]> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: AutoSimd<[i16; 4]> ) -> <AutoSimd<[i16; 4]> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: AutoSimd<[i16; 4]>) -> AutoSimd<[i16; 4]>`

`pub fn simd_min(self, other: AutoSimd<[i16; 4]>) -> AutoSimd<[i16; 4]>`

`pub fn simd_clamp( self, min: AutoSimd<[i16; 4]>, max: AutoSimd<[i16; 4]> ) -> AutoSimd<[i16; 4]>`

`pub fn simd_horizontal_min(self) -> <AutoSimd<[i16; 4]> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <AutoSimd<[i16; 4]> as SimdValue>::Element`

`impl SimdPartialOrd for Simd<Simd<[u16; 2]>>`

`pub fn simd_gt( self, other: Simd<Simd<[u16; 2]>> ) -> <Simd<Simd<[u16; 2]>> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: Simd<Simd<[u16; 2]>> ) -> <Simd<Simd<[u16; 2]>> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: Simd<Simd<[u16; 2]>> ) -> <Simd<Simd<[u16; 2]>> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: Simd<Simd<[u16; 2]>> ) -> <Simd<Simd<[u16; 2]>> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: Simd<Simd<[u16; 2]>> ) -> <Simd<Simd<[u16; 2]>> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: Simd<Simd<[u16; 2]>> ) -> <Simd<Simd<[u16; 2]>> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: Simd<Simd<[u16; 2]>>) -> Simd<Simd<[u16; 2]>>`

`pub fn simd_min(self, other: Simd<Simd<[u16; 2]>>) -> Simd<Simd<[u16; 2]>>`

`pub fn simd_clamp( self, min: Simd<Simd<[u16; 2]>>, max: Simd<Simd<[u16; 2]>> ) -> Simd<Simd<[u16; 2]>>`

`pub fn simd_horizontal_min(self) -> <Simd<Simd<[u16; 2]>> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <Simd<Simd<[u16; 2]>> as SimdValue>::Element`

`impl SimdPartialOrd for AutoSimd<[i32; 4]>`

`pub fn simd_gt( self, other: AutoSimd<[i32; 4]> ) -> <AutoSimd<[i32; 4]> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: AutoSimd<[i32; 4]> ) -> <AutoSimd<[i32; 4]> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: AutoSimd<[i32; 4]> ) -> <AutoSimd<[i32; 4]> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: AutoSimd<[i32; 4]> ) -> <AutoSimd<[i32; 4]> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: AutoSimd<[i32; 4]> ) -> <AutoSimd<[i32; 4]> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: AutoSimd<[i32; 4]> ) -> <AutoSimd<[i32; 4]> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: AutoSimd<[i32; 4]>) -> AutoSimd<[i32; 4]>`

`pub fn simd_min(self, other: AutoSimd<[i32; 4]>) -> AutoSimd<[i32; 4]>`

`pub fn simd_clamp( self, min: AutoSimd<[i32; 4]>, max: AutoSimd<[i32; 4]> ) -> AutoSimd<[i32; 4]>`

`pub fn simd_horizontal_min(self) -> <AutoSimd<[i32; 4]> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <AutoSimd<[i32; 4]> as SimdValue>::Element`

`impl SimdPartialOrd for AutoSimd<[u8; 16]>`

`pub fn simd_gt( self, other: AutoSimd<[u8; 16]> ) -> <AutoSimd<[u8; 16]> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: AutoSimd<[u8; 16]> ) -> <AutoSimd<[u8; 16]> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: AutoSimd<[u8; 16]> ) -> <AutoSimd<[u8; 16]> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: AutoSimd<[u8; 16]> ) -> <AutoSimd<[u8; 16]> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: AutoSimd<[u8; 16]> ) -> <AutoSimd<[u8; 16]> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: AutoSimd<[u8; 16]> ) -> <AutoSimd<[u8; 16]> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: AutoSimd<[u8; 16]>) -> AutoSimd<[u8; 16]>`

`pub fn simd_min(self, other: AutoSimd<[u8; 16]>) -> AutoSimd<[u8; 16]>`

`pub fn simd_clamp( self, min: AutoSimd<[u8; 16]>, max: AutoSimd<[u8; 16]> ) -> AutoSimd<[u8; 16]>`

`pub fn simd_horizontal_min(self) -> <AutoSimd<[u8; 16]> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <AutoSimd<[u8; 16]> as SimdValue>::Element`

`impl SimdPartialOrd for AutoSimd<[u32; 8]>`

`pub fn simd_gt( self, other: AutoSimd<[u32; 8]> ) -> <AutoSimd<[u32; 8]> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: AutoSimd<[u32; 8]> ) -> <AutoSimd<[u32; 8]> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: AutoSimd<[u32; 8]> ) -> <AutoSimd<[u32; 8]> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: AutoSimd<[u32; 8]> ) -> <AutoSimd<[u32; 8]> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: AutoSimd<[u32; 8]> ) -> <AutoSimd<[u32; 8]> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: AutoSimd<[u32; 8]> ) -> <AutoSimd<[u32; 8]> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: AutoSimd<[u32; 8]>) -> AutoSimd<[u32; 8]>`

`pub fn simd_min(self, other: AutoSimd<[u32; 8]>) -> AutoSimd<[u32; 8]>`

`pub fn simd_clamp( self, min: AutoSimd<[u32; 8]>, max: AutoSimd<[u32; 8]> ) -> AutoSimd<[u32; 8]>`

`pub fn simd_horizontal_min(self) -> <AutoSimd<[u32; 8]> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <AutoSimd<[u32; 8]> as SimdValue>::Element`

`impl SimdPartialOrd for AutoSimd<[u32; 4]>`

`pub fn simd_gt( self, other: AutoSimd<[u32; 4]> ) -> <AutoSimd<[u32; 4]> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: AutoSimd<[u32; 4]> ) -> <AutoSimd<[u32; 4]> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: AutoSimd<[u32; 4]> ) -> <AutoSimd<[u32; 4]> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: AutoSimd<[u32; 4]> ) -> <AutoSimd<[u32; 4]> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: AutoSimd<[u32; 4]> ) -> <AutoSimd<[u32; 4]> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: AutoSimd<[u32; 4]> ) -> <AutoSimd<[u32; 4]> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: AutoSimd<[u32; 4]>) -> AutoSimd<[u32; 4]>`

`pub fn simd_min(self, other: AutoSimd<[u32; 4]>) -> AutoSimd<[u32; 4]>`

`pub fn simd_clamp( self, min: AutoSimd<[u32; 4]>, max: AutoSimd<[u32; 4]> ) -> AutoSimd<[u32; 4]>`

`pub fn simd_horizontal_min(self) -> <AutoSimd<[u32; 4]> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <AutoSimd<[u32; 4]> as SimdValue>::Element`

`impl SimdPartialOrd for Simd<Simd<[u64; 2]>>`

`pub fn simd_gt( self, other: Simd<Simd<[u64; 2]>> ) -> <Simd<Simd<[u64; 2]>> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: Simd<Simd<[u64; 2]>> ) -> <Simd<Simd<[u64; 2]>> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: Simd<Simd<[u64; 2]>> ) -> <Simd<Simd<[u64; 2]>> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: Simd<Simd<[u64; 2]>> ) -> <Simd<Simd<[u64; 2]>> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: Simd<Simd<[u64; 2]>> ) -> <Simd<Simd<[u64; 2]>> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: Simd<Simd<[u64; 2]>> ) -> <Simd<Simd<[u64; 2]>> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: Simd<Simd<[u64; 2]>>) -> Simd<Simd<[u64; 2]>>`

`pub fn simd_min(self, other: Simd<Simd<[u64; 2]>>) -> Simd<Simd<[u64; 2]>>`

`pub fn simd_clamp( self, min: Simd<Simd<[u64; 2]>>, max: Simd<Simd<[u64; 2]>> ) -> Simd<Simd<[u64; 2]>>`

`pub fn simd_horizontal_min(self) -> <Simd<Simd<[u64; 2]>> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <Simd<Simd<[u64; 2]>> as SimdValue>::Element`

`impl SimdPartialOrd for Simd<Simd<[i32; 16]>>`

`pub fn simd_gt( self, other: Simd<Simd<[i32; 16]>> ) -> <Simd<Simd<[i32; 16]>> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: Simd<Simd<[i32; 16]>> ) -> <Simd<Simd<[i32; 16]>> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: Simd<Simd<[i32; 16]>> ) -> <Simd<Simd<[i32; 16]>> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: Simd<Simd<[i32; 16]>> ) -> <Simd<Simd<[i32; 16]>> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: Simd<Simd<[i32; 16]>> ) -> <Simd<Simd<[i32; 16]>> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: Simd<Simd<[i32; 16]>> ) -> <Simd<Simd<[i32; 16]>> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: Simd<Simd<[i32; 16]>>) -> Simd<Simd<[i32; 16]>>`

`pub fn simd_min(self, other: Simd<Simd<[i32; 16]>>) -> Simd<Simd<[i32; 16]>>`

`pub fn simd_clamp( self, min: Simd<Simd<[i32; 16]>>, max: Simd<Simd<[i32; 16]>> ) -> Simd<Simd<[i32; 16]>>`

`pub fn simd_horizontal_min( self ) -> <Simd<Simd<[i32; 16]>> as SimdValue>::Element`

`pub fn simd_horizontal_max( self ) -> <Simd<Simd<[i32; 16]>> as SimdValue>::Element`

`impl SimdPartialOrd for Simd<Simd<[i64; 4]>>`

`pub fn simd_gt( self, other: Simd<Simd<[i64; 4]>> ) -> <Simd<Simd<[i64; 4]>> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: Simd<Simd<[i64; 4]>> ) -> <Simd<Simd<[i64; 4]>> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: Simd<Simd<[i64; 4]>> ) -> <Simd<Simd<[i64; 4]>> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: Simd<Simd<[i64; 4]>> ) -> <Simd<Simd<[i64; 4]>> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: Simd<Simd<[i64; 4]>> ) -> <Simd<Simd<[i64; 4]>> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: Simd<Simd<[i64; 4]>> ) -> <Simd<Simd<[i64; 4]>> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: Simd<Simd<[i64; 4]>>) -> Simd<Simd<[i64; 4]>>`

`pub fn simd_min(self, other: Simd<Simd<[i64; 4]>>) -> Simd<Simd<[i64; 4]>>`

`pub fn simd_clamp( self, min: Simd<Simd<[i64; 4]>>, max: Simd<Simd<[i64; 4]>> ) -> Simd<Simd<[i64; 4]>>`

`pub fn simd_horizontal_min(self) -> <Simd<Simd<[i64; 4]>> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <Simd<Simd<[i64; 4]>> as SimdValue>::Element`

`impl SimdPartialOrd for AutoSimd<[i8; 8]>`

`pub fn simd_gt( self, other: AutoSimd<[i8; 8]> ) -> <AutoSimd<[i8; 8]> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: AutoSimd<[i8; 8]> ) -> <AutoSimd<[i8; 8]> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: AutoSimd<[i8; 8]> ) -> <AutoSimd<[i8; 8]> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: AutoSimd<[i8; 8]> ) -> <AutoSimd<[i8; 8]> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: AutoSimd<[i8; 8]> ) -> <AutoSimd<[i8; 8]> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: AutoSimd<[i8; 8]> ) -> <AutoSimd<[i8; 8]> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: AutoSimd<[i8; 8]>) -> AutoSimd<[i8; 8]>`

`pub fn simd_min(self, other: AutoSimd<[i8; 8]>) -> AutoSimd<[i8; 8]>`

`pub fn simd_clamp( self, min: AutoSimd<[i8; 8]>, max: AutoSimd<[i8; 8]> ) -> AutoSimd<[i8; 8]>`

`pub fn simd_horizontal_min(self) -> <AutoSimd<[i8; 8]> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <AutoSimd<[i8; 8]> as SimdValue>::Element`

`impl SimdPartialOrd for AutoSimd<[i16; 32]>`

`pub fn simd_gt( self, other: AutoSimd<[i16; 32]> ) -> <AutoSimd<[i16; 32]> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: AutoSimd<[i16; 32]> ) -> <AutoSimd<[i16; 32]> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: AutoSimd<[i16; 32]> ) -> <AutoSimd<[i16; 32]> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: AutoSimd<[i16; 32]> ) -> <AutoSimd<[i16; 32]> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: AutoSimd<[i16; 32]> ) -> <AutoSimd<[i16; 32]> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: AutoSimd<[i16; 32]> ) -> <AutoSimd<[i16; 32]> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: AutoSimd<[i16; 32]>) -> AutoSimd<[i16; 32]>`

`pub fn simd_min(self, other: AutoSimd<[i16; 32]>) -> AutoSimd<[i16; 32]>`

`pub fn simd_clamp( self, min: AutoSimd<[i16; 32]>, max: AutoSimd<[i16; 32]> ) -> AutoSimd<[i16; 32]>`

`pub fn simd_horizontal_min(self) -> <AutoSimd<[i16; 32]> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <AutoSimd<[i16; 32]> as SimdValue>::Element`

`impl SimdPartialOrd for AutoSimd<[u8; 32]>`

`pub fn simd_gt( self, other: AutoSimd<[u8; 32]> ) -> <AutoSimd<[u8; 32]> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: AutoSimd<[u8; 32]> ) -> <AutoSimd<[u8; 32]> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: AutoSimd<[u8; 32]> ) -> <AutoSimd<[u8; 32]> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: AutoSimd<[u8; 32]> ) -> <AutoSimd<[u8; 32]> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: AutoSimd<[u8; 32]> ) -> <AutoSimd<[u8; 32]> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: AutoSimd<[u8; 32]> ) -> <AutoSimd<[u8; 32]> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: AutoSimd<[u8; 32]>) -> AutoSimd<[u8; 32]>`

`pub fn simd_min(self, other: AutoSimd<[u8; 32]>) -> AutoSimd<[u8; 32]>`

`pub fn simd_clamp( self, min: AutoSimd<[u8; 32]>, max: AutoSimd<[u8; 32]> ) -> AutoSimd<[u8; 32]>`

`pub fn simd_horizontal_min(self) -> <AutoSimd<[u8; 32]> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <AutoSimd<[u8; 32]> as SimdValue>::Element`

`impl SimdPartialOrd for AutoSimd<[usize; 4]>`

`pub fn simd_gt( self, other: AutoSimd<[usize; 4]> ) -> <AutoSimd<[usize; 4]> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: AutoSimd<[usize; 4]> ) -> <AutoSimd<[usize; 4]> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: AutoSimd<[usize; 4]> ) -> <AutoSimd<[usize; 4]> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: AutoSimd<[usize; 4]> ) -> <AutoSimd<[usize; 4]> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: AutoSimd<[usize; 4]> ) -> <AutoSimd<[usize; 4]> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: AutoSimd<[usize; 4]> ) -> <AutoSimd<[usize; 4]> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: AutoSimd<[usize; 4]>) -> AutoSimd<[usize; 4]>`

`pub fn simd_min(self, other: AutoSimd<[usize; 4]>) -> AutoSimd<[usize; 4]>`

`pub fn simd_clamp( self, min: AutoSimd<[usize; 4]>, max: AutoSimd<[usize; 4]> ) -> AutoSimd<[usize; 4]>`

`pub fn simd_horizontal_min(self) -> <AutoSimd<[usize; 4]> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <AutoSimd<[usize; 4]> as SimdValue>::Element`

`impl SimdPartialOrd for Simd<Simd<[u8; 8]>>`

`pub fn simd_gt( self, other: Simd<Simd<[u8; 8]>> ) -> <Simd<Simd<[u8; 8]>> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: Simd<Simd<[u8; 8]>> ) -> <Simd<Simd<[u8; 8]>> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: Simd<Simd<[u8; 8]>> ) -> <Simd<Simd<[u8; 8]>> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: Simd<Simd<[u8; 8]>> ) -> <Simd<Simd<[u8; 8]>> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: Simd<Simd<[u8; 8]>> ) -> <Simd<Simd<[u8; 8]>> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: Simd<Simd<[u8; 8]>> ) -> <Simd<Simd<[u8; 8]>> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: Simd<Simd<[u8; 8]>>) -> Simd<Simd<[u8; 8]>>`

`pub fn simd_min(self, other: Simd<Simd<[u8; 8]>>) -> Simd<Simd<[u8; 8]>>`

`pub fn simd_clamp( self, min: Simd<Simd<[u8; 8]>>, max: Simd<Simd<[u8; 8]>> ) -> Simd<Simd<[u8; 8]>>`

`pub fn simd_horizontal_min(self) -> <Simd<Simd<[u8; 8]>> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <Simd<Simd<[u8; 8]>> as SimdValue>::Element`

`impl SimdPartialOrd for Simd<Simd<[f32; 8]>>`

`pub fn simd_gt( self, other: Simd<Simd<[f32; 8]>> ) -> <Simd<Simd<[f32; 8]>> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: Simd<Simd<[f32; 8]>> ) -> <Simd<Simd<[f32; 8]>> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: Simd<Simd<[f32; 8]>> ) -> <Simd<Simd<[f32; 8]>> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: Simd<Simd<[f32; 8]>> ) -> <Simd<Simd<[f32; 8]>> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: Simd<Simd<[f32; 8]>> ) -> <Simd<Simd<[f32; 8]>> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: Simd<Simd<[f32; 8]>> ) -> <Simd<Simd<[f32; 8]>> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: Simd<Simd<[f32; 8]>>) -> Simd<Simd<[f32; 8]>>`

`pub fn simd_min(self, other: Simd<Simd<[f32; 8]>>) -> Simd<Simd<[f32; 8]>>`

`pub fn simd_clamp( self, min: Simd<Simd<[f32; 8]>>, max: Simd<Simd<[f32; 8]>> ) -> Simd<Simd<[f32; 8]>>`

`pub fn simd_horizontal_min(self) -> <Simd<Simd<[f32; 8]>> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <Simd<Simd<[f32; 8]>> as SimdValue>::Element`

`impl SimdPartialOrd for AutoSimd<[i16; 16]>`

`pub fn simd_gt( self, other: AutoSimd<[i16; 16]> ) -> <AutoSimd<[i16; 16]> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: AutoSimd<[i16; 16]> ) -> <AutoSimd<[i16; 16]> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: AutoSimd<[i16; 16]> ) -> <AutoSimd<[i16; 16]> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: AutoSimd<[i16; 16]> ) -> <AutoSimd<[i16; 16]> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: AutoSimd<[i16; 16]> ) -> <AutoSimd<[i16; 16]> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: AutoSimd<[i16; 16]> ) -> <AutoSimd<[i16; 16]> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: AutoSimd<[i16; 16]>) -> AutoSimd<[i16; 16]>`

`pub fn simd_min(self, other: AutoSimd<[i16; 16]>) -> AutoSimd<[i16; 16]>`

`pub fn simd_clamp( self, min: AutoSimd<[i16; 16]>, max: AutoSimd<[i16; 16]> ) -> AutoSimd<[i16; 16]>`

`pub fn simd_horizontal_min(self) -> <AutoSimd<[i16; 16]> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <AutoSimd<[i16; 16]> as SimdValue>::Element`

`impl SimdPartialOrd for Simd<Simd<[f32; 4]>>`

`pub fn simd_gt( self, other: Simd<Simd<[f32; 4]>> ) -> <Simd<Simd<[f32; 4]>> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: Simd<Simd<[f32; 4]>> ) -> <Simd<Simd<[f32; 4]>> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: Simd<Simd<[f32; 4]>> ) -> <Simd<Simd<[f32; 4]>> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: Simd<Simd<[f32; 4]>> ) -> <Simd<Simd<[f32; 4]>> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: Simd<Simd<[f32; 4]>> ) -> <Simd<Simd<[f32; 4]>> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: Simd<Simd<[f32; 4]>> ) -> <Simd<Simd<[f32; 4]>> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: Simd<Simd<[f32; 4]>>) -> Simd<Simd<[f32; 4]>>`

`pub fn simd_min(self, other: Simd<Simd<[f32; 4]>>) -> Simd<Simd<[f32; 4]>>`

`pub fn simd_clamp( self, min: Simd<Simd<[f32; 4]>>, max: Simd<Simd<[f32; 4]>> ) -> Simd<Simd<[f32; 4]>>`

`pub fn simd_horizontal_min(self) -> <Simd<Simd<[f32; 4]>> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <Simd<Simd<[f32; 4]>> as SimdValue>::Element`

`impl SimdPartialOrd for Simd<Simd<[u128; 1]>>`

`pub fn simd_gt( self, other: Simd<Simd<[u128; 1]>> ) -> <Simd<Simd<[u128; 1]>> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: Simd<Simd<[u128; 1]>> ) -> <Simd<Simd<[u128; 1]>> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: Simd<Simd<[u128; 1]>> ) -> <Simd<Simd<[u128; 1]>> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: Simd<Simd<[u128; 1]>> ) -> <Simd<Simd<[u128; 1]>> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: Simd<Simd<[u128; 1]>> ) -> <Simd<Simd<[u128; 1]>> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: Simd<Simd<[u128; 1]>> ) -> <Simd<Simd<[u128; 1]>> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: Simd<Simd<[u128; 1]>>) -> Simd<Simd<[u128; 1]>>`

`pub fn simd_min(self, other: Simd<Simd<[u128; 1]>>) -> Simd<Simd<[u128; 1]>>`

`pub fn simd_clamp( self, min: Simd<Simd<[u128; 1]>>, max: Simd<Simd<[u128; 1]>> ) -> Simd<Simd<[u128; 1]>>`

`pub fn simd_horizontal_min( self ) -> <Simd<Simd<[u128; 1]>> as SimdValue>::Element`

`pub fn simd_horizontal_max( self ) -> <Simd<Simd<[u128; 1]>> as SimdValue>::Element`

`impl SimdPartialOrd for Simd<Simd<[u32; 2]>>`

`pub fn simd_gt( self, other: Simd<Simd<[u32; 2]>> ) -> <Simd<Simd<[u32; 2]>> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: Simd<Simd<[u32; 2]>> ) -> <Simd<Simd<[u32; 2]>> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: Simd<Simd<[u32; 2]>> ) -> <Simd<Simd<[u32; 2]>> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: Simd<Simd<[u32; 2]>> ) -> <Simd<Simd<[u32; 2]>> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: Simd<Simd<[u32; 2]>> ) -> <Simd<Simd<[u32; 2]>> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: Simd<Simd<[u32; 2]>> ) -> <Simd<Simd<[u32; 2]>> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: Simd<Simd<[u32; 2]>>) -> Simd<Simd<[u32; 2]>>`

`pub fn simd_min(self, other: Simd<Simd<[u32; 2]>>) -> Simd<Simd<[u32; 2]>>`

`pub fn simd_clamp( self, min: Simd<Simd<[u32; 2]>>, max: Simd<Simd<[u32; 2]>> ) -> Simd<Simd<[u32; 2]>>`

`pub fn simd_horizontal_min(self) -> <Simd<Simd<[u32; 2]>> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <Simd<Simd<[u32; 2]>> as SimdValue>::Element`

Loading content...

Implementors

`impl<T> SimdPartialOrd for T where T: SimdValue<Element = T, SimdBool = bool> + PartialOrd<T>,`

`pub fn simd_gt(self, other: T) -> <T as SimdValue>::SimdBool`

`pub fn simd_lt(self, other: T) -> <T as SimdValue>::SimdBool`

`pub fn simd_ge(self, other: T) -> <T as SimdValue>::SimdBool`

`pub fn simd_le(self, other: T) -> <T as SimdValue>::SimdBool`

`pub fn simd_eq(self, other: T) -> <T as SimdValue>::SimdBool`

`pub fn simd_ne(self, other: T) -> <T as SimdValue>::SimdBool`

`pub fn simd_max(self, other: T) -> T`

`pub fn simd_min(self, other: T) -> T`

`pub fn simd_clamp(self, min: T, max: T) -> T`

`pub fn simd_horizontal_min(self) -> <T as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <T as SimdValue>::Element`

Loading content...

Trait lnkit::prelude::SimdPartialOrd⎘[−]

Required methods

pub fn simd_gt(self, other: Self) -> Self::SimdBool

pub fn simd_lt(self, other: Self) -> Self::SimdBool

pub fn simd_ge(self, other: Self) -> Self::SimdBool

pub fn simd_le(self, other: Self) -> Self::SimdBool

pub fn simd_eq(self, other: Self) -> Self::SimdBool

pub fn simd_ne(self, other: Self) -> Self::SimdBool

pub fn simd_max(self, other: Self) -> Self

pub fn simd_min(self, other: Self) -> Self

pub fn simd_clamp(self, min: Self, max: Self) -> Self

pub fn simd_horizontal_min(self) -> Self::Element

pub fn simd_horizontal_max(self) -> Self::Element

Implementations on Foreign Types

impl SimdPartialOrd for Simd<Simd<[usize; 4]>>

pub fn simd_gt( self, other: Simd<Simd<[usize; 4]>>) -> <Simd<Simd<[usize; 4]>> as SimdValue>::SimdBool

pub fn simd_lt( self, other: Simd<Simd<[usize; 4]>>) -> <Simd<Simd<[usize; 4]>> as SimdValue>::SimdBool

pub fn simd_ge( self, other: Simd<Simd<[usize; 4]>>) -> <Simd<Simd<[usize; 4]>> as SimdValue>::SimdBool

pub fn simd_le( self, other: Simd<Simd<[usize; 4]>>) -> <Simd<Simd<[usize; 4]>> as SimdValue>::SimdBool

pub fn simd_eq( self, other: Simd<Simd<[usize; 4]>>) -> <Simd<Simd<[usize; 4]>> as SimdValue>::SimdBool

pub fn simd_ne( self, other: Simd<Simd<[usize; 4]>>) -> <Simd<Simd<[usize; 4]>> as SimdValue>::SimdBool

pub fn simd_max(self, other: Simd<Simd<[usize; 4]>>) -> Simd<Simd<[usize; 4]>>

pub fn simd_min(self, other: Simd<Simd<[usize; 4]>>) -> Simd<Simd<[usize; 4]>>

pub fn simd_clamp( self, min: Simd<Simd<[usize; 4]>>, max: Simd<Simd<[usize; 4]>>) -> Simd<Simd<[usize; 4]>>

pub fn simd_horizontal_min( self) -> <Simd<Simd<[usize; 4]>> as SimdValue>::Element

pub fn simd_horizontal_max( self) -> <Simd<Simd<[usize; 4]>> as SimdValue>::Element

impl SimdPartialOrd for AutoSimd<[f32; 2]>

pub fn simd_gt( self, other: AutoSimd<[f32; 2]>) -> <AutoSimd<[f32; 2]> as SimdValue>::SimdBool

pub fn simd_lt( self, other: AutoSimd<[f32; 2]>) -> <AutoSimd<[f32; 2]> as SimdValue>::SimdBool

pub fn simd_ge( self, other: AutoSimd<[f32; 2]>) -> <AutoSimd<[f32; 2]> as SimdValue>::SimdBool

pub fn simd_le( self, other: AutoSimd<[f32; 2]>) -> <AutoSimd<[f32; 2]> as SimdValue>::SimdBool

pub fn simd_eq( self, other: AutoSimd<[f32; 2]>) -> <AutoSimd<[f32; 2]> as SimdValue>::SimdBool

pub fn simd_ne( self, other: AutoSimd<[f32; 2]>) -> <AutoSimd<[f32; 2]> as SimdValue>::SimdBool

pub fn simd_max(self, other: AutoSimd<[f32; 2]>) -> AutoSimd<[f32; 2]>

pub fn simd_min(self, other: AutoSimd<[f32; 2]>) -> AutoSimd<[f32; 2]>

pub fn simd_clamp( self, min: AutoSimd<[f32; 2]>, max: AutoSimd<[f32; 2]>) -> AutoSimd<[f32; 2]>

pub fn simd_horizontal_min(self) -> <AutoSimd<[f32; 2]> as SimdValue>::Element

pub fn simd_horizontal_max(self) -> <AutoSimd<[f32; 2]> as SimdValue>::Element

impl SimdPartialOrd for AutoSimd<[isize; 2]>

pub fn simd_gt( self, other: AutoSimd<[isize; 2]>) -> <AutoSimd<[isize; 2]> as SimdValue>::SimdBool

pub fn simd_lt( self, other: AutoSimd<[isize; 2]>) -> <AutoSimd<[isize; 2]> as SimdValue>::SimdBool

pub fn simd_ge( self, other: AutoSimd<[isize; 2]>) -> <AutoSimd<[isize; 2]> as SimdValue>::SimdBool

pub fn simd_le( self, other: AutoSimd<[isize; 2]>) -> <AutoSimd<[isize; 2]> as SimdValue>::SimdBool

pub fn simd_eq( self, other: AutoSimd<[isize; 2]>) -> <AutoSimd<[isize; 2]> as SimdValue>::SimdBool

pub fn simd_ne( self, other: AutoSimd<[isize; 2]>) -> <AutoSimd<[isize; 2]> as SimdValue>::SimdBool

pub fn simd_max(self, other: AutoSimd<[isize; 2]>) -> AutoSimd<[isize; 2]>

pub fn simd_min(self, other: AutoSimd<[isize; 2]>) -> AutoSimd<[isize; 2]>

pub fn simd_clamp( self, min: AutoSimd<[isize; 2]>, max: AutoSimd<[isize; 2]>) -> AutoSimd<[isize; 2]>

pub fn simd_horizontal_min(self) -> <AutoSimd<[isize; 2]> as SimdValue>::Element

pub fn simd_horizontal_max(self) -> <AutoSimd<[isize; 2]> as SimdValue>::Element

impl SimdPartialOrd for Simd<Simd<[u16; 4]>>

pub fn simd_gt( self, other: Simd<Simd<[u16; 4]>>) -> <Simd<Simd<[u16; 4]>> as SimdValue>::SimdBool

pub fn simd_lt( self, other: Simd<Simd<[u16; 4]>>) -> <Simd<Simd<[u16; 4]>> as SimdValue>::SimdBool

pub fn simd_ge( self, other: Simd<Simd<[u16; 4]>>) -> <Simd<Simd<[u16; 4]>> as SimdValue>::SimdBool

pub fn simd_le( self, other: Simd<Simd<[u16; 4]>>) -> <Simd<Simd<[u16; 4]>> as SimdValue>::SimdBool

pub fn simd_eq( self, other: Simd<Simd<[u16; 4]>>) -> <Simd<Simd<[u16; 4]>> as SimdValue>::SimdBool

pub fn simd_ne( self, other: Simd<Simd<[u16; 4]>>) -> <Simd<Simd<[u16; 4]>> as SimdValue>::SimdBool

pub fn simd_max(self, other: Simd<Simd<[u16; 4]>>) -> Simd<Simd<[u16; 4]>>

pub fn simd_min(self, other: Simd<Simd<[u16; 4]>>) -> Simd<Simd<[u16; 4]>>

pub fn simd_clamp( self, min: Simd<Simd<[u16; 4]>>, max: Simd<Simd<[u16; 4]>>) -> Simd<Simd<[u16; 4]>>

pub fn simd_horizontal_min(self) -> <Simd<Simd<[u16; 4]>> as SimdValue>::Element

pub fn simd_horizontal_max(self) -> <Simd<Simd<[u16; 4]>> as SimdValue>::Element

impl SimdPartialOrd for Simd<Simd<[u128; 4]>>

pub fn simd_gt( self, other: Simd<Simd<[u128; 4]>>) -> <Simd<Simd<[u128; 4]>> as SimdValue>::SimdBool

pub fn simd_lt( self, other: Simd<Simd<[u128; 4]>>) -> <Simd<Simd<[u128; 4]>> as SimdValue>::SimdBool

pub fn simd_ge( self, other: Simd<Simd<[u128; 4]>>) -> <Simd<Simd<[u128; 4]>> as SimdValue>::SimdBool

pub fn simd_le( self, other: Simd<Simd<[u128; 4]>>) -> <Simd<Simd<[u128; 4]>> as SimdValue>::SimdBool

pub fn simd_eq( self, other: Simd<Simd<[u128; 4]>>) -> <Simd<Simd<[u128; 4]>> as SimdValue>::SimdBool

pub fn simd_ne( self, other: Simd<Simd<[u128; 4]>>) -> <Simd<Simd<[u128; 4]>> as SimdValue>::SimdBool

pub fn simd_max(self, other: Simd<Simd<[u128; 4]>>) -> Simd<Simd<[u128; 4]>>

pub fn simd_min(self, other: Simd<Simd<[u128; 4]>>) -> Simd<Simd<[u128; 4]>>

pub fn simd_clamp( self, min: Simd<Simd<[u128; 4]>>, max: Simd<Simd<[u128; 4]>>) -> Simd<Simd<[u128; 4]>>

pub fn simd_horizontal_min( self) -> <Simd<Simd<[u128; 4]>> as SimdValue>::Element

pub fn simd_horizontal_max( self) -> <Simd<Simd<[u128; 4]>> as SimdValue>::Element

impl SimdPartialOrd for AutoSimd<[u32; 2]>

pub fn simd_gt( self, other: AutoSimd<[u32; 2]>) -> <AutoSimd<[u32; 2]> as SimdValue>::SimdBool

pub fn simd_lt( self, other: AutoSimd<[u32; 2]>) -> <AutoSimd<[u32; 2]> as SimdValue>::SimdBool

pub fn simd_ge( self, other: AutoSimd<[u32; 2]>) -> <AutoSimd<[u32; 2]> as SimdValue>::SimdBool

pub fn simd_le( self, other: AutoSimd<[u32; 2]>) -> <AutoSimd<[u32; 2]> as SimdValue>::SimdBool

pub fn simd_eq( self, other: AutoSimd<[u32; 2]>) -> <AutoSimd<[u32; 2]> as SimdValue>::SimdBool

Trait lnkit::prelude::SimdPartialOrd[−]

`pub fn simd_gt(self, other: Self) -> Self::SimdBool`

`pub fn simd_lt(self, other: Self) -> Self::SimdBool`

`pub fn simd_ge(self, other: Self) -> Self::SimdBool`

`pub fn simd_le(self, other: Self) -> Self::SimdBool`

`pub fn simd_eq(self, other: Self) -> Self::SimdBool`

`pub fn simd_ne(self, other: Self) -> Self::SimdBool`

`pub fn simd_max(self, other: Self) -> Self`

`pub fn simd_min(self, other: Self) -> Self`

`pub fn simd_clamp(self, min: Self, max: Self) -> Self`

`pub fn simd_horizontal_min(self) -> Self::Element`

`pub fn simd_horizontal_max(self) -> Self::Element`

`impl SimdPartialOrd for Simd<Simd<[usize; 4]>>`

`pub fn simd_gt( self, other: Simd<Simd<[usize; 4]>> ) -> <Simd<Simd<[usize; 4]>> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: Simd<Simd<[usize; 4]>> ) -> <Simd<Simd<[usize; 4]>> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: Simd<Simd<[usize; 4]>> ) -> <Simd<Simd<[usize; 4]>> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: Simd<Simd<[usize; 4]>> ) -> <Simd<Simd<[usize; 4]>> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: Simd<Simd<[usize; 4]>> ) -> <Simd<Simd<[usize; 4]>> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: Simd<Simd<[usize; 4]>> ) -> <Simd<Simd<[usize; 4]>> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: Simd<Simd<[usize; 4]>>) -> Simd<Simd<[usize; 4]>>`

`pub fn simd_min(self, other: Simd<Simd<[usize; 4]>>) -> Simd<Simd<[usize; 4]>>`

`pub fn simd_clamp( self, min: Simd<Simd<[usize; 4]>>, max: Simd<Simd<[usize; 4]>> ) -> Simd<Simd<[usize; 4]>>`

`pub fn simd_horizontal_min( self ) -> <Simd<Simd<[usize; 4]>> as SimdValue>::Element`

`pub fn simd_horizontal_max( self ) -> <Simd<Simd<[usize; 4]>> as SimdValue>::Element`

`impl SimdPartialOrd for AutoSimd<[f32; 2]>`

`pub fn simd_gt( self, other: AutoSimd<[f32; 2]> ) -> <AutoSimd<[f32; 2]> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: AutoSimd<[f32; 2]> ) -> <AutoSimd<[f32; 2]> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: AutoSimd<[f32; 2]> ) -> <AutoSimd<[f32; 2]> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: AutoSimd<[f32; 2]> ) -> <AutoSimd<[f32; 2]> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: AutoSimd<[f32; 2]> ) -> <AutoSimd<[f32; 2]> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: AutoSimd<[f32; 2]> ) -> <AutoSimd<[f32; 2]> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: AutoSimd<[f32; 2]>) -> AutoSimd<[f32; 2]>`

`pub fn simd_min(self, other: AutoSimd<[f32; 2]>) -> AutoSimd<[f32; 2]>`

`pub fn simd_clamp( self, min: AutoSimd<[f32; 2]>, max: AutoSimd<[f32; 2]> ) -> AutoSimd<[f32; 2]>`

`pub fn simd_horizontal_min(self) -> <AutoSimd<[f32; 2]> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <AutoSimd<[f32; 2]> as SimdValue>::Element`

`impl SimdPartialOrd for AutoSimd<[isize; 2]>`

`pub fn simd_gt( self, other: AutoSimd<[isize; 2]> ) -> <AutoSimd<[isize; 2]> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: AutoSimd<[isize; 2]> ) -> <AutoSimd<[isize; 2]> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: AutoSimd<[isize; 2]> ) -> <AutoSimd<[isize; 2]> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: AutoSimd<[isize; 2]> ) -> <AutoSimd<[isize; 2]> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: AutoSimd<[isize; 2]> ) -> <AutoSimd<[isize; 2]> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: AutoSimd<[isize; 2]> ) -> <AutoSimd<[isize; 2]> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: AutoSimd<[isize; 2]>) -> AutoSimd<[isize; 2]>`

`pub fn simd_min(self, other: AutoSimd<[isize; 2]>) -> AutoSimd<[isize; 2]>`

`pub fn simd_clamp( self, min: AutoSimd<[isize; 2]>, max: AutoSimd<[isize; 2]> ) -> AutoSimd<[isize; 2]>`

`pub fn simd_horizontal_min(self) -> <AutoSimd<[isize; 2]> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <AutoSimd<[isize; 2]> as SimdValue>::Element`

`impl SimdPartialOrd for Simd<Simd<[u16; 4]>>`

`pub fn simd_gt( self, other: Simd<Simd<[u16; 4]>> ) -> <Simd<Simd<[u16; 4]>> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: Simd<Simd<[u16; 4]>> ) -> <Simd<Simd<[u16; 4]>> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: Simd<Simd<[u16; 4]>> ) -> <Simd<Simd<[u16; 4]>> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: Simd<Simd<[u16; 4]>> ) -> <Simd<Simd<[u16; 4]>> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: Simd<Simd<[u16; 4]>> ) -> <Simd<Simd<[u16; 4]>> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: Simd<Simd<[u16; 4]>> ) -> <Simd<Simd<[u16; 4]>> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: Simd<Simd<[u16; 4]>>) -> Simd<Simd<[u16; 4]>>`

`pub fn simd_min(self, other: Simd<Simd<[u16; 4]>>) -> Simd<Simd<[u16; 4]>>`

`pub fn simd_clamp( self, min: Simd<Simd<[u16; 4]>>, max: Simd<Simd<[u16; 4]>> ) -> Simd<Simd<[u16; 4]>>`

`pub fn simd_horizontal_min(self) -> <Simd<Simd<[u16; 4]>> as SimdValue>::Element`

`pub fn simd_horizontal_max(self) -> <Simd<Simd<[u16; 4]>> as SimdValue>::Element`

`impl SimdPartialOrd for Simd<Simd<[u128; 4]>>`

`pub fn simd_gt( self, other: Simd<Simd<[u128; 4]>> ) -> <Simd<Simd<[u128; 4]>> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: Simd<Simd<[u128; 4]>> ) -> <Simd<Simd<[u128; 4]>> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: Simd<Simd<[u128; 4]>> ) -> <Simd<Simd<[u128; 4]>> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: Simd<Simd<[u128; 4]>> ) -> <Simd<Simd<[u128; 4]>> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: Simd<Simd<[u128; 4]>> ) -> <Simd<Simd<[u128; 4]>> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: Simd<Simd<[u128; 4]>> ) -> <Simd<Simd<[u128; 4]>> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: Simd<Simd<[u128; 4]>>) -> Simd<Simd<[u128; 4]>>`

`pub fn simd_min(self, other: Simd<Simd<[u128; 4]>>) -> Simd<Simd<[u128; 4]>>`

`pub fn simd_clamp( self, min: Simd<Simd<[u128; 4]>>, max: Simd<Simd<[u128; 4]>> ) -> Simd<Simd<[u128; 4]>>`

`pub fn simd_horizontal_min( self ) -> <Simd<Simd<[u128; 4]>> as SimdValue>::Element`

`pub fn simd_horizontal_max( self ) -> <Simd<Simd<[u128; 4]>> as SimdValue>::Element`

`impl SimdPartialOrd for AutoSimd<[u32; 2]>`

`pub fn simd_gt( self, other: AutoSimd<[u32; 2]> ) -> <AutoSimd<[u32; 2]> as SimdValue>::SimdBool`

`pub fn simd_lt( self, other: AutoSimd<[u32; 2]> ) -> <AutoSimd<[u32; 2]> as SimdValue>::SimdBool`

`pub fn simd_ge( self, other: AutoSimd<[u32; 2]> ) -> <AutoSimd<[u32; 2]> as SimdValue>::SimdBool`

`pub fn simd_le( self, other: AutoSimd<[u32; 2]> ) -> <AutoSimd<[u32; 2]> as SimdValue>::SimdBool`

`pub fn simd_eq( self, other: AutoSimd<[u32; 2]> ) -> <AutoSimd<[u32; 2]> as SimdValue>::SimdBool`

`pub fn simd_ne( self, other: AutoSimd<[u32; 2]> ) -> <AutoSimd<[u32; 2]> as SimdValue>::SimdBool`

`pub fn simd_max(self, other: AutoSimd<[u32; 2]>) -> AutoSimd<[u32; 2]>`