Trait nalgebra::SimdPartialOrd

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

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

Required methods

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

Lanewise greater than > comparison.

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

Lanewise less than < comparison.

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

Lanewise greater or equal >= comparison.

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

Lanewise less or equal <= comparison.

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

Lanewise equal == comparison.

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

Lanewise not equal != comparison.

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

Lanewise max value.

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

Lanewise min value.

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

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

fn simd_horizontal_min(self) -> Self::Element

The min value among all lanes of self.

fn simd_horizontal_max(self) -> Self::Element

The max value among all lanes of self.

Implementations on Foreign Types

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 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<[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 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<[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 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 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<[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 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 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<[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 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<[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<[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 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<[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<[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<[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 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<[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 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<[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<[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 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<[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 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<[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 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<[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<[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 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<[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 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 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 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<[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 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 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<[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<[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 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 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<[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<[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<[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<[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<[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; 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<[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 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 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 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 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

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