Struct GenericIsa 

pub struct GenericIsa { /* private fields */ }

Implementations

impl GenericIsa

pub fn new() -> Self

Trait Implementations

impl Clone for GenericIsa

fn clone(&self) -> GenericIsa

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Concat<i32> for GenericIsa

fn concat_low(self, a: I32x4, b: I32x4) -> I32x4

Concatenate elements from the low halves of two vectors.

fn concat_high(self, a: I32x4, b: I32x4) -> I32x4

Concatenate elements from the high halves of two vectors.

impl Default for GenericIsa

fn default() -> Self

Returns the “default value” for a type.

impl Extend<i16> for GenericIsa

type Output = I32x4

SIMD vector type with elements that have twice the bit-width of those in Self::SIMD.

fn extend(self, x: I16x8) -> (I32x4, I32x4)

Extend each lane to a type with twice the width.

impl Extend<i8> for GenericIsa

type Output = I16x8

SIMD vector type with elements that have twice the bit-width of those in Self::SIMD.

fn extend(self, x: I8x16) -> (I16x8, I16x8)

Extend each lane to a type with twice the width.

impl Extend<u8> for GenericIsa

type Output = U16x8

SIMD vector type with elements that have twice the bit-width of those in Self::SIMD.

fn extend(self, x: U8x16) -> (U16x8, U16x8)

Extend each lane to a type with twice the width.

impl FloatOps<f32> for GenericIsa

type Int = <GenericIsa as Isa>::I32

Integer SIMD vector of the same bit-width as this vector.

fn div(self, x: F32x4, y: F32x4) -> F32x4

Compute x / y

fn round_ties_even(self, x: F32x4) -> F32x4

Round x to the nearest integer value, with ties to even.

fn neg(self, x: F32x4) -> F32x4

Compute -x

fn abs(self, x: F32x4) -> F32x4

Compute the absolute value of x

fn to_int_trunc(self, x: F32x4) -> Self::Int

Convert each lane to an integer of the same width, rounding towards zero.

fn to_int_round(self, x: F32x4) -> Self::Int

Convert each lane to an integer of the same width, rounding to nearest with ties to even.

fn reciprocal(self, x: Self::Simd) -> Self::Simd

Compute 1. / x

fn mul_sub_from(self, a: Self::Simd, b: Self::Simd, c: Self::Simd) -> Self::Simd

Compute c - a * b.

impl IntOps<i16> for GenericIsa

fn shift_left<const SHIFT: i32>(self, x: I16x8) -> I16x8

Shift each lane in x left by SHIFT bits.

fn shift_right<const SHIFT: i32>(self, x: I16x8) -> I16x8

Shift each lane in x right by SHIFT bits.

impl IntOps<i32> for GenericIsa

fn shift_left<const SHIFT: i32>(self, x: I32x4) -> I32x4

Shift each lane in x left by SHIFT bits.

fn shift_right<const SHIFT: i32>(self, x: I32x4) -> I32x4

Shift each lane in x right by SHIFT bits.

impl IntOps<i8> for GenericIsa

fn shift_left<const SHIFT: i32>(self, x: I8x16) -> I8x16

Shift each lane in x left by SHIFT bits.

fn shift_right<const SHIFT: i32>(self, x: I8x16) -> I8x16

Shift each lane in x right by SHIFT bits.

impl IntOps<u16> for GenericIsa

fn shift_left<const SHIFT: i32>(self, x: U16x8) -> U16x8

Shift each lane in x left by SHIFT bits.

fn shift_right<const SHIFT: i32>(self, x: U16x8) -> U16x8

Shift each lane in x right by SHIFT bits.

impl IntOps<u8> for GenericIsa

fn shift_left<const SHIFT: i32>(self, x: U8x16) -> U8x16

Shift each lane in x left by SHIFT bits.

fn shift_right<const SHIFT: i32>(self, x: U8x16) -> U8x16

Shift each lane in x right by SHIFT bits.

impl Interleave<i16> for GenericIsa

fn interleave_low(self, a: I16x8, b: I16x8) -> I16x8

Interleave elements from the low halves of two vectors.

fn interleave_high(self, a: I16x8, b: I16x8) -> I16x8

Interleave elements from the high halves of two vectors.

impl Interleave<i8> for GenericIsa

fn interleave_low(self, a: I8x16, b: I8x16) -> I8x16

Interleave elements from the low halves of two vectors.

fn interleave_high(self, a: I8x16, b: I8x16) -> I8x16

Interleave elements from the high halves of two vectors.

impl Interleave<u8> for GenericIsa

fn interleave_low(self, a: U8x16, b: U8x16) -> U8x16

Interleave elements from the low halves of two vectors.

fn interleave_high(self, a: U8x16, b: U8x16) -> U8x16

Interleave elements from the high halves of two vectors.

impl Isa for GenericIsa

type M32 = M32

Mask vector for 32-bit lanes.

type M16 = M16

Mask vector for 16-bit lanes.

type M8 = M8

Mask vector for 8-bit lanes.

type F32 = F32x4

SIMD vector with f32 elements.

type I32 = I32x4

SIMD vector with i32 elements.

type I16 = I16x8

SIMD vector with i16 elements.

type I8 = I8x16

SIMD vector with i8 elements.

type U8 = U8x16

SIMD vector with u8 elements.

type U16 = U16x8

SIMD vector with u16 elements.

type U32 = U32x4

SIMD vector with u32 elements.

type Bits = I32x4

SIMD vector with an unspecified element type. This is used for bitwise casting between different vector types.

fn f32(self) -> impl FloatOps<f32, Simd = Self::F32, Int = Self::I32>

Operations on SIMD vectors with f32 elements.

fn i32( self, ) -> impl SignedIntOps<i32, Simd = Self::I32> + NarrowSaturate<i32, i16, Output = Self::I16> + Concat<i32> + ToFloat<i32, Output = Self::F32>

Operations on SIMD vectors with i32 elements.

fn i16( self, ) -> impl SignedIntOps<i16, Simd = Self::I16> + NarrowSaturate<i16, u8, Output = Self::U8> + Extend<i16, Output = Self::I32> + Interleave<i16>

Operations on SIMD vectors with i16 elements.

fn i8( self, ) -> impl SignedIntOps<i8, Simd = Self::I8> + Extend<i8, Output = Self::I16> + Interleave<i8>

Operations on SIMD vectors with i8 elements.

fn u8( self, ) -> impl IntOps<u8, Simd = Self::U8> + Extend<u8, Output = Self::U16> + Interleave<u8>

Operations on SIMD vectors with u8 elements.

fn u16(self) -> impl IntOps<u16, Simd = Self::U16>

Operations on SIMD vectors with u16 elements.

fn m32(self) -> impl MaskOps<Self::M32>

Operations on mask vectors for 32-bit lanes.

fn m16(self) -> impl MaskOps<Self::M16>

Operations on mask vectors for 16-bit lanes.

fn m8(self) -> impl MaskOps<Self::M8>

Operations on mask vectors for 8-bit lanes.

impl NarrowSaturate<i16, u8> for GenericIsa

type Output = U8x16

fn narrow_saturate(self, lo: I16x8, hi: I16x8) -> U8x16

Narrow each lane in a pair of vectors to one with half the bit-width.

impl NarrowSaturate<i32, i16> for GenericIsa

type Output = I16x8

fn narrow_saturate(self, lo: I32x4, hi: I32x4) -> I16x8

Narrow each lane in a pair of vectors to one with half the bit-width.

impl NumOps<f32> for GenericIsa

type Simd = F32x4

SIMD vector containing lanes of type T.

fn len(self) -> usize

Return the number of elements in the vector.

fn first_n_mask(self, n: usize) -> M32

Return a mask with the first n lanes set to true.

unsafe fn load_ptr_mask( self, ptr: *const <F32x4 as Simd>::Elem, mask: <F32x4 as Simd>::Mask, ) -> F32x4

Load vector elements from ptr using a mask.

unsafe fn store_ptr_mask( self, x: F32x4, ptr: *mut <F32x4 as Simd>::Elem, mask: <F32x4 as Simd>::Mask, )

Store the values in this vector to a memory location, where the corresponding mask element is set.

fn add(self, x: F32x4, y: F32x4) -> F32x4

Compute x + y.

fn sub(self, x: F32x4, y: F32x4) -> F32x4

Compute x - y.

fn mul(self, x: F32x4, y: F32x4) -> F32x4

Compute x * y.

fn mul_add(self, a: F32x4, b: F32x4, c: F32x4) -> F32x4

Compute a * b + c.

fn eq(self, x: F32x4, y: F32x4) -> M32

Return a mask indicating whether elements in x are equal to y.

fn ge(self, x: F32x4, y: F32x4) -> M32

Return a mask indicating whether elements in x are greater or equal to y.

fn gt(self, x: F32x4, y: F32x4) -> M32

Return a mask indicating whether elements in x are greater than y.

fn min(self, x: F32x4, y: F32x4) -> F32x4

Return the minimum of x and y for each lane.

fn max(self, x: F32x4, y: F32x4) -> F32x4

Return the maximum of x and y for each lane.

fn splat(self, x: f32) -> F32x4

Create a new vector with all lanes set to x.

unsafe fn load_ptr(self, ptr: *const f32) -> F32x4

Load vector of elements from ptr.

fn select(self, x: F32x4, y: F32x4, mask: <F32x4 as Simd>::Mask) -> F32x4

Select elements from x or y according to a mask.

unsafe fn store_ptr(self, x: F32x4, ptr: *mut f32)

Store the values in this vector to a memory location.

fn and(self, x: F32x4, y: F32x4) -> F32x4

Return the bitwise AND of x and y.

fn not(self, x: F32x4) -> F32x4

Return the bitwise NOT of x.

fn or(self, x: F32x4, y: F32x4) -> F32x4

Return the bitwise OR of x and y.

fn xor(self, x: F32x4, y: F32x4) -> F32x4

Return the bitwise XOR of x and y.

fn from_bits(self, x: <<Self::Simd as Simd>::Isa as Isa>::Bits) -> Self::Simd

Convert x to an untyped vector of the same width.

fn zero(self) -> Self::Simd

Create a new vector with all lanes set to zero.

fn one(self) -> Self::Simd

Create a new vector with all lanes set to one.

fn broadcast_lane<const LANE: i32>(self, x: Self::Simd) -> Self::Simd

Broadcast the element from one lane of a vector to all lanes of a new vector.

fn poly_eval(self, x: Self::Simd, coeffs: &[Self::Simd]) -> Self::Simd

Evaluate a polynomial using Horner’s method.

fn lt(self, x: Self::Simd, y: Self::Simd) -> <Self::Simd as Simd>::Mask

Return a mask indicating whether elements in x are less than y.

fn le(self, x: Self::Simd, y: Self::Simd) -> <Self::Simd as Simd>::Mask

Return a mask indicating whether elements in x are less or equal to y.

fn clamp(self, x: Self::Simd, min: Self::Simd, max: Self::Simd) -> Self::Simd

Clamp values in x to minimum and maximum values from corresponding lanes in min and max.

fn fold_splat<F: Fn(T, T) -> T>( self, x: Self::Simd, accum: T, f: F, ) -> Self::Simd

Reduce the elements in x to a single value using f, then return a new vector with the accumulated value broadcast to each lane.

fn load(self, xs: &[T]) -> Self::Simd

Load the first self.len() elements from a slice into a vector.

fn load_many<const N: usize>(self, xs: &[T]) -> [Self::Simd; N]

Load N vectors from consecutive sub-slices of xs.

fn load_pad(self, xs: &[T]) -> (Self::Simd, <Self::Simd as Simd>::Mask)

Load elements from xs into a vector.

fn store(self, x: Self::Simd, xs: &mut [T])

Store x into the first self.len() elements of xs.

fn store_uninit(self, x: Self::Simd, xs: &mut [MaybeUninit<T>]) -> &mut [T]

Store x into the first self.len() elements of xs.

fn prefetch(self, ptr: *const T)

Pre-fetch the cache line containing ptr for reading.

fn prefetch_write(self, ptr: *mut T)

Pre-fetch the cache line containing ptr for writing.

fn sum(self, x: Self::Simd) -> T

Horizontally sum the elements in a vector.

impl NumOps<i16> for GenericIsa

type Simd = I16x8

SIMD vector containing lanes of type T.

fn len(self) -> usize

Return the number of elements in the vector.

fn first_n_mask(self, n: usize) -> M16

Return a mask with the first n lanes set to true.

unsafe fn load_ptr_mask( self, ptr: *const <I16x8 as Simd>::Elem, mask: <I16x8 as Simd>::Mask, ) -> I16x8

Load vector elements from ptr using a mask.

unsafe fn store_ptr_mask( self, x: I16x8, ptr: *mut <I16x8 as Simd>::Elem, mask: <I16x8 as Simd>::Mask, )

Store the values in this vector to a memory location, where the corresponding mask element is set.

fn add(self, x: I16x8, y: I16x8) -> I16x8

Compute x + y.

fn sub(self, x: I16x8, y: I16x8) -> I16x8

Compute x - y.

fn mul(self, x: I16x8, y: I16x8) -> I16x8

Compute x * y.

fn mul_add(self, a: I16x8, b: I16x8, c: I16x8) -> I16x8

Compute a * b + c.

fn eq(self, x: I16x8, y: I16x8) -> M16

Return a mask indicating whether elements in x are equal to y.

fn ge(self, x: I16x8, y: I16x8) -> M16

Return a mask indicating whether elements in x are greater or equal to y.

fn gt(self, x: I16x8, y: I16x8) -> M16

Return a mask indicating whether elements in x are greater than y.

fn min(self, x: I16x8, y: I16x8) -> I16x8

Return the minimum of x and y for each lane.

fn max(self, x: I16x8, y: I16x8) -> I16x8

Return the maximum of x and y for each lane.

fn splat(self, x: i16) -> I16x8

Create a new vector with all lanes set to x.

unsafe fn load_ptr(self, ptr: *const i16) -> I16x8

Load vector of elements from ptr.

fn select(self, x: I16x8, y: I16x8, mask: <I16x8 as Simd>::Mask) -> I16x8

Select elements from x or y according to a mask.

unsafe fn store_ptr(self, x: I16x8, ptr: *mut i16)

Store the values in this vector to a memory location.

fn and(self, x: I16x8, y: I16x8) -> I16x8

Return the bitwise AND of x and y.

fn or(self, x: I16x8, y: I16x8) -> I16x8

Return the bitwise OR of x and y.

fn not(self, x: I16x8) -> I16x8

Return the bitwise NOT of x.

fn xor(self, x: I16x8, y: I16x8) -> I16x8

Return the bitwise XOR of x and y.

fn from_bits(self, x: <<Self::Simd as Simd>::Isa as Isa>::Bits) -> Self::Simd

Convert x to an untyped vector of the same width.

fn zero(self) -> Self::Simd

Create a new vector with all lanes set to zero.

fn one(self) -> Self::Simd

Create a new vector with all lanes set to one.

fn broadcast_lane<const LANE: i32>(self, x: Self::Simd) -> Self::Simd

Broadcast the element from one lane of a vector to all lanes of a new vector.

fn poly_eval(self, x: Self::Simd, coeffs: &[Self::Simd]) -> Self::Simd

Evaluate a polynomial using Horner’s method.

fn lt(self, x: Self::Simd, y: Self::Simd) -> <Self::Simd as Simd>::Mask

Return a mask indicating whether elements in x are less than y.

fn le(self, x: Self::Simd, y: Self::Simd) -> <Self::Simd as Simd>::Mask

Return a mask indicating whether elements in x are less or equal to y.

fn clamp(self, x: Self::Simd, min: Self::Simd, max: Self::Simd) -> Self::Simd

Clamp values in x to minimum and maximum values from corresponding lanes in min and max.

fn fold_splat<F: Fn(T, T) -> T>( self, x: Self::Simd, accum: T, f: F, ) -> Self::Simd

Reduce the elements in x to a single value using f, then return a new vector with the accumulated value broadcast to each lane.

fn load(self, xs: &[T]) -> Self::Simd

Load the first self.len() elements from a slice into a vector.

fn load_many<const N: usize>(self, xs: &[T]) -> [Self::Simd; N]

Load N vectors from consecutive sub-slices of xs.

fn load_pad(self, xs: &[T]) -> (Self::Simd, <Self::Simd as Simd>::Mask)

Load elements from xs into a vector.

fn store(self, x: Self::Simd, xs: &mut [T])

Store x into the first self.len() elements of xs.

fn store_uninit(self, x: Self::Simd, xs: &mut [MaybeUninit<T>]) -> &mut [T]

Store x into the first self.len() elements of xs.

fn prefetch(self, ptr: *const T)

Pre-fetch the cache line containing ptr for reading.

fn prefetch_write(self, ptr: *mut T)

Pre-fetch the cache line containing ptr for writing.

fn sum(self, x: Self::Simd) -> T

Horizontally sum the elements in a vector.

impl NumOps<i32> for GenericIsa

type Simd = I32x4

SIMD vector containing lanes of type T.

fn len(self) -> usize

Return the number of elements in the vector.

fn first_n_mask(self, n: usize) -> M32

Return a mask with the first n lanes set to true.

unsafe fn load_ptr_mask( self, ptr: *const <I32x4 as Simd>::Elem, mask: <I32x4 as Simd>::Mask, ) -> I32x4

Load vector elements from ptr using a mask.

unsafe fn store_ptr_mask( self, x: I32x4, ptr: *mut <I32x4 as Simd>::Elem, mask: <I32x4 as Simd>::Mask, )

Store the values in this vector to a memory location, where the corresponding mask element is set.

fn add(self, x: I32x4, y: I32x4) -> I32x4

Compute x + y.

fn sub(self, x: I32x4, y: I32x4) -> I32x4

Compute x - y.

fn mul(self, x: I32x4, y: I32x4) -> I32x4

Compute x * y.

fn mul_add(self, a: I32x4, b: I32x4, c: I32x4) -> I32x4

Compute a * b + c.

fn eq(self, x: I32x4, y: I32x4) -> M32

Return a mask indicating whether elements in x are equal to y.

fn ge(self, x: I32x4, y: I32x4) -> M32

Return a mask indicating whether elements in x are greater or equal to y.

fn gt(self, x: I32x4, y: I32x4) -> M32

Return a mask indicating whether elements in x are greater than y.

fn min(self, x: I32x4, y: I32x4) -> I32x4

Return the minimum of x and y for each lane.

fn max(self, x: I32x4, y: I32x4) -> I32x4

Return the maximum of x and y for each lane.

fn splat(self, x: i32) -> I32x4

Create a new vector with all lanes set to x.

unsafe fn load_ptr(self, ptr: *const i32) -> I32x4

Load vector of elements from ptr.

fn select(self, x: I32x4, y: I32x4, mask: <I32x4 as Simd>::Mask) -> I32x4

Select elements from x or y according to a mask.

unsafe fn store_ptr(self, x: I32x4, ptr: *mut i32)

Store the values in this vector to a memory location.

fn and(self, x: I32x4, y: I32x4) -> I32x4

Return the bitwise AND of x and y.

fn or(self, x: I32x4, y: I32x4) -> I32x4

Return the bitwise OR of x and y.

fn not(self, x: I32x4) -> I32x4

Return the bitwise NOT of x.

fn xor(self, x: I32x4, y: I32x4) -> I32x4

Return the bitwise XOR of x and y.

fn from_bits(self, x: <<Self::Simd as Simd>::Isa as Isa>::Bits) -> Self::Simd

Convert x to an untyped vector of the same width.

fn zero(self) -> Self::Simd

Create a new vector with all lanes set to zero.

fn one(self) -> Self::Simd

Create a new vector with all lanes set to one.

fn broadcast_lane<const LANE: i32>(self, x: Self::Simd) -> Self::Simd

Broadcast the element from one lane of a vector to all lanes of a new vector.

fn poly_eval(self, x: Self::Simd, coeffs: &[Self::Simd]) -> Self::Simd

Evaluate a polynomial using Horner’s method.

fn lt(self, x: Self::Simd, y: Self::Simd) -> <Self::Simd as Simd>::Mask

Return a mask indicating whether elements in x are less than y.

fn le(self, x: Self::Simd, y: Self::Simd) -> <Self::Simd as Simd>::Mask

Return a mask indicating whether elements in x are less or equal to y.

fn clamp(self, x: Self::Simd, min: Self::Simd, max: Self::Simd) -> Self::Simd

Clamp values in x to minimum and maximum values from corresponding lanes in min and max.

fn fold_splat<F: Fn(T, T) -> T>( self, x: Self::Simd, accum: T, f: F, ) -> Self::Simd

Reduce the elements in x to a single value using f, then return a new vector with the accumulated value broadcast to each lane.

fn load(self, xs: &[T]) -> Self::Simd

Load the first self.len() elements from a slice into a vector.

fn load_many<const N: usize>(self, xs: &[T]) -> [Self::Simd; N]

Load N vectors from consecutive sub-slices of xs.

fn load_pad(self, xs: &[T]) -> (Self::Simd, <Self::Simd as Simd>::Mask)

Load elements from xs into a vector.

fn store(self, x: Self::Simd, xs: &mut [T])

Store x into the first self.len() elements of xs.

fn store_uninit(self, x: Self::Simd, xs: &mut [MaybeUninit<T>]) -> &mut [T]

Store x into the first self.len() elements of xs.

fn prefetch(self, ptr: *const T)

Pre-fetch the cache line containing ptr for reading.

fn prefetch_write(self, ptr: *mut T)

Pre-fetch the cache line containing ptr for writing.

fn sum(self, x: Self::Simd) -> T

Horizontally sum the elements in a vector.

impl NumOps<i8> for GenericIsa

type Simd = I8x16

SIMD vector containing lanes of type T.

fn len(self) -> usize

Return the number of elements in the vector.

fn first_n_mask(self, n: usize) -> M8

Return a mask with the first n lanes set to true.

unsafe fn load_ptr_mask( self, ptr: *const <I8x16 as Simd>::Elem, mask: <I8x16 as Simd>::Mask, ) -> I8x16

Load vector elements from ptr using a mask.

unsafe fn store_ptr_mask( self, x: I8x16, ptr: *mut <I8x16 as Simd>::Elem, mask: <I8x16 as Simd>::Mask, )

Store the values in this vector to a memory location, where the corresponding mask element is set.

fn add(self, x: I8x16, y: I8x16) -> I8x16

Compute x + y.

fn sub(self, x: I8x16, y: I8x16) -> I8x16

Compute x - y.

fn mul(self, x: I8x16, y: I8x16) -> I8x16

Compute x * y.

fn mul_add(self, a: I8x16, b: I8x16, c: I8x16) -> I8x16

Compute a * b + c.

fn eq(self, x: I8x16, y: I8x16) -> M8

Return a mask indicating whether elements in x are equal to y.

fn ge(self, x: I8x16, y: I8x16) -> M8

Return a mask indicating whether elements in x are greater or equal to y.

fn gt(self, x: I8x16, y: I8x16) -> M8

Return a mask indicating whether elements in x are greater than y.

fn min(self, x: I8x16, y: I8x16) -> I8x16

Return the minimum of x and y for each lane.

fn max(self, x: I8x16, y: I8x16) -> I8x16

Return the maximum of x and y for each lane.

fn splat(self, x: i8) -> I8x16

Create a new vector with all lanes set to x.

unsafe fn load_ptr(self, ptr: *const i8) -> I8x16

Load vector of elements from ptr.

fn select(self, x: I8x16, y: I8x16, mask: <I8x16 as Simd>::Mask) -> I8x16

Select elements from x or y according to a mask.

unsafe fn store_ptr(self, x: I8x16, ptr: *mut i8)

Store the values in this vector to a memory location.

fn and(self, x: I8x16, y: I8x16) -> I8x16

Return the bitwise AND of x and y.

fn or(self, x: I8x16, y: I8x16) -> I8x16

Return the bitwise OR of x and y.

fn not(self, x: I8x16) -> I8x16

Return the bitwise NOT of x.

fn xor(self, x: I8x16, y: I8x16) -> I8x16

Return the bitwise XOR of x and y.

fn from_bits(self, x: <<Self::Simd as Simd>::Isa as Isa>::Bits) -> Self::Simd

Convert x to an untyped vector of the same width.

fn zero(self) -> Self::Simd

Create a new vector with all lanes set to zero.

fn one(self) -> Self::Simd

Create a new vector with all lanes set to one.

fn broadcast_lane<const LANE: i32>(self, x: Self::Simd) -> Self::Simd

Broadcast the element from one lane of a vector to all lanes of a new vector.

fn poly_eval(self, x: Self::Simd, coeffs: &[Self::Simd]) -> Self::Simd

Evaluate a polynomial using Horner’s method.

fn lt(self, x: Self::Simd, y: Self::Simd) -> <Self::Simd as Simd>::Mask

Return a mask indicating whether elements in x are less than y.

fn le(self, x: Self::Simd, y: Self::Simd) -> <Self::Simd as Simd>::Mask

Return a mask indicating whether elements in x are less or equal to y.

fn clamp(self, x: Self::Simd, min: Self::Simd, max: Self::Simd) -> Self::Simd

Clamp values in x to minimum and maximum values from corresponding lanes in min and max.

fn fold_splat<F: Fn(T, T) -> T>( self, x: Self::Simd, accum: T, f: F, ) -> Self::Simd

Reduce the elements in x to a single value using f, then return a new vector with the accumulated value broadcast to each lane.

fn load(self, xs: &[T]) -> Self::Simd

Load the first self.len() elements from a slice into a vector.

fn load_many<const N: usize>(self, xs: &[T]) -> [Self::Simd; N]

Load N vectors from consecutive sub-slices of xs.

fn load_pad(self, xs: &[T]) -> (Self::Simd, <Self::Simd as Simd>::Mask)

Load elements from xs into a vector.

fn store(self, x: Self::Simd, xs: &mut [T])

Store x into the first self.len() elements of xs.

fn store_uninit(self, x: Self::Simd, xs: &mut [MaybeUninit<T>]) -> &mut [T]

Store x into the first self.len() elements of xs.

fn prefetch(self, ptr: *const T)

Pre-fetch the cache line containing ptr for reading.

fn prefetch_write(self, ptr: *mut T)

Pre-fetch the cache line containing ptr for writing.

fn sum(self, x: Self::Simd) -> T

Horizontally sum the elements in a vector.

impl NumOps<u16> for GenericIsa

type Simd = U16x8

SIMD vector containing lanes of type T.

fn len(self) -> usize

Return the number of elements in the vector.

fn first_n_mask(self, n: usize) -> M16

Return a mask with the first n lanes set to true.

unsafe fn load_ptr_mask( self, ptr: *const <U16x8 as Simd>::Elem, mask: <U16x8 as Simd>::Mask, ) -> U16x8

Load vector elements from ptr using a mask.

unsafe fn store_ptr_mask( self, x: U16x8, ptr: *mut <U16x8 as Simd>::Elem, mask: <U16x8 as Simd>::Mask, )

Store the values in this vector to a memory location, where the corresponding mask element is set.

fn add(self, x: U16x8, y: U16x8) -> U16x8

Compute x + y.

fn sub(self, x: U16x8, y: U16x8) -> U16x8

Compute x - y.

fn mul(self, x: U16x8, y: U16x8) -> U16x8

Compute x * y.

fn mul_add(self, a: U16x8, b: U16x8, c: U16x8) -> U16x8

Compute a * b + c.

fn eq(self, x: U16x8, y: U16x8) -> M16

Return a mask indicating whether elements in x are equal to y.

fn ge(self, x: U16x8, y: U16x8) -> M16

Return a mask indicating whether elements in x are greater or equal to y.

fn gt(self, x: U16x8, y: U16x8) -> M16

Return a mask indicating whether elements in x are greater than y.

fn min(self, x: U16x8, y: U16x8) -> U16x8

Return the minimum of x and y for each lane.

fn max(self, x: U16x8, y: U16x8) -> U16x8

Return the maximum of x and y for each lane.

fn splat(self, x: u16) -> U16x8

Create a new vector with all lanes set to x.

unsafe fn load_ptr(self, ptr: *const u16) -> U16x8

Load vector of elements from ptr.

fn select(self, x: U16x8, y: U16x8, mask: <U16x8 as Simd>::Mask) -> U16x8

Select elements from x or y according to a mask.

unsafe fn store_ptr(self, x: U16x8, ptr: *mut u16)

Store the values in this vector to a memory location.

fn and(self, x: U16x8, y: U16x8) -> U16x8

Return the bitwise AND of x and y.

fn or(self, x: U16x8, y: U16x8) -> U16x8

Return the bitwise OR of x and y.

fn not(self, x: U16x8) -> U16x8

Return the bitwise NOT of x.

fn xor(self, x: U16x8, y: U16x8) -> U16x8

Return the bitwise XOR of x and y.

fn from_bits(self, x: <<Self::Simd as Simd>::Isa as Isa>::Bits) -> Self::Simd

Convert x to an untyped vector of the same width.

fn zero(self) -> Self::Simd

Create a new vector with all lanes set to zero.

fn one(self) -> Self::Simd

Create a new vector with all lanes set to one.

fn broadcast_lane<const LANE: i32>(self, x: Self::Simd) -> Self::Simd

Broadcast the element from one lane of a vector to all lanes of a new vector.

fn poly_eval(self, x: Self::Simd, coeffs: &[Self::Simd]) -> Self::Simd

Evaluate a polynomial using Horner’s method.

fn lt(self, x: Self::Simd, y: Self::Simd) -> <Self::Simd as Simd>::Mask

Return a mask indicating whether elements in x are less than y.

fn le(self, x: Self::Simd, y: Self::Simd) -> <Self::Simd as Simd>::Mask

Return a mask indicating whether elements in x are less or equal to y.

fn clamp(self, x: Self::Simd, min: Self::Simd, max: Self::Simd) -> Self::Simd

Clamp values in x to minimum and maximum values from corresponding lanes in min and max.

fn fold_splat<F: Fn(T, T) -> T>( self, x: Self::Simd, accum: T, f: F, ) -> Self::Simd

Reduce the elements in x to a single value using f, then return a new vector with the accumulated value broadcast to each lane.

fn load(self, xs: &[T]) -> Self::Simd

Load the first self.len() elements from a slice into a vector.

fn load_many<const N: usize>(self, xs: &[T]) -> [Self::Simd; N]

Load N vectors from consecutive sub-slices of xs.

fn load_pad(self, xs: &[T]) -> (Self::Simd, <Self::Simd as Simd>::Mask)

Load elements from xs into a vector.

fn store(self, x: Self::Simd, xs: &mut [T])

Store x into the first self.len() elements of xs.

fn store_uninit(self, x: Self::Simd, xs: &mut [MaybeUninit<T>]) -> &mut [T]

Store x into the first self.len() elements of xs.

fn prefetch(self, ptr: *const T)

Pre-fetch the cache line containing ptr for reading.

fn prefetch_write(self, ptr: *mut T)

Pre-fetch the cache line containing ptr for writing.

fn sum(self, x: Self::Simd) -> T

Horizontally sum the elements in a vector.

impl NumOps<u8> for GenericIsa

type Simd = U8x16

SIMD vector containing lanes of type T.

fn len(self) -> usize

Return the number of elements in the vector.

fn first_n_mask(self, n: usize) -> M8

Return a mask with the first n lanes set to true.

unsafe fn load_ptr_mask( self, ptr: *const <U8x16 as Simd>::Elem, mask: <U8x16 as Simd>::Mask, ) -> U8x16

Load vector elements from ptr using a mask.

unsafe fn store_ptr_mask( self, x: U8x16, ptr: *mut <U8x16 as Simd>::Elem, mask: <U8x16 as Simd>::Mask, )

Store the values in this vector to a memory location, where the corresponding mask element is set.

fn add(self, x: U8x16, y: U8x16) -> U8x16

Compute x + y.

fn sub(self, x: U8x16, y: U8x16) -> U8x16

Compute x - y.

fn mul(self, x: U8x16, y: U8x16) -> U8x16

Compute x * y.

fn mul_add(self, a: U8x16, b: U8x16, c: U8x16) -> U8x16

Compute a * b + c.

fn eq(self, x: U8x16, y: U8x16) -> M8

Return a mask indicating whether elements in x are equal to y.

fn ge(self, x: U8x16, y: U8x16) -> M8

Return a mask indicating whether elements in x are greater or equal to y.

fn gt(self, x: U8x16, y: U8x16) -> M8

Return a mask indicating whether elements in x are greater than y.

fn min(self, x: U8x16, y: U8x16) -> U8x16

Return the minimum of x and y for each lane.

fn max(self, x: U8x16, y: U8x16) -> U8x16

Return the maximum of x and y for each lane.

fn splat(self, x: u8) -> U8x16

Create a new vector with all lanes set to x.

unsafe fn load_ptr(self, ptr: *const u8) -> U8x16

Load vector of elements from ptr.

fn select(self, x: U8x16, y: U8x16, mask: <U8x16 as Simd>::Mask) -> U8x16

Select elements from x or y according to a mask.

unsafe fn store_ptr(self, x: U8x16, ptr: *mut u8)

Store the values in this vector to a memory location.

fn and(self, x: U8x16, y: U8x16) -> U8x16

Return the bitwise AND of x and y.

fn or(self, x: U8x16, y: U8x16) -> U8x16

Return the bitwise OR of x and y.

fn not(self, x: U8x16) -> U8x16

Return the bitwise NOT of x.

fn xor(self, x: U8x16, y: U8x16) -> U8x16

Return the bitwise XOR of x and y.

fn from_bits(self, x: <<Self::Simd as Simd>::Isa as Isa>::Bits) -> Self::Simd

Convert x to an untyped vector of the same width.

fn zero(self) -> Self::Simd

Create a new vector with all lanes set to zero.

fn one(self) -> Self::Simd

Create a new vector with all lanes set to one.

fn broadcast_lane<const LANE: i32>(self, x: Self::Simd) -> Self::Simd

Broadcast the element from one lane of a vector to all lanes of a new vector.

fn poly_eval(self, x: Self::Simd, coeffs: &[Self::Simd]) -> Self::Simd

Evaluate a polynomial using Horner’s method.

fn lt(self, x: Self::Simd, y: Self::Simd) -> <Self::Simd as Simd>::Mask

Return a mask indicating whether elements in x are less than y.

fn le(self, x: Self::Simd, y: Self::Simd) -> <Self::Simd as Simd>::Mask

Return a mask indicating whether elements in x are less or equal to y.

fn clamp(self, x: Self::Simd, min: Self::Simd, max: Self::Simd) -> Self::Simd

Clamp values in x to minimum and maximum values from corresponding lanes in min and max.

fn fold_splat<F: Fn(T, T) -> T>( self, x: Self::Simd, accum: T, f: F, ) -> Self::Simd

Reduce the elements in x to a single value using f, then return a new vector with the accumulated value broadcast to each lane.

fn load(self, xs: &[T]) -> Self::Simd

Load the first self.len() elements from a slice into a vector.

fn load_many<const N: usize>(self, xs: &[T]) -> [Self::Simd; N]

Load N vectors from consecutive sub-slices of xs.

fn load_pad(self, xs: &[T]) -> (Self::Simd, <Self::Simd as Simd>::Mask)

Load elements from xs into a vector.

fn store(self, x: Self::Simd, xs: &mut [T])

Store x into the first self.len() elements of xs.

fn store_uninit(self, x: Self::Simd, xs: &mut [MaybeUninit<T>]) -> &mut [T]

Store x into the first self.len() elements of xs.

fn prefetch(self, ptr: *const T)

Pre-fetch the cache line containing ptr for reading.

fn prefetch_write(self, ptr: *mut T)

Pre-fetch the cache line containing ptr for writing.

fn sum(self, x: Self::Simd) -> T

Horizontally sum the elements in a vector.

impl SignedIntOps<i16> for GenericIsa

fn neg(self, x: I16x8) -> I16x8

Return -x.

fn abs(self, x: Self::Simd) -> Self::Simd

Compute the absolute value of x

impl SignedIntOps<i32> for GenericIsa

fn neg(self, x: I32x4) -> I32x4

Return -x.

fn abs(self, x: Self::Simd) -> Self::Simd

Compute the absolute value of x

impl SignedIntOps<i8> for GenericIsa

fn neg(self, x: I8x16) -> I8x16

Return -x.

fn abs(self, x: Self::Simd) -> Self::Simd

Compute the absolute value of x

impl ToFloat<i32> for GenericIsa

type Output = F32x4

fn to_float(self, x: I32x4) -> Self::Output

impl Copy for GenericIsa