Trait lnkit::prelude::SimdValue[−]

pub trait SimdValue {
    type Element: SimdValue;
    type SimdBool: SimdBool;
    pub fn lanes() -> usize;
    pub fn splat(val: Self::Element) -> Self;
    pub fn extract(&self, i: usize) -> Self::Element;
    pub unsafe fn extract_unchecked(&self, i: usize) -> Self::Element;
    pub fn replace(&mut self, i: usize, val: Self::Element);
    pub unsafe fn replace_unchecked(&mut self, i: usize, val: Self::Element);
    pub fn select(self, cond: Self::SimdBool, other: Self) -> Self;

    pub fn map_lanes(self, f: impl Fn(Self::Element) -> Self::Element) -> Self
    where
        Self: Clone,
    { ... }
    pub fn zip_map_lanes(
        self, 
        b: Self, 
        f: impl Fn(Self::Element, Self::Element) -> Self::Element
    ) -> Self
    where
        Self: Clone,
    { ... }
}

Base trait for every SIMD types.

Associated Types

`type Element: SimdValue`

The type of the elements of each lane of this SIMD value.

`type SimdBool: SimdBool`

Type of the result of comparing two SIMD values like self.

Loading content...

Required methods

`pub fn lanes() -> usize`

The number of lanes of this SIMD value.

`pub fn splat(val: Self::Element) -> Self`

Initializes an SIMD value with each lanes set to val.

`pub fn extract(&self, i: usize) -> Self::Element`

Extracts the i-th lane of self.

Panics if i >= Self::lanes().

`pub unsafe fn extract_unchecked(&self, i: usize) -> Self::Element`

Extracts the i-th lane of self without bound-checking.

`pub fn replace(&mut self, i: usize, val: Self::Element)`

Replaces the i-th lane of self by val.

Panics if i >= Self::lanes().

`pub unsafe fn replace_unchecked(&mut self, i: usize, val: Self::Element)`

Replaces the i-th lane of self by val without bound-checking.

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

Merges self and other depending on the lanes of cond.

For each lane of cond with bits set to 1, the result’s will contain the value of the lane of self. For each lane of cond with bits set to 0, the result’s will contain the value of the lane of other.

Loading content...

Provided methods

`pub fn map_lanes(self, f: impl Fn(Self::Element) -> Self::Element) -> Self where Self: Clone,`

Applies a function to each lane of self.

Note that, while convenient, this method can be extremely slow as this requires to extract each lane of self and then combine them again into a new SIMD value.

`pub fn zip_map_lanes( self, b: Self, f: impl Fn(Self::Element, Self::Element) -> Self::Element ) -> Self where Self: Clone,`

Applies a function to each lane of self paired with the corresponding lane of b.

Note that, while convenient, this method can be extremely slow as this requires to extract each lane of self and then combine them again into a new SIMD value.

Loading content...

Implementations on Foreign Types

`impl SimdValue for Simd<Simd<[m64; 2]>>`

`type Element = bool`

`type SimdBool = Simd<Simd<[m64; 2]>>`

`pub fn lanes() -> usize`

`pub fn splat( val: <Simd<Simd<[m64; 2]>> as SimdValue>::Element ) -> Simd<Simd<[m64; 2]>>`

`pub fn extract(&self, i: usize) -> <Simd<Simd<[m64; 2]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[m64; 2]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[m64; 2]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[m64; 2]>> as SimdValue>::Element )`

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

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

`type Element = u16`

`type SimdBool = AutoSimd<[bool; 8]>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <AutoSimd<[u16; 8]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[u16; 8]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[u16; 8]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[u16; 8]> as SimdValue>::Element )`

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

`impl SimdValue for Simd<Simd<[m8; 64]>>`

`type Element = bool`

`type SimdBool = Simd<Simd<[m8; 64]>>`

`pub fn lanes() -> usize`

`pub fn splat( val: <Simd<Simd<[m8; 64]>> as SimdValue>::Element ) -> Simd<Simd<[m8; 64]>>`

`pub fn extract(&self, i: usize) -> <Simd<Simd<[m8; 64]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[m8; 64]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[m8; 64]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[m8; 64]>> as SimdValue>::Element )`

`pub fn select( self, cond: <Simd<Simd<[m8; 64]>> as SimdValue>::SimdBool, other: Simd<Simd<[m8; 64]>> ) -> Simd<Simd<[m8; 64]>>`

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

`type Element = isize`

`type SimdBool = Simd<Simd<[msize; 2]>>`

`pub fn lanes() -> usize`

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

`pub fn extract( &self, i: usize ) -> <Simd<Simd<[isize; 2]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[isize; 2]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[isize; 2]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[isize; 2]>> as SimdValue>::Element )`

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

`impl SimdValue for u128`

`type Element = u128`

`type SimdBool = bool`

`pub fn lanes() -> usize`

`pub fn splat(val: <u128 as SimdValue>::Element) -> u128`

`pub fn extract(&self, usize) -> <u128 as SimdValue>::Element`

`pub unsafe fn extract_unchecked(&self, usize) -> <u128 as SimdValue>::Element`

`pub fn replace(&mut self, usize, val: <u128 as SimdValue>::Element)`

`pub unsafe fn replace_unchecked( &mut self, usize, val: <u128 as SimdValue>::Element )`

`pub fn select(self, cond: <u128 as SimdValue>::SimdBool, other: u128) -> u128`

`impl SimdValue for AutoSimd<[i16; 16]>`

`type Element = i16`

`type SimdBool = AutoSimd<[bool; 16]>`

`pub fn lanes() -> usize`

`pub fn splat( val: <AutoSimd<[i16; 16]> as SimdValue>::Element ) -> AutoSimd<[i16; 16]>`

`pub fn extract(&self, i: usize) -> <AutoSimd<[i16; 16]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[i16; 16]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[i16; 16]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[i16; 16]> as SimdValue>::Element )`

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

`impl SimdValue for i8`

`type Element = i8`

`type SimdBool = bool`

`pub fn lanes() -> usize`

`pub fn splat(val: <i8 as SimdValue>::Element) -> i8`

`pub fn extract(&self, usize) -> <i8 as SimdValue>::Element`

`pub unsafe fn extract_unchecked(&self, usize) -> <i8 as SimdValue>::Element`

`pub fn replace(&mut self, usize, val: <i8 as SimdValue>::Element)`

`pub unsafe fn replace_unchecked( &mut self, usize, val: <i8 as SimdValue>::Element )`

`pub fn select(self, cond: <i8 as SimdValue>::SimdBool, other: i8) -> i8`

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

`type Element = i128`

`type SimdBool = AutoSimd<[bool; 1]>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <AutoSimd<[i128; 1]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[i128; 1]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[i128; 1]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[i128; 1]> as SimdValue>::Element )`

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

`impl SimdValue for Simd<Simd<[isize; 4]>>`

`type Element = isize`

`type SimdBool = Simd<Simd<[msize; 4]>>`

`pub fn lanes() -> usize`

`pub fn splat( val: <Simd<Simd<[isize; 4]>> as SimdValue>::Element ) -> Simd<Simd<[isize; 4]>>`

`pub fn extract( &self, i: usize ) -> <Simd<Simd<[isize; 4]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[isize; 4]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[isize; 4]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[isize; 4]>> as SimdValue>::Element )`

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

`impl SimdValue for AutoSimd<[u8; 16]>`

`type Element = u8`

`type SimdBool = AutoSimd<[bool; 16]>`

`pub fn lanes() -> usize`

`pub fn splat( val: <AutoSimd<[u8; 16]> as SimdValue>::Element ) -> AutoSimd<[u8; 16]>`

`pub fn extract(&self, i: usize) -> <AutoSimd<[u8; 16]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[u8; 16]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[u8; 16]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[u8; 16]> as SimdValue>::Element )`

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

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

`type Element = i64`

`type SimdBool = Simd<Simd<[m64; 2]>>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <Simd<Simd<[i64; 2]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[i64; 2]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[i64; 2]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[i64; 2]>> as SimdValue>::Element )`

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

`impl SimdValue for Simd<Simd<[i64; 4]>>`

`type Element = i64`

`type SimdBool = Simd<Simd<[m64; 4]>>`

`pub fn lanes() -> usize`

`pub fn splat( val: <Simd<Simd<[i64; 4]>> as SimdValue>::Element ) -> Simd<Simd<[i64; 4]>>`

`pub fn extract(&self, i: usize) -> <Simd<Simd<[i64; 4]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[i64; 4]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[i64; 4]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[i64; 4]>> as SimdValue>::Element )`

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

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

`type Element = i64`

`type SimdBool = AutoSimd<[bool; 2]>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <AutoSimd<[i64; 2]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[i64; 2]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[i64; 2]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[i64; 2]> as SimdValue>::Element )`

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

`impl SimdValue for i16`

`type Element = i16`

`type SimdBool = bool`

`pub fn lanes() -> usize`

`pub fn splat(val: <i16 as SimdValue>::Element) -> i16`

`pub fn extract(&self, usize) -> <i16 as SimdValue>::Element`

`pub unsafe fn extract_unchecked(&self, usize) -> <i16 as SimdValue>::Element`

`pub fn replace(&mut self, usize, val: <i16 as SimdValue>::Element)`

`pub unsafe fn replace_unchecked( &mut self, usize, val: <i16 as SimdValue>::Element )`

`pub fn select(self, cond: <i16 as SimdValue>::SimdBool, other: i16) -> i16`

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

`type Element = i128`

`type SimdBool = Simd<Simd<[m128; 1]>>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <Simd<Simd<[i128; 1]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[i128; 1]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[i128; 1]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[i128; 1]>> as SimdValue>::Element )`

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

`impl SimdValue for AutoSimd<[u128; 4]>`

`type Element = u128`

`type SimdBool = AutoSimd<[bool; 4]>`

`pub fn lanes() -> usize`

`pub fn splat( val: <AutoSimd<[u128; 4]> as SimdValue>::Element ) -> AutoSimd<[u128; 4]>`

`pub fn extract(&self, i: usize) -> <AutoSimd<[u128; 4]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[u128; 4]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[u128; 4]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[u128; 4]> as SimdValue>::Element )`

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

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

`type Element = u64`

`type SimdBool = AutoSimd<[bool; 4]>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <AutoSimd<[u64; 4]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[u64; 4]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[u64; 4]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[u64; 4]> as SimdValue>::Element )`

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

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

`type Element = f32`

`type SimdBool = AutoSimd<[bool; 8]>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <AutoSimd<[f32; 8]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[f32; 8]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[f32; 8]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[f32; 8]> as SimdValue>::Element )`

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

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

`type Element = f32`

`type SimdBool = AutoSimd<[bool; 16]>`

`pub fn lanes() -> usize`

`pub fn splat( val: <AutoSimd<[f32; 16]> as SimdValue>::Element ) -> AutoSimd<[f32; 16]>`

`pub fn extract(&self, i: usize) -> <AutoSimd<[f32; 16]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[f32; 16]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[f32; 16]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[f32; 16]> as SimdValue>::Element )`

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

`impl SimdValue for AutoSimd<[bool; 32]>`

`type Element = bool`

`type SimdBool = AutoSimd<[bool; 32]>`

`pub fn lanes() -> usize`

`pub fn splat( val: <AutoSimd<[bool; 32]> as SimdValue>::Element ) -> AutoSimd<[bool; 32]>`

`pub fn extract(&self, i: usize) -> <AutoSimd<[bool; 32]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[bool; 32]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[bool; 32]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[bool; 32]> as SimdValue>::Element )`

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

`impl SimdValue for AutoSimd<[f64; 8]>`

`type Element = f64`

`type SimdBool = AutoSimd<[bool; 8]>`

`pub fn lanes() -> usize`

`pub fn splat( val: <AutoSimd<[f64; 8]> as SimdValue>::Element ) -> AutoSimd<[f64; 8]>`

`pub fn extract(&self, i: usize) -> <AutoSimd<[f64; 8]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[f64; 8]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[f64; 8]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[f64; 8]> as SimdValue>::Element )`

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

`impl SimdValue for i64`

`type Element = i64`

`type SimdBool = bool`

`pub fn lanes() -> usize`

`pub fn splat(val: <i64 as SimdValue>::Element) -> i64`

`pub fn extract(&self, usize) -> <i64 as SimdValue>::Element`

`pub unsafe fn extract_unchecked(&self, usize) -> <i64 as SimdValue>::Element`

`pub fn replace(&mut self, usize, val: <i64 as SimdValue>::Element)`

`pub unsafe fn replace_unchecked( &mut self, usize, val: <i64 as SimdValue>::Element )`

`pub fn select(self, cond: <i64 as SimdValue>::SimdBool, other: i64) -> i64`

`impl SimdValue for bool`

`type Element = bool`

`type SimdBool = bool`

`pub fn lanes() -> usize`

`pub fn splat(val: <bool as SimdValue>::Element) -> bool`

`pub fn extract(&self, usize) -> <bool as SimdValue>::Element`

`pub unsafe fn extract_unchecked(&self, usize) -> <bool as SimdValue>::Element`

`pub fn replace(&mut self, usize, val: <bool as SimdValue>::Element)`

`pub unsafe fn replace_unchecked( &mut self, usize, val: <bool as SimdValue>::Element )`

`pub fn select(self, cond: <bool as SimdValue>::SimdBool, other: bool) -> bool`

`impl SimdValue for u16`

`type Element = u16`

`type SimdBool = bool`

`pub fn lanes() -> usize`

`pub fn splat(val: <u16 as SimdValue>::Element) -> u16`

`pub fn extract(&self, usize) -> <u16 as SimdValue>::Element`

`pub unsafe fn extract_unchecked(&self, usize) -> <u16 as SimdValue>::Element`

`pub fn replace(&mut self, usize, val: <u16 as SimdValue>::Element)`

`pub unsafe fn replace_unchecked( &mut self, usize, val: <u16 as SimdValue>::Element )`

`pub fn select(self, cond: <u16 as SimdValue>::SimdBool, other: u16) -> u16`

`impl SimdValue for AutoSimd<[i32; 4]>`

`type Element = i32`

`type SimdBool = AutoSimd<[bool; 4]>`

`pub fn lanes() -> usize`

`pub fn splat( val: <AutoSimd<[i32; 4]> as SimdValue>::Element ) -> AutoSimd<[i32; 4]>`

`pub fn extract(&self, i: usize) -> <AutoSimd<[i32; 4]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[i32; 4]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[i32; 4]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[i32; 4]> as SimdValue>::Element )`

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

`impl SimdValue for Simd<Simd<[m32; 8]>>`

`type Element = bool`

`type SimdBool = Simd<Simd<[m32; 8]>>`

`pub fn lanes() -> usize`

`pub fn splat( val: <Simd<Simd<[m32; 8]>> as SimdValue>::Element ) -> Simd<Simd<[m32; 8]>>`

`pub fn extract(&self, i: usize) -> <Simd<Simd<[m32; 8]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[m32; 8]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[m32; 8]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[m32; 8]>> as SimdValue>::Element )`

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

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

`type Element = u16`

`type SimdBool = Simd<Simd<[m16; 4]>>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <Simd<Simd<[u16; 4]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[u16; 4]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[u16; 4]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[u16; 4]>> as SimdValue>::Element )`

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

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

`type Element = i128`

`type SimdBool = Simd<Simd<[m128; 4]>>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <Simd<Simd<[i128; 4]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[i128; 4]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[i128; 4]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[i128; 4]>> as SimdValue>::Element )`

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

`impl SimdValue for isize`

`type Element = isize`

`type SimdBool = bool`

`pub fn lanes() -> usize`

`pub fn splat(val: <isize as SimdValue>::Element) -> isize`

`pub fn extract(&self, usize) -> <isize as SimdValue>::Element`

`pub unsafe fn extract_unchecked(&self, usize) -> <isize as SimdValue>::Element`

`pub fn replace(&mut self, usize, val: <isize as SimdValue>::Element)`

`pub unsafe fn replace_unchecked( &mut self, usize, val: <isize as SimdValue>::Element )`

`pub fn select(self, cond: <isize as SimdValue>::SimdBool, other: isize) -> isize`

`impl SimdValue for AutoSimd<[u32; 4]>`

`type Element = u32`

`type SimdBool = AutoSimd<[bool; 4]>`

`pub fn lanes() -> usize`

`pub fn splat( val: <AutoSimd<[u32; 4]> as SimdValue>::Element ) -> AutoSimd<[u32; 4]>`

`pub fn extract(&self, i: usize) -> <AutoSimd<[u32; 4]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[u32; 4]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[u32; 4]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[u32; 4]> as SimdValue>::Element )`

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

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

`type Element = i8`

`type SimdBool = Simd<Simd<[m8; 4]>>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <Simd<Simd<[i8; 4]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[i8; 4]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[i8; 4]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[i8; 4]>> as SimdValue>::Element )`

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

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

`type Element = u64`

`type SimdBool = Simd<Simd<[m64; 4]>>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <Simd<Simd<[u64; 4]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[u64; 4]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[u64; 4]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[u64; 4]>> as SimdValue>::Element )`

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

`impl SimdValue for Simd<Simd<[i32; 16]>>`

`type Element = i32`

`type SimdBool = Simd<Simd<[m32; 16]>>`

`pub fn lanes() -> usize`

`pub fn splat( val: <Simd<Simd<[i32; 16]>> as SimdValue>::Element ) -> Simd<Simd<[i32; 16]>>`

`pub fn extract(&self, i: usize) -> <Simd<Simd<[i32; 16]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[i32; 16]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[i32; 16]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[i32; 16]>> as SimdValue>::Element )`

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

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

`type Element = i16`

`type SimdBool = Simd<Simd<[m16; 4]>>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <Simd<Simd<[i16; 4]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[i16; 4]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[i16; 4]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[i16; 4]>> as SimdValue>::Element )`

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

`impl SimdValue for AutoSimd<[u128; 2]>`

`type Element = u128`

`type SimdBool = AutoSimd<[bool; 2]>`

`pub fn lanes() -> usize`

`pub fn splat( val: <AutoSimd<[u128; 2]> as SimdValue>::Element ) -> AutoSimd<[u128; 2]>`

`pub fn extract(&self, i: usize) -> <AutoSimd<[u128; 2]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[u128; 2]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[u128; 2]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[u128; 2]> as SimdValue>::Element )`

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

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

`type Element = u128`

`type SimdBool = AutoSimd<[bool; 1]>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <AutoSimd<[u128; 1]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[u128; 1]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[u128; 1]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[u128; 1]> as SimdValue>::Element )`

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

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

`type Element = isize`

`type SimdBool = Simd<Simd<[msize; 8]>>`

`pub fn lanes() -> usize`

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

`pub fn extract( &self, i: usize ) -> <Simd<Simd<[isize; 8]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[isize; 8]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[isize; 8]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[isize; 8]>> as SimdValue>::Element )`

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

`impl SimdValue for Simd<Simd<[u32; 4]>>`

`type Element = u32`

`type SimdBool = Simd<Simd<[m32; 4]>>`

`pub fn lanes() -> usize`

`pub fn splat( val: <Simd<Simd<[u32; 4]>> as SimdValue>::Element ) -> Simd<Simd<[u32; 4]>>`

`pub fn extract(&self, i: usize) -> <Simd<Simd<[u32; 4]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[u32; 4]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[u32; 4]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[u32; 4]>> as SimdValue>::Element )`

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

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

`type Element = u128`

`type SimdBool = Simd<Simd<[m128; 4]>>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <Simd<Simd<[u128; 4]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[u128; 4]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[u128; 4]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[u128; 4]>> as SimdValue>::Element )`

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

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

`type Element = u32`

`type SimdBool = Simd<Simd<[m32; 8]>>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <Simd<Simd<[u32; 8]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[u32; 8]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[u32; 8]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[u32; 8]>> as SimdValue>::Element )`

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

`impl SimdValue for Simd<Simd<[u32; 2]>>`

`type Element = u32`

`type SimdBool = Simd<Simd<[m32; 2]>>`

`pub fn lanes() -> usize`

`pub fn splat( val: <Simd<Simd<[u32; 2]>> as SimdValue>::Element ) -> Simd<Simd<[u32; 2]>>`

`pub fn extract(&self, i: usize) -> <Simd<Simd<[u32; 2]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[u32; 2]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[u32; 2]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[u32; 2]>> as SimdValue>::Element )`

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

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

`type Element = u8`

`type SimdBool = Simd<Simd<[m8; 2]>>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <Simd<Simd<[u8; 2]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[u8; 2]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[u8; 2]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[u8; 2]>> as SimdValue>::Element )`

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

`impl SimdValue for Simd<Simd<[u128; 1]>>`

`type Element = u128`

`type SimdBool = Simd<Simd<[m128; 1]>>`

`pub fn lanes() -> usize`

`pub fn splat( val: <Simd<Simd<[u128; 1]>> as SimdValue>::Element ) -> Simd<Simd<[u128; 1]>>`

`pub fn extract(&self, i: usize) -> <Simd<Simd<[u128; 1]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[u128; 1]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[u128; 1]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[u128; 1]>> as SimdValue>::Element )`

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

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

`type Element = u32`

`type SimdBool = AutoSimd<[bool; 2]>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <AutoSimd<[u32; 2]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[u32; 2]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[u32; 2]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[u32; 2]> as SimdValue>::Element )`

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

`impl SimdValue for Simd<Simd<[f64; 2]>>`

`type Element = f64`

`type SimdBool = Simd<Simd<[m64; 2]>>`

`pub fn lanes() -> usize`

`pub fn splat( val: <Simd<Simd<[f64; 2]>> as SimdValue>::Element ) -> Simd<Simd<[f64; 2]>>`

`pub fn extract(&self, i: usize) -> <Simd<Simd<[f64; 2]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[f64; 2]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[f64; 2]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[f64; 2]>> as SimdValue>::Element )`

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

`impl SimdValue for Simd<Simd<[m8; 16]>>`

`type Element = bool`

`type SimdBool = Simd<Simd<[m8; 16]>>`

`pub fn lanes() -> usize`

`pub fn splat( val: <Simd<Simd<[m8; 16]>> as SimdValue>::Element ) -> Simd<Simd<[m8; 16]>>`

`pub fn extract(&self, i: usize) -> <Simd<Simd<[m8; 16]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[m8; 16]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[m8; 16]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[m8; 16]>> as SimdValue>::Element )`

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

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

`type Element = f32`

`type SimdBool = Simd<Simd<[m32; 2]>>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <Simd<Simd<[f32; 2]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[f32; 2]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[f32; 2]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[f32; 2]>> as SimdValue>::Element )`

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

`impl SimdValue for Simd<Simd<[msize; 4]>>`

`type Element = bool`

`type SimdBool = Simd<Simd<[msize; 4]>>`

`pub fn lanes() -> usize`

`pub fn splat( val: <Simd<Simd<[msize; 4]>> as SimdValue>::Element ) -> Simd<Simd<[msize; 4]>>`

`pub fn extract( &self, i: usize ) -> <Simd<Simd<[msize; 4]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[msize; 4]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[msize; 4]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[msize; 4]>> as SimdValue>::Element )`

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

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

`type Element = u8`

`type SimdBool = Simd<Simd<[m8; 32]>>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <Simd<Simd<[u8; 32]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[u8; 32]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[u8; 32]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[u8; 32]>> as SimdValue>::Element )`

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

`impl SimdValue for AutoSimd<[i16; 4]>`

`type Element = i16`

`type SimdBool = AutoSimd<[bool; 4]>`

`pub fn lanes() -> usize`

`pub fn splat( val: <AutoSimd<[i16; 4]> as SimdValue>::Element ) -> AutoSimd<[i16; 4]>`

`pub fn extract(&self, i: usize) -> <AutoSimd<[i16; 4]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[i16; 4]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[i16; 4]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[i16; 4]> as SimdValue>::Element )`

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

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

`type Element = u16`

`type SimdBool = AutoSimd<[bool; 32]>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <AutoSimd<[u16; 32]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[u16; 32]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[u16; 32]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[u16; 32]> as SimdValue>::Element )`

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

`impl SimdValue for Simd<Simd<[m16; 2]>>`

`type Element = bool`

`type SimdBool = Simd<Simd<[m16; 2]>>`

`pub fn lanes() -> usize`

`pub fn splat( val: <Simd<Simd<[m16; 2]>> as SimdValue>::Element ) -> Simd<Simd<[m16; 2]>>`

`pub fn extract(&self, i: usize) -> <Simd<Simd<[m16; 2]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[m16; 2]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[m16; 2]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[m16; 2]>> as SimdValue>::Element )`

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

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

`type Element = i32`

`type SimdBool = Simd<Simd<[m32; 2]>>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <Simd<Simd<[i32; 2]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[i32; 2]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[i32; 2]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[i32; 2]>> as SimdValue>::Element )`

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

`impl SimdValue for Simd<Simd<[m128; 2]>>`

`type Element = bool`

`type SimdBool = Simd<Simd<[m128; 2]>>`

`pub fn lanes() -> usize`

`pub fn splat( val: <Simd<Simd<[m128; 2]>> as SimdValue>::Element ) -> Simd<Simd<[m128; 2]>>`

`pub fn extract(&self, i: usize) -> <Simd<Simd<[m128; 2]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[m128; 2]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[m128; 2]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[m128; 2]>> as SimdValue>::Element )`

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

`impl SimdValue for Simd<Simd<[m16; 8]>>`

`type Element = bool`

`type SimdBool = Simd<Simd<[m16; 8]>>`

`pub fn lanes() -> usize`

`pub fn splat( val: <Simd<Simd<[m16; 8]>> as SimdValue>::Element ) -> Simd<Simd<[m16; 8]>>`

`pub fn extract(&self, i: usize) -> <Simd<Simd<[m16; 8]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[m16; 8]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[m16; 8]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[m16; 8]>> as SimdValue>::Element )`

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

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

`type Element = usize`

`type SimdBool = Simd<Simd<[msize; 4]>>`

`pub fn lanes() -> usize`

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

`pub fn extract( &self, i: usize ) -> <Simd<Simd<[usize; 4]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[usize; 4]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[usize; 4]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[usize; 4]>> as SimdValue>::Element )`

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

`impl SimdValue for Simd<Simd<[f64; 4]>>`

`type Element = f64`

`type SimdBool = Simd<Simd<[m64; 4]>>`

`pub fn lanes() -> usize`

`pub fn splat( val: <Simd<Simd<[f64; 4]>> as SimdValue>::Element ) -> Simd<Simd<[f64; 4]>>`

`pub fn extract(&self, i: usize) -> <Simd<Simd<[f64; 4]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[f64; 4]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[f64; 4]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[f64; 4]>> as SimdValue>::Element )`

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

`impl SimdValue for Simd<Simd<[i8; 64]>>`

`type Element = i8`

`type SimdBool = Simd<Simd<[m8; 64]>>`

`pub fn lanes() -> usize`

`pub fn splat( val: <Simd<Simd<[i8; 64]>> as SimdValue>::Element ) -> Simd<Simd<[i8; 64]>>`

`pub fn extract(&self, i: usize) -> <Simd<Simd<[i8; 64]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[i8; 64]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[i8; 64]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[i8; 64]>> as SimdValue>::Element )`

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

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

`type Element = i16`

`type SimdBool = Simd<Simd<[m16; 8]>>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <Simd<Simd<[i16; 8]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[i16; 8]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[i16; 8]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[i16; 8]>> as SimdValue>::Element )`

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

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

`type Element = u32`

`type SimdBool = AutoSimd<[bool; 16]>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <AutoSimd<[u32; 16]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[u32; 16]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[u32; 16]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[u32; 16]> as SimdValue>::Element )`

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

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

`type Element = i16`

`type SimdBool = AutoSimd<[bool; 2]>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <AutoSimd<[i16; 2]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[i16; 2]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[i16; 2]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[i16; 2]> as SimdValue>::Element )`

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

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

`type Element = i16`

`type SimdBool = Simd<Simd<[m16; 32]>>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <Simd<Simd<[i16; 32]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[i16; 32]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[i16; 32]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[i16; 32]>> as SimdValue>::Element )`

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

`impl SimdValue for Simd<Simd<[msize; 8]>>`

`type Element = bool`

`type SimdBool = Simd<Simd<[msize; 8]>>`

`pub fn lanes() -> usize`

`pub fn splat( val: <Simd<Simd<[msize; 8]>> as SimdValue>::Element ) -> Simd<Simd<[msize; 8]>>`

`pub fn extract( &self, i: usize ) -> <Simd<Simd<[msize; 8]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[msize; 8]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[msize; 8]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[msize; 8]>> as SimdValue>::Element )`

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

`impl SimdValue for i128`

`type Element = i128`

`type SimdBool = bool`

`pub fn lanes() -> usize`

`pub fn splat(val: <i128 as SimdValue>::Element) -> i128`

`pub fn extract(&self, usize) -> <i128 as SimdValue>::Element`

`pub unsafe fn extract_unchecked(&self, usize) -> <i128 as SimdValue>::Element`

`pub fn replace(&mut self, usize, val: <i128 as SimdValue>::Element)`

`pub unsafe fn replace_unchecked( &mut self, usize, val: <i128 as SimdValue>::Element )`

`pub fn select(self, cond: <i128 as SimdValue>::SimdBool, other: i128) -> i128`

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

`type Element = i32`

`type SimdBool = AutoSimd<[bool; 2]>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <AutoSimd<[i32; 2]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[i32; 2]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[i32; 2]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[i32; 2]> as SimdValue>::Element )`

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

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

`type Element = u64`

`type SimdBool = AutoSimd<[bool; 2]>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <AutoSimd<[u64; 2]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[u64; 2]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[u64; 2]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[u64; 2]> as SimdValue>::Element )`

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

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

`type Element = i128`

`type SimdBool = AutoSimd<[bool; 2]>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <AutoSimd<[i128; 2]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[i128; 2]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[i128; 2]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[i128; 2]> as SimdValue>::Element )`

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

`impl SimdValue for AutoSimd<[u8; 4]>`

`type Element = u8`

`type SimdBool = AutoSimd<[bool; 4]>`

`pub fn lanes() -> usize`

`pub fn splat( val: <AutoSimd<[u8; 4]> as SimdValue>::Element ) -> AutoSimd<[u8; 4]>`

`pub fn extract(&self, i: usize) -> <AutoSimd<[u8; 4]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[u8; 4]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[u8; 4]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[u8; 4]> as SimdValue>::Element )`

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

`impl SimdValue for AutoSimd<[i16; 32]>`

`type Element = i16`

`type SimdBool = AutoSimd<[bool; 32]>`

`pub fn lanes() -> usize`

`pub fn splat( val: <AutoSimd<[i16; 32]> as SimdValue>::Element ) -> AutoSimd<[i16; 32]>`

`pub fn extract(&self, i: usize) -> <AutoSimd<[i16; 32]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[i16; 32]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[i16; 32]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[i16; 32]> as SimdValue>::Element )`

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

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

`type Element = i128`

`type SimdBool = AutoSimd<[bool; 4]>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <AutoSimd<[i128; 4]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[i128; 4]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[i128; 4]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[i128; 4]> as SimdValue>::Element )`

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

`impl SimdValue for Simd<Simd<[u8; 4]>>`

`type Element = u8`

`type SimdBool = Simd<Simd<[m8; 4]>>`

`pub fn lanes() -> usize`

`pub fn splat( val: <Simd<Simd<[u8; 4]>> as SimdValue>::Element ) -> Simd<Simd<[u8; 4]>>`

`pub fn extract(&self, i: usize) -> <Simd<Simd<[u8; 4]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[u8; 4]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[u8; 4]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[u8; 4]>> as SimdValue>::Element )`

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

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

`type Element = u64`

`type SimdBool = AutoSimd<[bool; 8]>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <AutoSimd<[u64; 8]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[u64; 8]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[u64; 8]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[u64; 8]> as SimdValue>::Element )`

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

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

`type Element = f32`

`type SimdBool = Simd<Simd<[m32; 16]>>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <Simd<Simd<[f32; 16]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[f32; 16]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[f32; 16]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[f32; 16]>> as SimdValue>::Element )`

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

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

`type Element = i8`

`type SimdBool = AutoSimd<[bool; 32]>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <AutoSimd<[i8; 32]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[i8; 32]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[i8; 32]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[i8; 32]> as SimdValue>::Element )`

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

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

`type Element = u16`

`type SimdBool = AutoSimd<[bool; 2]>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <AutoSimd<[u16; 2]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[u16; 2]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[u16; 2]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[u16; 2]> as SimdValue>::Element )`

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

`impl SimdValue for Simd<Simd<[u8; 8]>>`

`type Element = u8`

`type SimdBool = Simd<Simd<[m8; 8]>>`

`pub fn lanes() -> usize`

`pub fn splat( val: <Simd<Simd<[u8; 8]>> as SimdValue>::Element ) -> Simd<Simd<[u8; 8]>>`

`pub fn extract(&self, i: usize) -> <Simd<Simd<[u8; 8]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[u8; 8]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[u8; 8]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[u8; 8]>> as SimdValue>::Element )`

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

`impl SimdValue for Simd<Simd<[m16; 4]>>`

`type Element = bool`

`type SimdBool = Simd<Simd<[m16; 4]>>`

`pub fn lanes() -> usize`

`pub fn splat( val: <Simd<Simd<[m16; 4]>> as SimdValue>::Element ) -> Simd<Simd<[m16; 4]>>`

`pub fn extract(&self, i: usize) -> <Simd<Simd<[m16; 4]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[m16; 4]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[m16; 4]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[m16; 4]>> as SimdValue>::Element )`

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

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

`type Element = i8`

`type SimdBool = AutoSimd<[bool; 4]>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <AutoSimd<[i8; 4]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[i8; 4]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[i8; 4]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[i8; 4]> as SimdValue>::Element )`

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

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

`type Element = i16`

`type SimdBool = Simd<Simd<[m16; 2]>>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <Simd<Simd<[i16; 2]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[i16; 2]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[i16; 2]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[i16; 2]>> as SimdValue>::Element )`

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

`impl SimdValue for Simd<Simd<[u16; 8]>>`

`type Element = u16`

`type SimdBool = Simd<Simd<[m16; 8]>>`

`pub fn lanes() -> usize`

`pub fn splat( val: <Simd<Simd<[u16; 8]>> as SimdValue>::Element ) -> Simd<Simd<[u16; 8]>>`

`pub fn extract(&self, i: usize) -> <Simd<Simd<[u16; 8]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[u16; 8]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[u16; 8]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[u16; 8]>> as SimdValue>::Element )`

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

`impl SimdValue for AutoSimd<[u8; 32]>`

`type Element = u8`

`type SimdBool = AutoSimd<[bool; 32]>`

`pub fn lanes() -> usize`

`pub fn splat( val: <AutoSimd<[u8; 32]> as SimdValue>::Element ) -> AutoSimd<[u8; 32]>`

`pub fn extract(&self, i: usize) -> <AutoSimd<[u8; 32]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[u8; 32]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[u8; 32]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[u8; 32]> as SimdValue>::Element )`

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

`impl SimdValue for u64`

`type Element = u64`

`type SimdBool = bool`

`pub fn lanes() -> usize`

`pub fn splat(val: <u64 as SimdValue>::Element) -> u64`

`pub fn extract(&self, usize) -> <u64 as SimdValue>::Element`

`pub unsafe fn extract_unchecked(&self, usize) -> <u64 as SimdValue>::Element`

`pub fn replace(&mut self, usize, val: <u64 as SimdValue>::Element)`

`pub unsafe fn replace_unchecked( &mut self, usize, val: <u64 as SimdValue>::Element )`

`pub fn select(self, cond: <u64 as SimdValue>::SimdBool, other: u64) -> u64`

`impl SimdValue for Simd<Simd<[u64; 2]>>`

`type Element = u64`

`type SimdBool = Simd<Simd<[m64; 2]>>`

`pub fn lanes() -> usize`

`pub fn splat( val: <Simd<Simd<[u64; 2]>> as SimdValue>::Element ) -> Simd<Simd<[u64; 2]>>`

`pub fn extract(&self, i: usize) -> <Simd<Simd<[u64; 2]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[u64; 2]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[u64; 2]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[u64; 2]>> as SimdValue>::Element )`

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

`impl SimdValue for Simd<Simd<[m64; 4]>>`

`type Element = bool`

`type SimdBool = Simd<Simd<[m64; 4]>>`

`pub fn lanes() -> usize`

`pub fn splat( val: <Simd<Simd<[m64; 4]>> as SimdValue>::Element ) -> Simd<Simd<[m64; 4]>>`

`pub fn extract(&self, i: usize) -> <Simd<Simd<[m64; 4]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[m64; 4]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[m64; 4]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[m64; 4]>> as SimdValue>::Element )`

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

`impl SimdValue for AutoSimd<[bool; 2]>`

`type Element = bool`

`type SimdBool = AutoSimd<[bool; 2]>`

`pub fn lanes() -> usize`

`pub fn splat( val: <AutoSimd<[bool; 2]> as SimdValue>::Element ) -> AutoSimd<[bool; 2]>`

`pub fn extract(&self, i: usize) -> <AutoSimd<[bool; 2]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[bool; 2]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[bool; 2]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[bool; 2]> as SimdValue>::Element )`

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

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

`type Element = isize`

`type SimdBool = AutoSimd<[bool; 4]>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <AutoSimd<[isize; 4]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[isize; 4]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[isize; 4]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[isize; 4]> as SimdValue>::Element )`

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

`impl SimdValue for Simd<Simd<[msize; 2]>>`

`type Element = bool`

`type SimdBool = Simd<Simd<[msize; 2]>>`

`pub fn lanes() -> usize`

`pub fn splat( val: <Simd<Simd<[msize; 2]>> as SimdValue>::Element ) -> Simd<Simd<[msize; 2]>>`

`pub fn extract( &self, i: usize ) -> <Simd<Simd<[msize; 2]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[msize; 2]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[msize; 2]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[msize; 2]>> as SimdValue>::Element )`

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

`impl SimdValue for AutoSimd<[bool; 8]>`

`type Element = bool`

`type SimdBool = AutoSimd<[bool; 8]>`

`pub fn lanes() -> usize`

`pub fn splat( val: <AutoSimd<[bool; 8]> as SimdValue>::Element ) -> AutoSimd<[bool; 8]>`

`pub fn extract(&self, i: usize) -> <AutoSimd<[bool; 8]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[bool; 8]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[bool; 8]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[bool; 8]> as SimdValue>::Element )`

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

`impl SimdValue for Simd<Simd<[f32; 4]>>`

`type Element = f32`

`type SimdBool = Simd<Simd<[m32; 4]>>`

`pub fn lanes() -> usize`

`pub fn splat( val: <Simd<Simd<[f32; 4]>> as SimdValue>::Element ) -> Simd<Simd<[f32; 4]>>`

`pub fn extract(&self, i: usize) -> <Simd<Simd<[f32; 4]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[f32; 4]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[f32; 4]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[f32; 4]>> as SimdValue>::Element )`

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

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

`type Element = f32`

`type SimdBool = AutoSimd<[bool; 2]>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <AutoSimd<[f32; 2]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[f32; 2]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[f32; 2]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[f32; 2]> as SimdValue>::Element )`

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

`impl SimdValue for Simd<Simd<[m8; 8]>>`

`type Element = bool`

`type SimdBool = Simd<Simd<[m8; 8]>>`

`pub fn lanes() -> usize`

`pub fn splat( val: <Simd<Simd<[m8; 8]>> as SimdValue>::Element ) -> Simd<Simd<[m8; 8]>>`

`pub fn extract(&self, i: usize) -> <Simd<Simd<[m8; 8]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[m8; 8]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[m8; 8]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[m8; 8]>> as SimdValue>::Element )`

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

`impl SimdValue for Simd<Simd<[m32; 2]>>`

`type Element = bool`

`type SimdBool = Simd<Simd<[m32; 2]>>`

`pub fn lanes() -> usize`

`pub fn splat( val: <Simd<Simd<[m32; 2]>> as SimdValue>::Element ) -> Simd<Simd<[m32; 2]>>`

`pub fn extract(&self, i: usize) -> <Simd<Simd<[m32; 2]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[m32; 2]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[m32; 2]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[m32; 2]>> as SimdValue>::Element )`

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

`impl SimdValue for f64`

`type Element = f64`

`type SimdBool = bool`

`pub fn lanes() -> usize`

`pub fn splat(val: <f64 as SimdValue>::Element) -> f64`

`pub fn extract(&self, usize) -> <f64 as SimdValue>::Element`

`pub unsafe fn extract_unchecked(&self, usize) -> <f64 as SimdValue>::Element`

`pub fn replace(&mut self, usize, val: <f64 as SimdValue>::Element)`

`pub unsafe fn replace_unchecked( &mut self, usize, val: <f64 as SimdValue>::Element )`

`pub fn select(self, cond: <f64 as SimdValue>::SimdBool, other: f64) -> f64`

`impl SimdValue for i32`

`type Element = i32`

`type SimdBool = bool`

`pub fn lanes() -> usize`

`pub fn splat(val: <i32 as SimdValue>::Element) -> i32`

`pub fn extract(&self, usize) -> <i32 as SimdValue>::Element`

`pub unsafe fn extract_unchecked(&self, usize) -> <i32 as SimdValue>::Element`

`pub fn replace(&mut self, usize, val: <i32 as SimdValue>::Element)`

`pub unsafe fn replace_unchecked( &mut self, usize, val: <i32 as SimdValue>::Element )`

`pub fn select(self, cond: <i32 as SimdValue>::SimdBool, other: i32) -> i32`

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

`type Element = i8`

`type SimdBool = Simd<Simd<[m8; 16]>>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <Simd<Simd<[i8; 16]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[i8; 16]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[i8; 16]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[i8; 16]>> as SimdValue>::Element )`

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

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

`type Element = u8`

`type SimdBool = Simd<Simd<[m8; 16]>>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <Simd<Simd<[u8; 16]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[u8; 16]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[u8; 16]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[u8; 16]>> as SimdValue>::Element )`

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

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

`type Element = f64`

`type SimdBool = Simd<Simd<[m64; 8]>>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <Simd<Simd<[f64; 8]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[f64; 8]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[f64; 8]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[f64; 8]>> as SimdValue>::Element )`

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

`impl SimdValue for AutoSimd<[u8; 8]>`

`type Element = u8`

`type SimdBool = AutoSimd<[bool; 8]>`

`pub fn lanes() -> usize`

`pub fn splat( val: <AutoSimd<[u8; 8]> as SimdValue>::Element ) -> AutoSimd<[u8; 8]>`

`pub fn extract(&self, i: usize) -> <AutoSimd<[u8; 8]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[u8; 8]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[u8; 8]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[u8; 8]> as SimdValue>::Element )`

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

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

`type Element = i32`

`type SimdBool = AutoSimd<[bool; 8]>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <AutoSimd<[i32; 8]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[i32; 8]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[i32; 8]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[i32; 8]> as SimdValue>::Element )`

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

`impl SimdValue for Simd<Simd<[m8; 2]>>`

`type Element = bool`

`type SimdBool = Simd<Simd<[m8; 2]>>`

`pub fn lanes() -> usize`

`pub fn splat( val: <Simd<Simd<[m8; 2]>> as SimdValue>::Element ) -> Simd<Simd<[m8; 2]>>`

`pub fn extract(&self, i: usize) -> <Simd<Simd<[m8; 2]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[m8; 2]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[m8; 2]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[m8; 2]>> as SimdValue>::Element )`

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

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

`type Element = u16`

`type SimdBool = Simd<Simd<[m16; 32]>>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <Simd<Simd<[u16; 32]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[u16; 32]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[u16; 32]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[u16; 32]>> as SimdValue>::Element )`

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

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

`type Element = i8`

`type SimdBool = AutoSimd<[bool; 16]>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <AutoSimd<[i8; 16]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[i8; 16]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[i8; 16]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[i8; 16]> as SimdValue>::Element )`

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

`impl SimdValue for AutoSimd<[u32; 8]>`

`type Element = u32`

`type SimdBool = AutoSimd<[bool; 8]>`

`pub fn lanes() -> usize`

`pub fn splat( val: <AutoSimd<[u32; 8]> as SimdValue>::Element ) -> AutoSimd<[u32; 8]>`

`pub fn extract(&self, i: usize) -> <AutoSimd<[u32; 8]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[u32; 8]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[u32; 8]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[u32; 8]> as SimdValue>::Element )`

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

`impl SimdValue for usize`

`type Element = usize`

`type SimdBool = bool`

`pub fn lanes() -> usize`

`pub fn splat(val: <usize as SimdValue>::Element) -> usize`

`pub fn extract(&self, usize) -> <usize as SimdValue>::Element`

`pub unsafe fn extract_unchecked(&self, usize) -> <usize as SimdValue>::Element`

`pub fn replace(&mut self, usize, val: <usize as SimdValue>::Element)`

`pub unsafe fn replace_unchecked( &mut self, usize, val: <usize as SimdValue>::Element )`

`pub fn select(self, cond: <usize as SimdValue>::SimdBool, other: usize) -> usize`

`impl SimdValue for Simd<Simd<[u32; 16]>>`

`type Element = u32`

`type SimdBool = Simd<Simd<[m32; 16]>>`

`pub fn lanes() -> usize`

`pub fn splat( val: <Simd<Simd<[u32; 16]>> as SimdValue>::Element ) -> Simd<Simd<[u32; 16]>>`

`pub fn extract(&self, i: usize) -> <Simd<Simd<[u32; 16]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[u32; 16]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[u32; 16]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[u32; 16]>> as SimdValue>::Element )`

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

`impl SimdValue for Simd<Simd<[m8; 32]>>`

`type Element = bool`

`type SimdBool = Simd<Simd<[m8; 32]>>`

`pub fn lanes() -> usize`

`pub fn splat( val: <Simd<Simd<[m8; 32]>> as SimdValue>::Element ) -> Simd<Simd<[m8; 32]>>`

`pub fn extract(&self, i: usize) -> <Simd<Simd<[m8; 32]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[m8; 32]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[m8; 32]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[m8; 32]>> as SimdValue>::Element )`

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

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

`type Element = i64`

`type SimdBool = AutoSimd<[bool; 4]>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <AutoSimd<[i64; 4]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[i64; 4]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[i64; 4]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[i64; 4]> as SimdValue>::Element )`

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

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

`type Element = i128`

`type SimdBool = Simd<Simd<[m128; 2]>>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <Simd<Simd<[i128; 2]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[i128; 2]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[i128; 2]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[i128; 2]>> as SimdValue>::Element )`

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

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

`type Element = u128`

`type SimdBool = Simd<Simd<[m128; 2]>>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <Simd<Simd<[u128; 2]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[u128; 2]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[u128; 2]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[u128; 2]>> as SimdValue>::Element )`

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

`impl SimdValue for AutoSimd<[bool; 1]>`

`type Element = bool`

`type SimdBool = AutoSimd<[bool; 1]>`

`pub fn lanes() -> usize`

`pub fn splat( val: <AutoSimd<[bool; 1]> as SimdValue>::Element ) -> AutoSimd<[bool; 1]>`

`pub fn extract(&self, i: usize) -> <AutoSimd<[bool; 1]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[bool; 1]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[bool; 1]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[bool; 1]> as SimdValue>::Element )`

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

`impl SimdValue for u8`

`type Element = u8`

`type SimdBool = bool`

`pub fn lanes() -> usize`

`pub fn splat(val: <u8 as SimdValue>::Element) -> u8`

`pub fn extract(&self, usize) -> <u8 as SimdValue>::Element`

`pub unsafe fn extract_unchecked(&self, usize) -> <u8 as SimdValue>::Element`

`pub fn replace(&mut self, usize, val: <u8 as SimdValue>::Element)`

`pub unsafe fn replace_unchecked( &mut self, usize, val: <u8 as SimdValue>::Element )`

`pub fn select(self, cond: <u8 as SimdValue>::SimdBool, other: u8) -> u8`

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

`type Element = f64`

`type SimdBool = AutoSimd<[bool; 4]>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <AutoSimd<[f64; 4]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[f64; 4]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[f64; 4]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[f64; 4]> as SimdValue>::Element )`

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

`impl SimdValue for Simd<Simd<[u8; 64]>>`

`type Element = u8`

`type SimdBool = Simd<Simd<[m8; 64]>>`

`pub fn lanes() -> usize`

`pub fn splat( val: <Simd<Simd<[u8; 64]>> as SimdValue>::Element ) -> Simd<Simd<[u8; 64]>>`

`pub fn extract(&self, i: usize) -> <Simd<Simd<[u8; 64]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[u8; 64]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[u8; 64]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[u8; 64]>> as SimdValue>::Element )`

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

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

`type Element = i16`

`type SimdBool = AutoSimd<[bool; 8]>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <AutoSimd<[i16; 8]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[i16; 8]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[i16; 8]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[i16; 8]> as SimdValue>::Element )`

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

`impl SimdValue for Simd<Simd<[m16; 16]>>`

`type Element = bool`

`type SimdBool = Simd<Simd<[m16; 16]>>`

`pub fn lanes() -> usize`

`pub fn splat( val: <Simd<Simd<[m16; 16]>> as SimdValue>::Element ) -> Simd<Simd<[m16; 16]>>`

`pub fn extract(&self, i: usize) -> <Simd<Simd<[m16; 16]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[m16; 16]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[m16; 16]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[m16; 16]>> as SimdValue>::Element )`

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

`impl SimdValue for Simd<Simd<[m8; 4]>>`

`type Element = bool`

`type SimdBool = Simd<Simd<[m8; 4]>>`

`pub fn lanes() -> usize`

`pub fn splat( val: <Simd<Simd<[m8; 4]>> as SimdValue>::Element ) -> Simd<Simd<[m8; 4]>>`

`pub fn extract(&self, i: usize) -> <Simd<Simd<[m8; 4]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[m8; 4]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[m8; 4]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[m8; 4]>> as SimdValue>::Element )`

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

`impl SimdValue for u32`

`type Element = u32`

`type SimdBool = bool`

`pub fn lanes() -> usize`

`pub fn splat(val: <u32 as SimdValue>::Element) -> u32`

`pub fn extract(&self, usize) -> <u32 as SimdValue>::Element`

`pub unsafe fn extract_unchecked(&self, usize) -> <u32 as SimdValue>::Element`

`pub fn replace(&mut self, usize, val: <u32 as SimdValue>::Element)`

`pub unsafe fn replace_unchecked( &mut self, usize, val: <u32 as SimdValue>::Element )`

`pub fn select(self, cond: <u32 as SimdValue>::SimdBool, other: u32) -> u32`

`impl SimdValue for Simd<Simd<[m64; 8]>>`

`type Element = bool`

`type SimdBool = Simd<Simd<[m64; 8]>>`

`pub fn lanes() -> usize`

`pub fn splat( val: <Simd<Simd<[m64; 8]>> as SimdValue>::Element ) -> Simd<Simd<[m64; 8]>>`

`pub fn extract(&self, i: usize) -> <Simd<Simd<[m64; 8]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[m64; 8]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[m64; 8]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[m64; 8]>> as SimdValue>::Element )`

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

`impl SimdValue for Simd<Simd<[f32; 8]>>`

`type Element = f32`

`type SimdBool = Simd<Simd<[m32; 8]>>`

`pub fn lanes() -> usize`

`pub fn splat( val: <Simd<Simd<[f32; 8]>> as SimdValue>::Element ) -> Simd<Simd<[f32; 8]>>`

`pub fn extract(&self, i: usize) -> <Simd<Simd<[f32; 8]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[f32; 8]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[f32; 8]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[f32; 8]>> as SimdValue>::Element )`

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

`impl SimdValue for AutoSimd<[i64; 8]>`

`type Element = i64`

`type SimdBool = AutoSimd<[bool; 8]>`

`pub fn lanes() -> usize`

`pub fn splat( val: <AutoSimd<[i64; 8]> as SimdValue>::Element ) -> AutoSimd<[i64; 8]>`

`pub fn extract(&self, i: usize) -> <AutoSimd<[i64; 8]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[i64; 8]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[i64; 8]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[i64; 8]> as SimdValue>::Element )`

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

`impl SimdValue for Simd<Simd<[m16; 32]>>`

`type Element = bool`

`type SimdBool = Simd<Simd<[m16; 32]>>`

`pub fn lanes() -> usize`

`pub fn splat( val: <Simd<Simd<[m16; 32]>> as SimdValue>::Element ) -> Simd<Simd<[m16; 32]>>`

`pub fn extract(&self, i: usize) -> <Simd<Simd<[m16; 32]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[m16; 32]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[m16; 32]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[m16; 32]>> as SimdValue>::Element )`

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

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

`type Element = i32`

`type SimdBool = AutoSimd<[bool; 16]>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <AutoSimd<[i32; 16]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[i32; 16]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[i32; 16]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[i32; 16]> as SimdValue>::Element )`

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

`impl SimdValue for Simd<Simd<[i8; 8]>>`

`type Element = i8`

`type SimdBool = Simd<Simd<[m8; 8]>>`

`pub fn lanes() -> usize`

`pub fn splat( val: <Simd<Simd<[i8; 8]>> as SimdValue>::Element ) -> Simd<Simd<[i8; 8]>>`

`pub fn extract(&self, i: usize) -> <Simd<Simd<[i8; 8]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[i8; 8]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[i8; 8]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[i8; 8]>> as SimdValue>::Element )`

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

`impl SimdValue for AutoSimd<[u16; 4]>`

`type Element = u16`

`type SimdBool = AutoSimd<[bool; 4]>`

`pub fn lanes() -> usize`

`pub fn splat( val: <AutoSimd<[u16; 4]> as SimdValue>::Element ) -> AutoSimd<[u16; 4]>`

`pub fn extract(&self, i: usize) -> <AutoSimd<[u16; 4]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[u16; 4]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[u16; 4]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[u16; 4]> as SimdValue>::Element )`

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

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

`type Element = i32`

`type SimdBool = Simd<Simd<[m32; 4]>>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <Simd<Simd<[i32; 4]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[i32; 4]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[i32; 4]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[i32; 4]>> as SimdValue>::Element )`

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

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

`type Element = i8`

`type SimdBool = Simd<Simd<[m8; 32]>>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <Simd<Simd<[i8; 32]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[i8; 32]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[i8; 32]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[i8; 32]>> as SimdValue>::Element )`

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

`impl SimdValue for AutoSimd<[usize; 2]>`

`type Element = usize`

`type SimdBool = AutoSimd<[bool; 2]>`

`pub fn lanes() -> usize`

`pub fn splat( val: <AutoSimd<[usize; 2]> as SimdValue>::Element ) -> AutoSimd<[usize; 2]>`

`pub fn extract(&self, i: usize) -> <AutoSimd<[usize; 2]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[usize; 2]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[usize; 2]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[usize; 2]> as SimdValue>::Element )`

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

`impl SimdValue for Simd<Simd<[u16; 2]>>`

`type Element = u16`

`type SimdBool = Simd<Simd<[m16; 2]>>`

`pub fn lanes() -> usize`

`pub fn splat( val: <Simd<Simd<[u16; 2]>> as SimdValue>::Element ) -> Simd<Simd<[u16; 2]>>`

`pub fn extract(&self, i: usize) -> <Simd<Simd<[u16; 2]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[u16; 2]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[u16; 2]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[u16; 2]>> as SimdValue>::Element )`

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

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

`type Element = usize`

`type SimdBool = Simd<Simd<[msize; 2]>>`

`pub fn lanes() -> usize`

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

`pub fn extract( &self, i: usize ) -> <Simd<Simd<[usize; 2]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[usize; 2]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[usize; 2]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[usize; 2]>> as SimdValue>::Element )`

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

`impl SimdValue for Simd<Simd<[u64; 8]>>`

`type Element = u64`

`type SimdBool = Simd<Simd<[m64; 8]>>`

`pub fn lanes() -> usize`

`pub fn splat( val: <Simd<Simd<[u64; 8]>> as SimdValue>::Element ) -> Simd<Simd<[u64; 8]>>`

`pub fn extract(&self, i: usize) -> <Simd<Simd<[u64; 8]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[u64; 8]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[u64; 8]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[u64; 8]>> as SimdValue>::Element )`

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

`impl SimdValue for f32`

`type Element = f32`

`type SimdBool = bool`

`pub fn lanes() -> usize`

`pub fn splat(val: <f32 as SimdValue>::Element) -> f32`

`pub fn extract(&self, usize) -> <f32 as SimdValue>::Element`

`pub unsafe fn extract_unchecked(&self, usize) -> <f32 as SimdValue>::Element`

`pub fn replace(&mut self, usize, val: <f32 as SimdValue>::Element)`

`pub unsafe fn replace_unchecked( &mut self, usize, val: <f32 as SimdValue>::Element )`

`pub fn select(self, cond: <f32 as SimdValue>::SimdBool, other: f32) -> f32`

`impl SimdValue for AutoSimd<[bool; 4]>`

`type Element = bool`

`type SimdBool = AutoSimd<[bool; 4]>`

`pub fn lanes() -> usize`

`pub fn splat( val: <AutoSimd<[bool; 4]> as SimdValue>::Element ) -> AutoSimd<[bool; 4]>`

`pub fn extract(&self, i: usize) -> <AutoSimd<[bool; 4]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[bool; 4]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[bool; 4]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[bool; 4]> as SimdValue>::Element )`

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

`impl SimdValue for AutoSimd<[i8; 2]>`

`type Element = i8`

`type SimdBool = AutoSimd<[bool; 2]>`

`pub fn lanes() -> usize`

`pub fn splat( val: <AutoSimd<[i8; 2]> as SimdValue>::Element ) -> AutoSimd<[i8; 2]>`

`pub fn extract(&self, i: usize) -> <AutoSimd<[i8; 2]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[i8; 2]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[i8; 2]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[i8; 2]> as SimdValue>::Element )`

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

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

`type Element = u16`

`type SimdBool = Simd<Simd<[m16; 16]>>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <Simd<Simd<[u16; 16]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[u16; 16]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[u16; 16]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[u16; 16]>> as SimdValue>::Element )`

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

`impl SimdValue for AutoSimd<[bool; 16]>`

`type Element = bool`

`type SimdBool = AutoSimd<[bool; 16]>`

`pub fn lanes() -> usize`

`pub fn splat( val: <AutoSimd<[bool; 16]> as SimdValue>::Element ) -> AutoSimd<[bool; 16]>`

`pub fn extract(&self, i: usize) -> <AutoSimd<[bool; 16]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[bool; 16]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[bool; 16]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[bool; 16]> as SimdValue>::Element )`

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

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

`type Element = f64`

`type SimdBool = AutoSimd<[bool; 2]>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <AutoSimd<[f64; 2]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[f64; 2]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[f64; 2]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[f64; 2]> as SimdValue>::Element )`

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

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

`type Element = i64`

`type SimdBool = Simd<Simd<[m64; 8]>>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <Simd<Simd<[i64; 8]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[i64; 8]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[i64; 8]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[i64; 8]>> as SimdValue>::Element )`

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

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

`type Element = isize`

`type SimdBool = AutoSimd<[bool; 8]>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <AutoSimd<[isize; 8]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[isize; 8]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[isize; 8]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[isize; 8]> as SimdValue>::Element )`

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

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

`type Element = u16`

`type SimdBool = AutoSimd<[bool; 16]>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <AutoSimd<[u16; 16]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[u16; 16]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[u16; 16]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[u16; 16]> as SimdValue>::Element )`

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

`impl SimdValue for AutoSimd<[usize; 8]>`

`type Element = usize`

`type SimdBool = AutoSimd<[bool; 8]>`

`pub fn lanes() -> usize`

`pub fn splat( val: <AutoSimd<[usize; 8]> as SimdValue>::Element ) -> AutoSimd<[usize; 8]>`

`pub fn extract(&self, i: usize) -> <AutoSimd<[usize; 8]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[usize; 8]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[usize; 8]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[usize; 8]> as SimdValue>::Element )`

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

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

`type Element = usize`

`type SimdBool = Simd<Simd<[msize; 8]>>`

`pub fn lanes() -> usize`

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

`pub fn extract( &self, i: usize ) -> <Simd<Simd<[usize; 8]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[usize; 8]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[usize; 8]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[usize; 8]>> as SimdValue>::Element )`

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

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

`type Element = isize`

`type SimdBool = AutoSimd<[bool; 2]>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <AutoSimd<[isize; 2]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[isize; 2]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[isize; 2]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[isize; 2]> as SimdValue>::Element )`

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

`impl SimdValue for Simd<Simd<[m128; 1]>>`

`type Element = bool`

`type SimdBool = Simd<Simd<[m128; 1]>>`

`pub fn lanes() -> usize`

`pub fn splat( val: <Simd<Simd<[m128; 1]>> as SimdValue>::Element ) -> Simd<Simd<[m128; 1]>>`

`pub fn extract(&self, i: usize) -> <Simd<Simd<[m128; 1]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[m128; 1]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[m128; 1]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[m128; 1]>> as SimdValue>::Element )`

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

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

`type Element = f32`

`type SimdBool = AutoSimd<[bool; 4]>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <AutoSimd<[f32; 4]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[f32; 4]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[f32; 4]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[f32; 4]> as SimdValue>::Element )`

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

`impl SimdValue for AutoSimd<[u8; 2]>`

`type Element = u8`

`type SimdBool = AutoSimd<[bool; 2]>`

`pub fn lanes() -> usize`

`pub fn splat( val: <AutoSimd<[u8; 2]> as SimdValue>::Element ) -> AutoSimd<[u8; 2]>`

`pub fn extract(&self, i: usize) -> <AutoSimd<[u8; 2]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[u8; 2]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[u8; 2]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[u8; 2]> as SimdValue>::Element )`

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

`impl SimdValue for AutoSimd<[usize; 4]>`

`type Element = usize`

`type SimdBool = AutoSimd<[bool; 4]>`

`pub fn lanes() -> usize`

`pub fn splat( val: <AutoSimd<[usize; 4]> as SimdValue>::Element ) -> AutoSimd<[usize; 4]>`

`pub fn extract(&self, i: usize) -> <AutoSimd<[usize; 4]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[usize; 4]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[usize; 4]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[usize; 4]> as SimdValue>::Element )`

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

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

`type Element = i8`

`type SimdBool = Simd<Simd<[m8; 2]>>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <Simd<Simd<[i8; 2]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[i8; 2]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[i8; 2]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[i8; 2]>> as SimdValue>::Element )`

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

`impl SimdValue for Simd<Simd<[m128; 4]>>`

`type Element = bool`

`type SimdBool = Simd<Simd<[m128; 4]>>`

`pub fn lanes() -> usize`

`pub fn splat( val: <Simd<Simd<[m128; 4]>> as SimdValue>::Element ) -> Simd<Simd<[m128; 4]>>`

`pub fn extract(&self, i: usize) -> <Simd<Simd<[m128; 4]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[m128; 4]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[m128; 4]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[m128; 4]>> as SimdValue>::Element )`

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

`impl SimdValue for Simd<Simd<[i32; 8]>>`

`type Element = i32`

`type SimdBool = Simd<Simd<[m32; 8]>>`

`pub fn lanes() -> usize`

`pub fn splat( val: <Simd<Simd<[i32; 8]>> as SimdValue>::Element ) -> Simd<Simd<[i32; 8]>>`

`pub fn extract(&self, i: usize) -> <Simd<Simd<[i32; 8]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[i32; 8]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[i32; 8]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[i32; 8]>> as SimdValue>::Element )`

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

`impl SimdValue for Simd<Simd<[m32; 16]>>`

`type Element = bool`

`type SimdBool = Simd<Simd<[m32; 16]>>`

`pub fn lanes() -> usize`

`pub fn splat( val: <Simd<Simd<[m32; 16]>> as SimdValue>::Element ) -> Simd<Simd<[m32; 16]>>`

`pub fn extract(&self, i: usize) -> <Simd<Simd<[m32; 16]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[m32; 16]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[m32; 16]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[m32; 16]>> as SimdValue>::Element )`

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

`impl SimdValue for Simd<Simd<[m32; 4]>>`

`type Element = bool`

`type SimdBool = Simd<Simd<[m32; 4]>>`

`pub fn lanes() -> usize`

`pub fn splat( val: <Simd<Simd<[m32; 4]>> as SimdValue>::Element ) -> Simd<Simd<[m32; 4]>>`

`pub fn extract(&self, i: usize) -> <Simd<Simd<[m32; 4]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[m32; 4]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[m32; 4]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[m32; 4]>> as SimdValue>::Element )`

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

`impl SimdValue for AutoSimd<[i8; 8]>`

`type Element = i8`

`type SimdBool = AutoSimd<[bool; 8]>`

`pub fn lanes() -> usize`

`pub fn splat( val: <AutoSimd<[i8; 8]> as SimdValue>::Element ) -> AutoSimd<[i8; 8]>`

`pub fn extract(&self, i: usize) -> <AutoSimd<[i8; 8]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[i8; 8]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[i8; 8]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[i8; 8]> as SimdValue>::Element )`

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

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

`type Element = i16`

`type SimdBool = Simd<Simd<[m16; 16]>>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <Simd<Simd<[i16; 16]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[i16; 16]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[i16; 16]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[i16; 16]>> as SimdValue>::Element )`

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

Loading content...

Implementors

`impl<N> SimdValue for Complex<N> where N: SimdValue,`

`type Element = Complex<<N as SimdValue>::Element>`

`type SimdBool = <N as SimdValue>::SimdBool`

`pub fn lanes() -> usize`

`pub fn splat(val: <Complex<N> as SimdValue>::Element) -> Complex<N>`

`pub fn extract(&self, i: usize) -> <Complex<N> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Complex<N> as SimdValue>::Element`

`pub fn replace(&mut self, i: usize, val: <Complex<N> as SimdValue>::Element)`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Complex<N> as SimdValue>::Element )`

`pub fn select( self, cond: <Complex<N> as SimdValue>::SimdBool, other: Complex<N> ) -> Complex<N>`

`impl<T> SimdValue for Quaternion<T> where T: Scalar + SimdValue, <T as SimdValue>::Element: Scalar,` [src]

`type Element = Quaternion<<T as SimdValue>::Element>`

`type SimdBool = <T as SimdValue>::SimdBool`

`pub fn lanes() -> usize`[src]

`pub fn splat(val: <Quaternion<T> as SimdValue>::Element) -> Quaternion<T>`[src]

`pub fn extract(&self, i: usize) -> <Quaternion<T> as SimdValue>::Element`[src]

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Quaternion<T> as SimdValue>::Element`[src]

`pub fn replace(&mut self, i: usize, val: <Quaternion<T> as SimdValue>::Element)`[src]

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Quaternion<T> as SimdValue>::Element )`[src]

`pub fn select( self, cond: <Quaternion<T> as SimdValue>::SimdBool, other: Quaternion<T> ) -> Quaternion<T>`[src]

`impl<T> SimdValue for Unit<Complex<T>> where T: SimdRealField, <T as SimdValue>::Element: SimdRealField,` [src]

`type Element = Unit<Complex<<T as SimdValue>::Element>>`

`type SimdBool = <T as SimdValue>::SimdBool`

`pub fn lanes() -> usize`[src]

`pub fn splat(val: <Unit<Complex<T>> as SimdValue>::Element) -> Unit<Complex<T>>`[src]

`pub fn extract(&self, i: usize) -> <Unit<Complex<T>> as SimdValue>::Element`[src]

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Unit<Complex<T>> as SimdValue>::Element`[src]

`pub fn replace( &mut self, i: usize, val: <Unit<Complex<T>> as SimdValue>::Element )`[src]

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Unit<Complex<T>> as SimdValue>::Element )`[src]

`pub fn select( self, cond: <Unit<Complex<T>> as SimdValue>::SimdBool, other: Unit<Complex<T>> ) -> Unit<Complex<T>>`[src]

`impl<T> SimdValue for Unit<Quaternion<T>> where T: Scalar + SimdValue, <T as SimdValue>::Element: Scalar,` [src]

`type Element = Unit<Quaternion<<T as SimdValue>::Element>>`

`type SimdBool = <T as SimdValue>::SimdBool`

`pub fn lanes() -> usize`[src]

`pub fn splat( val: <Unit<Quaternion<T>> as SimdValue>::Element ) -> Unit<Quaternion<T>>`[src]

`pub fn extract(&self, i: usize) -> <Unit<Quaternion<T>> as SimdValue>::Element`[src]

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Unit<Quaternion<T>> as SimdValue>::Element`[src]

`pub fn replace( &mut self, i: usize, val: <Unit<Quaternion<T>> as SimdValue>::Element )`[src]

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Unit<Quaternion<T>> as SimdValue>::Element )`[src]

`pub fn select( self, cond: <Unit<Quaternion<T>> as SimdValue>::SimdBool, other: Unit<Quaternion<T>> ) -> Unit<Quaternion<T>>`[src]

impl<T, C, const D: usize> SimdValue for Transform<T, C, D> where C: TCategory, T: RealField, <T as SimdValue>::Element: Scalar, Const<D>: DimNameAdd<Const<1_usize>>, DefaultAllocator: Allocator<T, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>, DefaultAllocator: Allocator<<T as SimdValue>::Element, <Const<D> as DimNameAdd<Const<1_usize>>>::Output, <Const<D> as DimNameAdd<Const<1_usize>>>::Output>, [src]

`type Element = Transform<<T as SimdValue>::Element, C, D>`

`type SimdBool = <T as SimdValue>::SimdBool`

`pub fn lanes() -> usize`[src]

`pub fn splat( val: <Transform<T, C, D> as SimdValue>::Element ) -> Transform<T, C, D>`[src]

`pub fn extract(&self, i: usize) -> <Transform<T, C, D> as SimdValue>::Element`[src]

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Transform<T, C, D> as SimdValue>::Element`[src]

`pub fn replace( &mut self, i: usize, val: <Transform<T, C, D> as SimdValue>::Element )`[src]

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Transform<T, C, D> as SimdValue>::Element )`[src]

`pub fn select( self, cond: <Transform<T, C, D> as SimdValue>::SimdBool, other: Transform<T, C, D> ) -> Transform<T, C, D>`[src]

`impl<T, R, C> SimdValue for Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> where C: Dim, T: Scalar + SimdValue, R: Dim, <T as SimdValue>::Element: Scalar, DefaultAllocator: Allocator<T, R, C>, DefaultAllocator: Allocator<<T as SimdValue>::Element, R, C>,` [src]

`type Element = Matrix<<T as SimdValue>::Element, R, C, <DefaultAllocator as Allocator<<T as SimdValue>::Element, R, C>>::Buffer>`

`type SimdBool = <T as SimdValue>::SimdBool`

`pub fn lanes() -> usize`[src]

`pub fn splat( val: <Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> as SimdValue>::Element ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer>`[src]

`pub fn extract( &self, i: usize ) -> <Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> as SimdValue>::Element`[src]

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> as SimdValue>::Element`[src]

`pub fn replace( &mut self, i: usize, val: <Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> as SimdValue>::Element )`[src]

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> as SimdValue>::Element )`[src]

`pub fn select( self, cond: <Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> as SimdValue>::SimdBool, other: Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer> ) -> Matrix<T, R, C, <DefaultAllocator as Allocator<T, R, C>>::Buffer>`[src]

`impl<T, R, const D: usize> SimdValue for Isometry<T, R, D> where T: SimdRealField, R: SimdValue<SimdBool = <T as SimdValue>::SimdBool> + AbstractRotation<T, D>, <T as SimdValue>::Element: SimdRealField, <R as SimdValue>::Element: AbstractRotation<<T as SimdValue>::Element, D>,` [src]

`type Element = Isometry<<T as SimdValue>::Element, <R as SimdValue>::Element, D>`

`type SimdBool = <T as SimdValue>::SimdBool`

`pub fn lanes() -> usize`[src]

`pub fn splat( val: <Isometry<T, R, D> as SimdValue>::Element ) -> Isometry<T, R, D>`[src]

`pub fn extract(&self, i: usize) -> <Isometry<T, R, D> as SimdValue>::Element`[src]

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Isometry<T, R, D> as SimdValue>::Element`[src]

`pub fn replace( &mut self, i: usize, val: <Isometry<T, R, D> as SimdValue>::Element )`[src]

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Isometry<T, R, D> as SimdValue>::Element )`[src]

`pub fn select( self, cond: <Isometry<T, R, D> as SimdValue>::SimdBool, other: Isometry<T, R, D> ) -> Isometry<T, R, D>`[src]

`impl<T, R, const D: usize> SimdValue for Similarity<T, R, D> where T: SimdRealField, R: SimdValue<SimdBool = <T as SimdValue>::SimdBool> + AbstractRotation<T, D>, <T as SimdValue>::Element: SimdRealField, <R as SimdValue>::Element: AbstractRotation<<T as SimdValue>::Element, D>,` [src]

`type Element = Similarity<<T as SimdValue>::Element, <R as SimdValue>::Element, D>`

`type SimdBool = <T as SimdValue>::SimdBool`

`pub fn lanes() -> usize`[src]

`pub fn splat( val: <Similarity<T, R, D> as SimdValue>::Element ) -> Similarity<T, R, D>`[src]

`pub fn extract(&self, i: usize) -> <Similarity<T, R, D> as SimdValue>::Element`[src]

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Similarity<T, R, D> as SimdValue>::Element`[src]

`pub fn replace( &mut self, i: usize, val: <Similarity<T, R, D> as SimdValue>::Element )`[src]

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Similarity<T, R, D> as SimdValue>::Element )`[src]

`pub fn select( self, cond: <Similarity<T, R, D> as SimdValue>::SimdBool, other: Similarity<T, R, D> ) -> Similarity<T, R, D>`[src]

`impl<T, const D: usize> SimdValue for Point<T, D> where T: Scalar + SimdValue, <T as SimdValue>::Element: Scalar,` [src]

`type Element = Point<<T as SimdValue>::Element, D>`

`type SimdBool = <T as SimdValue>::SimdBool`

`pub fn lanes() -> usize`[src]

`pub fn splat(val: <Point<T, D> as SimdValue>::Element) -> Point<T, D>`[src]

`pub fn extract(&self, i: usize) -> <Point<T, D> as SimdValue>::Element`[src]

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Point<T, D> as SimdValue>::Element`[src]

`pub fn replace(&mut self, i: usize, val: <Point<T, D> as SimdValue>::Element)`[src]

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Point<T, D> as SimdValue>::Element )`[src]

`pub fn select( self, cond: <Point<T, D> as SimdValue>::SimdBool, other: Point<T, D> ) -> Point<T, D>`[src]

`impl<T, const D: usize> SimdValue for Rotation<T, D> where T: Scalar + SimdValue, <T as SimdValue>::Element: Scalar,` [src]

`type Element = Rotation<<T as SimdValue>::Element, D>`

`type SimdBool = <T as SimdValue>::SimdBool`

`pub fn lanes() -> usize`[src]

`pub fn splat(val: <Rotation<T, D> as SimdValue>::Element) -> Rotation<T, D>`[src]

`pub fn extract(&self, i: usize) -> <Rotation<T, D> as SimdValue>::Element`[src]

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Rotation<T, D> as SimdValue>::Element`[src]

`pub fn replace(&mut self, i: usize, val: <Rotation<T, D> as SimdValue>::Element)`[src]

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Rotation<T, D> as SimdValue>::Element )`[src]

`pub fn select( self, cond: <Rotation<T, D> as SimdValue>::SimdBool, other: Rotation<T, D> ) -> Rotation<T, D>`[src]

`impl<T, const D: usize> SimdValue for Translation<T, D> where T: Scalar + SimdValue, <T as SimdValue>::Element: Scalar,` [src]

`type Element = Translation<<T as SimdValue>::Element, D>`

`type SimdBool = <T as SimdValue>::SimdBool`

`pub fn lanes() -> usize`[src]

`pub fn splat( val: <Translation<T, D> as SimdValue>::Element ) -> Translation<T, D>`[src]

`pub fn extract(&self, i: usize) -> <Translation<T, D> as SimdValue>::Element`[src]

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Translation<T, D> as SimdValue>::Element`[src]

`pub fn replace( &mut self, i: usize, val: <Translation<T, D> as SimdValue>::Element )`[src]

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Translation<T, D> as SimdValue>::Element )`[src]

`pub fn select( self, cond: <Translation<T, D> as SimdValue>::SimdBool, other: Translation<T, D> ) -> Translation<T, D>`[src]

Loading content...

Trait lnkit::prelude::SimdValue⎘[−]

Associated Types

type Element: SimdValue

type SimdBool: SimdBool

Required methods

pub fn lanes() -> usize

pub fn splat(val: Self::Element) -> Self

pub fn extract(&self, i: usize) -> Self::Element

pub unsafe fn extract_unchecked(&self, i: usize) -> Self::Element

pub fn replace(&mut self, i: usize, val: Self::Element)

pub unsafe fn replace_unchecked(&mut self, i: usize, val: Self::Element)

pub fn select(self, cond: Self::SimdBool, other: Self) -> Self

Provided methods

pub fn map_lanes(self, f: impl Fn(Self::Element) -> Self::Element) -> Self where Self: Clone,

pub fn zip_map_lanes( self, b: Self, f: impl Fn(Self::Element, Self::Element) -> Self::Element) -> Self where Self: Clone,

Implementations on Foreign Types

impl SimdValue for Simd<Simd<[m64; 2]>>

type Element = bool

type SimdBool = Simd<Simd<[m64; 2]>>

pub fn lanes() -> usize

pub fn splat( val: <Simd<Simd<[m64; 2]>> as SimdValue>::Element) -> Simd<Simd<[m64; 2]>>

pub fn extract(&self, i: usize) -> <Simd<Simd<[m64; 2]>> as SimdValue>::Element

pub unsafe fn extract_unchecked( &self, i: usize) -> <Simd<Simd<[m64; 2]>> as SimdValue>::Element

pub fn replace( &mut self, i: usize, val: <Simd<Simd<[m64; 2]>> as SimdValue>::Element)

pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[m64; 2]>> as SimdValue>::Element)

pub fn select( self, cond: <Simd<Simd<[m64; 2]>> as SimdValue>::SimdBool, other: Simd<Simd<[m64; 2]>>) -> Simd<Simd<[m64; 2]>>

impl SimdValue for AutoSimd<[u16; 8]>

type Element = u16

type SimdBool = AutoSimd<[bool; 8]>

pub fn lanes() -> usize

pub fn splat( val: <AutoSimd<[u16; 8]> as SimdValue>::Element) -> AutoSimd<[u16; 8]>

pub fn extract(&self, i: usize) -> <AutoSimd<[u16; 8]> as SimdValue>::Element

pub unsafe fn extract_unchecked( &self, i: usize) -> <AutoSimd<[u16; 8]> as SimdValue>::Element

pub fn replace( &mut self, i: usize, val: <AutoSimd<[u16; 8]> as SimdValue>::Element)

pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[u16; 8]> as SimdValue>::Element)

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

impl SimdValue for Simd<Simd<[m8; 64]>>

type Element = bool

type SimdBool = Simd<Simd<[m8; 64]>>

pub fn lanes() -> usize

pub fn splat( val: <Simd<Simd<[m8; 64]>> as SimdValue>::Element) -> Simd<Simd<[m8; 64]>>

pub fn extract(&self, i: usize) -> <Simd<Simd<[m8; 64]>> as SimdValue>::Element

pub unsafe fn extract_unchecked( &self, i: usize) -> <Simd<Simd<[m8; 64]>> as SimdValue>::Element

pub fn replace( &mut self, i: usize, val: <Simd<Simd<[m8; 64]>> as SimdValue>::Element)

pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[m8; 64]>> as SimdValue>::Element)

pub fn select( self, cond: <Simd<Simd<[m8; 64]>> as SimdValue>::SimdBool, other: Simd<Simd<[m8; 64]>>) -> Simd<Simd<[m8; 64]>>

impl SimdValue for Simd<Simd<[isize; 2]>>

type Element = isize

type SimdBool = Simd<Simd<[msize; 2]>>

pub fn lanes() -> usize

pub fn splat( val: <Simd<Simd<[isize; 2]>> as SimdValue>::Element) -> Simd<Simd<[isize; 2]>>

pub fn extract( &self, i: usize) -> <Simd<Simd<[isize; 2]>> as SimdValue>::Element

pub unsafe fn extract_unchecked( &self, i: usize) -> <Simd<Simd<[isize; 2]>> as SimdValue>::Element

pub fn replace( &mut self, i: usize, val: <Simd<Simd<[isize; 2]>> as SimdValue>::Element)

pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[isize; 2]>> as SimdValue>::Element)

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

impl SimdValue for u128

type Element = u128

type SimdBool = bool

pub fn lanes() -> usize

pub fn splat(val: <u128 as SimdValue>::Element) -> u128

pub fn extract(&self, usize) -> <u128 as SimdValue>::Element

pub unsafe fn extract_unchecked(&self, usize) -> <u128 as SimdValue>::Element

pub fn replace(&mut self, usize, val: <u128 as SimdValue>::Element)

pub unsafe fn replace_unchecked( &mut self, usize, val: <u128 as SimdValue>::Element)

pub fn select(self, cond: <u128 as SimdValue>::SimdBool, other: u128) -> u128

impl SimdValue for AutoSimd<[i16; 16]>

type Element = i16

type SimdBool = AutoSimd<[bool; 16]>

pub fn lanes() -> usize

pub fn splat( val: <AutoSimd<[i16; 16]> as SimdValue>::Element) -> AutoSimd<[i16; 16]>

pub fn extract(&self, i: usize) -> <AutoSimd<[i16; 16]> as SimdValue>::Element

pub unsafe fn extract_unchecked( &self, i: usize) -> <AutoSimd<[i16; 16]> as SimdValue>::Element

pub fn replace( &mut self, i: usize, val: <AutoSimd<[i16; 16]> as SimdValue>::Element)

pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[i16; 16]> as SimdValue>::Element)

pub fn select( self, cond: <AutoSimd<[i16; 16]> as SimdValue>::SimdBool, other: AutoSimd<[i16; 16]>) -> AutoSimd<[i16; 16]>

impl SimdValue for i8

type Element = i8

type SimdBool = bool

pub fn lanes() -> usize

Trait lnkit::prelude::SimdValue[−]

`type Element: SimdValue`

`type SimdBool: SimdBool`

`pub fn lanes() -> usize`

`pub fn splat(val: Self::Element) -> Self`

`pub fn extract(&self, i: usize) -> Self::Element`

`pub unsafe fn extract_unchecked(&self, i: usize) -> Self::Element`

`pub fn replace(&mut self, i: usize, val: Self::Element)`

`pub unsafe fn replace_unchecked(&mut self, i: usize, val: Self::Element)`

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

`pub fn map_lanes(self, f: impl Fn(Self::Element) -> Self::Element) -> Self where Self: Clone,`

`pub fn zip_map_lanes( self, b: Self, f: impl Fn(Self::Element, Self::Element) -> Self::Element ) -> Self where Self: Clone,`

`impl SimdValue for Simd<Simd<[m64; 2]>>`

`type Element = bool`

`type SimdBool = Simd<Simd<[m64; 2]>>`

`pub fn lanes() -> usize`

`pub fn splat( val: <Simd<Simd<[m64; 2]>> as SimdValue>::Element ) -> Simd<Simd<[m64; 2]>>`

`pub fn extract(&self, i: usize) -> <Simd<Simd<[m64; 2]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[m64; 2]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[m64; 2]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[m64; 2]>> as SimdValue>::Element )`

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

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

`type Element = u16`

`type SimdBool = AutoSimd<[bool; 8]>`

`pub fn lanes() -> usize`

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

`pub fn extract(&self, i: usize) -> <AutoSimd<[u16; 8]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[u16; 8]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[u16; 8]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[u16; 8]> as SimdValue>::Element )`

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

`impl SimdValue for Simd<Simd<[m8; 64]>>`

`type Element = bool`

`type SimdBool = Simd<Simd<[m8; 64]>>`

`pub fn lanes() -> usize`

`pub fn splat( val: <Simd<Simd<[m8; 64]>> as SimdValue>::Element ) -> Simd<Simd<[m8; 64]>>`

`pub fn extract(&self, i: usize) -> <Simd<Simd<[m8; 64]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[m8; 64]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[m8; 64]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[m8; 64]>> as SimdValue>::Element )`

`pub fn select( self, cond: <Simd<Simd<[m8; 64]>> as SimdValue>::SimdBool, other: Simd<Simd<[m8; 64]>> ) -> Simd<Simd<[m8; 64]>>`

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

`type Element = isize`

`type SimdBool = Simd<Simd<[msize; 2]>>`

`pub fn lanes() -> usize`

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

`pub fn extract( &self, i: usize ) -> <Simd<Simd<[isize; 2]>> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <Simd<Simd<[isize; 2]>> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <Simd<Simd<[isize; 2]>> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <Simd<Simd<[isize; 2]>> as SimdValue>::Element )`

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

`impl SimdValue for u128`

`type Element = u128`

`type SimdBool = bool`

`pub fn lanes() -> usize`

`pub fn splat(val: <u128 as SimdValue>::Element) -> u128`

`pub fn extract(&self, usize) -> <u128 as SimdValue>::Element`

`pub unsafe fn extract_unchecked(&self, usize) -> <u128 as SimdValue>::Element`

`pub fn replace(&mut self, usize, val: <u128 as SimdValue>::Element)`

`pub unsafe fn replace_unchecked( &mut self, usize, val: <u128 as SimdValue>::Element )`

`pub fn select(self, cond: <u128 as SimdValue>::SimdBool, other: u128) -> u128`

`impl SimdValue for AutoSimd<[i16; 16]>`

`type Element = i16`

`type SimdBool = AutoSimd<[bool; 16]>`

`pub fn lanes() -> usize`

`pub fn splat( val: <AutoSimd<[i16; 16]> as SimdValue>::Element ) -> AutoSimd<[i16; 16]>`

`pub fn extract(&self, i: usize) -> <AutoSimd<[i16; 16]> as SimdValue>::Element`

`pub unsafe fn extract_unchecked( &self, i: usize ) -> <AutoSimd<[i16; 16]> as SimdValue>::Element`

`pub fn replace( &mut self, i: usize, val: <AutoSimd<[i16; 16]> as SimdValue>::Element )`

`pub unsafe fn replace_unchecked( &mut self, i: usize, val: <AutoSimd<[i16; 16]> as SimdValue>::Element )`

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

`impl SimdValue for i8`

`type Element = i8`

`type SimdBool = bool`

`pub fn lanes() -> usize`

`pub fn splat(val: <i8 as SimdValue>::Element) -> i8`

`pub fn extract(&self, usize) -> <i8 as SimdValue>::Element`

`pub unsafe fn extract_unchecked(&self, usize) -> <i8 as SimdValue>::Element`

`pub fn replace(&mut self, usize, val: <i8 as SimdValue>::Element)`