Trait nalgebra::SimdValue

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

    fn map_lanes(self, f: impl Fn(Self::Element) -> Self::Element) -> Self
    where
        Self: Clone,
    { ... }
    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.

Required methods

fn lanes() -> usize

The number of lanes of this SIMD value.

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

Initializes an SIMD value with each lanes set to val.

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

Extracts the i-th lane of self.

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

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

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

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

Replaces the i-th lane of self by val.

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

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

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

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.

Provided methods

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.

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.

Implementations on Foreign Types

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

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, R, C> SimdValue for OMatrix<T, R, C> where
    T: Scalar + SimdValue,
    R: Dim,
    C: Dim,
    T::Element: Scalar,
    DefaultAllocator: Allocator<T, R, C> + Allocator<T::Element, R, C>, 

type Element = OMatrix<T::Element, R, C>

type SimdBool = T::SimdBool

fn lanes() -> usize

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

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

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

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

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

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

impl<T, const D: usize> SimdValue for Rotation<T, D> where
    T: Scalar + SimdValue,
    T::Element: Scalar, 

type Element = Rotation<T::Element, D>

type SimdBool = T::SimdBool

fn lanes() -> usize

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

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

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

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

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

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

impl<T: Scalar + SimdValue> SimdValue for Quaternion<T> where
    T::Element: Scalar, 

type Element = Quaternion<T::Element>

type SimdBool = T::SimdBool

fn lanes() -> usize

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

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

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

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

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

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

impl<T: Scalar + SimdValue> SimdValue for UnitQuaternion<T> where
    T::Element: Scalar, 

type Element = UnitQuaternion<T::Element>

type SimdBool = T::SimdBool

fn lanes() -> usize

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

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

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

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

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

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

impl<T: Scalar + SimdValue, const D: usize> SimdValue for Point<T, D> where
    T::Element: Scalar, 

type Element = Point<T::Element, D>

type SimdBool = T::SimdBool

fn lanes() -> usize

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

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

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

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

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

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

impl<T: Scalar + SimdValue, const D: usize> SimdValue for Translation<T, D> where
    T::Element: Scalar, 

type Element = Translation<T::Element, D>

type SimdBool = T::SimdBool

fn lanes() -> usize

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

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

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

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

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

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

impl<T: RealField, C, const D: usize> SimdValue for Transform<T, C, D> where
    T::Element: Scalar,
    C: TCategory,
    Const<D>: DimNameAdd<U1>,
    DefaultAllocator: Allocator<T, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>> + Allocator<T::Element, DimNameSum<Const<D>, U1>, DimNameSum<Const<D>, U1>>, 

type Element = Transform<T::Element, C, D>

type SimdBool = T::SimdBool

fn lanes() -> usize

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

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

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

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

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

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

impl<T: SimdRealField> SimdValue for UnitComplex<T> where
    T::Element: SimdRealField, 

type Element = UnitComplex<T::Element>

type SimdBool = T::SimdBool

fn lanes() -> usize

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

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

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

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

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

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

impl<T: SimdRealField, R, const D: usize> SimdValue for Isometry<T, R, D> where
    T::Element: SimdRealField,
    R: SimdValue<SimdBool = T::SimdBool> + AbstractRotation<T, D>,
    R::Element: AbstractRotation<T::Element, D>, 

type Element = Isometry<T::Element, R::Element, D>

type SimdBool = T::SimdBool

fn lanes() -> usize

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

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

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

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

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

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

impl<T: SimdRealField, R, const D: usize> SimdValue for Similarity<T, R, D> where
    T::Element: SimdRealField,
    R: SimdValue<SimdBool = T::SimdBool> + AbstractRotation<T, D>,
    R::Element: AbstractRotation<T::Element, D>, 

type Element = Similarity<T::Element, R::Element, D>

type SimdBool = T::SimdBool

fn lanes() -> usize

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

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

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

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

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

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