Struct `Simd`

#[repr(simd)]
pub(crate) struct Simd<T: SimdElement, const N: usize>(pub(in ::core_arch::simd) [T; N]);

Fields

0: [T; N]

Implementations

`impl Simd<f16, 16>`

const fn as_m256h(self) -> __m256h

`impl Simd<f16, 32>`

const fn as_m512h(self) -> __m512h

`impl Simd<f16, 8>`

const fn as_m128h(self) -> __m128h

`impl Simd<f32, 16>`

const fn as_m512(self) -> __m512

`impl Simd<f32, 4>`

const fn as_m128(self) -> __m128

`impl Simd<f32, 4>`

const fn v128(self) -> v128

`impl Simd<f32, 8>`

const fn as_m256(self) -> __m256

`impl Simd<f64, 2>`

const fn v128(self) -> v128

`impl Simd<f64, 2>`

const fn as_m128d(self) -> __m128d

`impl Simd<f64, 4>`

const fn as_m256d(self) -> __m256d

`impl Simd<f64, 8>`

const fn as_m512d(self) -> __m512d

`impl Simd<i16, 16>`

const fn as_m256bh(self) -> __m256bh

`impl Simd<i16, 16>`

const fn as_m256i(self) -> __m256i

`impl Simd<i16, 32>`

const fn as_m512bh(self) -> __m512bh

`impl Simd<i16, 32>`

const fn as_m512i(self) -> __m512i

`impl Simd<i16, 8>`

const fn as_m128i(self) -> __m128i

`impl Simd<i16, 8>`

const fn as_m128bh(self) -> __m128bh

`impl Simd<i16, 8>`

const fn v128(self) -> v128

`impl Simd<i32, 16>`

const fn as_m512bh(self) -> __m512bh

`impl Simd<i32, 16>`

const fn as_m512i(self) -> __m512i

`impl Simd<i32, 4>`

const fn as_m128i(self) -> __m128i

`impl Simd<i32, 4>`

const fn as_m128bh(self) -> __m128bh

`impl Simd<i32, 4>`

const fn v128(self) -> v128

`impl Simd<i32, 8>`

const fn as_m256i(self) -> __m256i

`impl Simd<i32, 8>`

const fn as_m256bh(self) -> __m256bh

`impl Simd<i64, 2>`

const fn v128(self) -> v128

`impl Simd<i64, 2>`

const fn as_m128i(self) -> __m128i

`impl Simd<i64, 4>`

const fn as_m256i(self) -> __m256i

`impl Simd<i64, 8>`

const fn as_m512i(self) -> __m512i

`impl Simd<i8, 16>`

const fn as_m128i(self) -> __m128i

`impl Simd<i8, 16>`

const fn v128(self) -> v128

`impl Simd<i8, 32>`

const fn as_m256i(self) -> __m256i

`impl Simd<i8, 64>`

const fn as_m512i(self) -> __m512i

`impl Simd<u16, 16>`

const fn as_m256bh(self) -> __m256bh

`impl Simd<u16, 16>`

const fn as_m256i(self) -> __m256i

`impl Simd<u16, 32>`

const fn as_m512i(self) -> __m512i

`impl Simd<u16, 32>`

const fn as_m512bh(self) -> __m512bh

`impl Simd<u16, 8>`

const fn as_m128bh(self) -> __m128bh

`impl Simd<u16, 8>`

const fn v128(self) -> v128

`impl Simd<u16, 8>`

const fn as_m128i(self) -> __m128i

`impl Simd<u32, 16>`

const fn as_m512i(self) -> __m512i

`impl Simd<u32, 16>`

const fn as_m512bh(self) -> __m512bh

`impl Simd<u32, 4>`

const fn v128(self) -> v128

`impl Simd<u32, 4>`

const fn as_m128i(self) -> __m128i

`impl Simd<u32, 4>`

const fn as_m128bh(self) -> __m128bh

`impl Simd<u32, 8>`

const fn as_m256bh(self) -> __m256bh

`impl Simd<u32, 8>`

const fn as_m256i(self) -> __m256i

`impl Simd<u64, 2>`

const fn v128(self) -> v128

`impl Simd<u64, 2>`

const fn as_m128i(self) -> __m128i

`impl Simd<u64, 4>`

const fn as_m256i(self) -> __m256i

`impl Simd<u64, 8>`

const fn as_m512i(self) -> __m512i

`impl Simd<u8, 16>`

const fn as_m128i(self) -> __m128i

`impl Simd<u8, 16>`

const fn v128(self) -> v128

`impl Simd<u8, 32>`

const fn as_m256i(self) -> __m256i

`impl Simd<u8, 64>`

const fn as_m512i(self) -> __m512i

`impl<T: SimdElement> Simd<T, 1>`

const fn new(x0: T) -> Self

`impl<T: SimdElement> Simd<T, 16>`

const fn new(x0: T, x1: T, x2: T, x3: T, x4: T, x5: T, x6: T, x7: T, x8: T, x9: T, x10: T, x11: T, x12: T, x13: T, x14: T, x15: T) -> Self

`impl<T: SimdElement> Simd<T, 2>`

const fn new(x0: T, x1: T) -> Self

`impl<T: SimdElement> Simd<T, 32>`

const fn new(x0: T, x1: T, x2: T, x3: T, x4: T, x5: T, x6: T, x7: T, x8: T, x9: T, x10: T, x11: T, x12: T, x13: T, x14: T, x15: T, x16: T, x17: T, x18: T, x19: T, x20: T, x21: T, x22: T, x23: T, x24: T, x25: T, x26: T, x27: T, x28: T, x29: T, x30: T, x31: T) -> Self

`impl<T: SimdElement> Simd<T, 4>`

const fn new(x0: T, x1: T, x2: T, x3: T) -> Self

`impl<T: SimdElement> Simd<T, 8>`

const fn new(x0: T, x1: T, x2: T, x3: T, x4: T, x5: T, x6: T, x7: T) -> Self

`impl<T: SimdElement, const N: usize> Simd<T, N>`

const ZERO: Self = _;: A value of this type where all elements are zeroed out.
const fn from_array(elements: [T; N]) -> Self
const fn splat(value: T) -> Self
const fn extract_dyn(&self, index: usize) -> T: Extract the element at position index. Note that index is not a constant so this operation is not efficient on most platforms. Use for testing only.
const fn as_array(&self) -> &[T; N]

`impl<const N: usize> Simd<f16, N>`

const fn to_bits(self) -> Simd<u16, N>
const fn from_bits(bits: Simd<u16, N>) -> Self

`impl<const N: usize> Simd<f32, N>`

const fn to_bits(self) -> Simd<u32, N>
const fn from_bits(bits: Simd<u32, N>) -> Self

`impl<const N: usize> Simd<f64, N>`

const fn to_bits(self) -> Simd<u64, N>
const fn from_bits(bits: Simd<u64, N>) -> Self

Trait Implementations

`impl From<HvxVector> for Simd<i32, 16>`

fn from(simd: HvxVector) -> Self

`impl From<HvxVector> for Simd<i32, 32>`

fn from(simd: HvxVector) -> Self

`impl From<HvxVectorPair> for Simd<i32, 32>`

fn from(simd: HvxVectorPair) -> Self

`impl From<HvxVectorPair> for Simd<i32, 64>`

fn from(simd: HvxVectorPair) -> Self

`impl From<HvxVectorPred> for Simd<i32, 16>`

fn from(simd: HvxVectorPred) -> Self

`impl From<HvxVectorPred> for Simd<i32, 32>`

fn from(simd: HvxVectorPred) -> Self

`impl From<__m128> for Simd<f32, 4>`

fn from(simd: __m128) -> Self

`impl From<__m128bh> for Simd<u16, 8>`

fn from(simd: __m128bh) -> Self

`impl From<__m128d> for Simd<f64, 2>`

fn from(simd: __m128d) -> Self

`impl From<__m128h> for Simd<f16, 8>`

fn from(simd: __m128h) -> Self

`impl From<__m128i> for Simd<i64, 2>`

fn from(simd: __m128i) -> Self

`impl From<__m256> for Simd<f32, 8>`

fn from(simd: __m256) -> Self

`impl From<__m256bh> for Simd<u16, 16>`

fn from(simd: __m256bh) -> Self

`impl From<__m256d> for Simd<f64, 4>`

fn from(simd: __m256d) -> Self

`impl From<__m256h> for Simd<f16, 16>`

fn from(simd: __m256h) -> Self

`impl From<__m256i> for Simd<i64, 4>`

fn from(simd: __m256i) -> Self

`impl From<__m512> for Simd<f32, 16>`

fn from(simd: __m512) -> Self

`impl From<__m512bh> for Simd<u16, 32>`

fn from(simd: __m512bh) -> Self

`impl From<__m512d> for Simd<f64, 8>`

fn from(simd: __m512d) -> Self

`impl From<__m512h> for Simd<f16, 32>`

fn from(simd: __m512h) -> Self

`impl From<__m512i> for Simd<i64, 8>`

fn from(simd: __m512i) -> Self

`impl From<f16x2> for Simd<f16, 2>`

fn from(simd: f16x2) -> Self

`impl From<float16x4_t> for Simd<f16, 4>`

fn from(simd: float16x4_t) -> Self

`impl From<float16x8_t> for Simd<f16, 8>`

fn from(simd: float16x8_t) -> Self

`impl From<float32x2_t> for Simd<f32, 2>`

fn from(simd: float32x2_t) -> Self

`impl From<float32x4_t> for Simd<f32, 4>`

fn from(simd: float32x4_t) -> Self

`impl From<float64x1_t> for Simd<f64, 1>`

fn from(simd: float64x1_t) -> Self

`impl From<float64x2_t> for Simd<f64, 2>`

fn from(simd: float64x2_t) -> Self

`impl From<int16x4_t> for Simd<i16, 4>`

fn from(simd: int16x4_t) -> Self

`impl From<int16x8_t> for Simd<i16, 8>`

fn from(simd: int16x8_t) -> Self

`impl From<int32x2_t> for Simd<i32, 2>`

fn from(simd: int32x2_t) -> Self

`impl From<int32x4_t> for Simd<i32, 4>`

fn from(simd: int32x4_t) -> Self

`impl From<int64x1_t> for Simd<i64, 1>`

fn from(simd: int64x1_t) -> Self

`impl From<int64x2_t> for Simd<i64, 2>`

fn from(simd: int64x2_t) -> Self

`impl From<int8x16_t> for Simd<i8, 16>`

fn from(simd: int8x16_t) -> Self

`impl From<int8x8_t> for Simd<i8, 8>`

fn from(simd: int8x8_t) -> Self

`impl From<m128> for Simd<f32, 4>`

fn from(simd: m128) -> Self

`impl From<m128d> for Simd<f64, 2>`

fn from(simd: m128d) -> Self

`impl From<m128i> for Simd<i64, 2>`

fn from(simd: m128i) -> Self

`impl From<m256> for Simd<f32, 8>`

fn from(simd: m256) -> Self

`impl From<m256d> for Simd<f64, 4>`

fn from(simd: m256d) -> Self

`impl From<m256i> for Simd<i64, 4>`

fn from(simd: m256i) -> Self

`impl From<poly16x4_t> for Simd<u16, 4>`

fn from(simd: poly16x4_t) -> Self

`impl From<poly16x8_t> for Simd<u16, 8>`

fn from(simd: poly16x8_t) -> Self

`impl From<poly64x1_t> for Simd<u64, 1>`

fn from(simd: poly64x1_t) -> Self

`impl From<poly64x2_t> for Simd<u64, 2>`

fn from(simd: poly64x2_t) -> Self

`impl From<poly8x16_t> for Simd<u8, 16>`

fn from(simd: poly8x16_t) -> Self

`impl From<poly8x8_t> for Simd<u8, 8>`

fn from(simd: poly8x8_t) -> Self

`impl From<uint16x4_t> for Simd<u16, 4>`

fn from(simd: uint16x4_t) -> Self

`impl From<uint16x8_t> for Simd<u16, 8>`

fn from(simd: uint16x8_t) -> Self

`impl From<uint32x2_t> for Simd<u32, 2>`

fn from(simd: uint32x2_t) -> Self

`impl From<uint32x4_t> for Simd<u32, 4>`

fn from(simd: uint32x4_t) -> Self

`impl From<uint64x1_t> for Simd<u64, 1>`

fn from(simd: uint64x1_t) -> Self

`impl From<uint64x2_t> for Simd<u64, 2>`

fn from(simd: uint64x2_t) -> Self

`impl From<uint8x16_t> for Simd<u8, 16>`

fn from(simd: uint8x16_t) -> Self

`impl From<uint8x8_t> for Simd<u8, 8>`

fn from(simd: uint8x8_t) -> Self

`impl From<v128> for Simd<i32, 4>`

fn from(simd: v128) -> Self

`impl From<vector_bool_char> for Simd<i8, 16>`

fn from(simd: vector_bool_char) -> Self

`impl From<vector_bool_char> for Simd<i8, 16>`

fn from(simd: vector_bool_char) -> Self

`impl From<vector_bool_int> for Simd<i32, 4>`

fn from(simd: vector_bool_int) -> Self

`impl From<vector_bool_int> for Simd<i32, 4>`

fn from(simd: vector_bool_int) -> Self

`impl From<vector_bool_long> for Simd<i64, 2>`

fn from(simd: vector_bool_long) -> Self

`impl From<vector_bool_long_long> for Simd<i64, 2>`

fn from(simd: vector_bool_long_long) -> Self

`impl From<vector_bool_short> for Simd<i16, 8>`

fn from(simd: vector_bool_short) -> Self

`impl From<vector_bool_short> for Simd<i16, 8>`

fn from(simd: vector_bool_short) -> Self

`impl From<vector_double> for Simd<f64, 2>`

fn from(simd: vector_double) -> Self

`impl From<vector_double> for Simd<f64, 2>`

fn from(simd: vector_double) -> Self

`impl From<vector_float> for Simd<f32, 4>`

fn from(simd: vector_float) -> Self

`impl From<vector_float> for Simd<f32, 4>`

fn from(simd: vector_float) -> Self

`impl From<vector_signed_char> for Simd<i8, 16>`

fn from(simd: vector_signed_char) -> Self

`impl From<vector_signed_char> for Simd<i8, 16>`

fn from(simd: vector_signed_char) -> Self

`impl From<vector_signed_int> for Simd<i32, 4>`

fn from(simd: vector_signed_int) -> Self

`impl From<vector_signed_int> for Simd<i32, 4>`

fn from(simd: vector_signed_int) -> Self

`impl From<vector_signed_long> for Simd<i64, 2>`

fn from(simd: vector_signed_long) -> Self

`impl From<vector_signed_long_long> for Simd<i64, 2>`

fn from(simd: vector_signed_long_long) -> Self

`impl From<vector_signed_short> for Simd<i16, 8>`

fn from(simd: vector_signed_short) -> Self

`impl From<vector_signed_short> for Simd<i16, 8>`

fn from(simd: vector_signed_short) -> Self

`impl From<vector_unsigned_char> for Simd<u8, 16>`

fn from(simd: vector_unsigned_char) -> Self

`impl From<vector_unsigned_char> for Simd<u8, 16>`

fn from(simd: vector_unsigned_char) -> Self

`impl From<vector_unsigned_int> for Simd<u32, 4>`

fn from(simd: vector_unsigned_int) -> Self

`impl From<vector_unsigned_int> for Simd<u32, 4>`

fn from(simd: vector_unsigned_int) -> Self

`impl From<vector_unsigned_long> for Simd<u64, 2>`

fn from(simd: vector_unsigned_long) -> Self

`impl From<vector_unsigned_long_long> for Simd<u64, 2>`

fn from(simd: vector_unsigned_long_long) -> Self

`impl From<vector_unsigned_short> for Simd<u16, 8>`

fn from(simd: vector_unsigned_short) -> Self

`impl From<vector_unsigned_short> for Simd<u16, 8>`

fn from(simd: vector_unsigned_short) -> Self

`impl SimdExt for Simd<i128, 2>`

type Elem = i128;
unsafe fn splat(v: i64) -> Self

`impl SimdExt for Simd<i128, 4>`

type Elem = i128;
unsafe fn splat(v: i64) -> Self

`impl SimdExt for Simd<i16, 16>`

type Elem = i16;
unsafe fn splat(v: i64) -> Self

`impl SimdExt for Simd<i16, 32>`

type Elem = i16;
unsafe fn splat(v: i64) -> Self

`impl SimdExt for Simd<i16, 8>`

type Elem = i16;
unsafe fn splat(v: i64) -> Self

`impl SimdExt for Simd<i32, 16>`

type Elem = i32;
unsafe fn splat(v: i64) -> Self

`impl SimdExt for Simd<i32, 4>`

type Elem = i32;
unsafe fn splat(v: i64) -> Self

`impl SimdExt for Simd<i32, 8>`

type Elem = i32;
unsafe fn splat(v: i64) -> Self

`impl SimdExt for Simd<i64, 2>`

type Elem = i64;
unsafe fn splat(v: i64) -> Self

`impl SimdExt for Simd<i64, 4>`

type Elem = i64;
unsafe fn splat(v: i64) -> Self

`impl SimdExt for Simd<i64, 8>`

type Elem = i64;
unsafe fn splat(v: i64) -> Self

`impl SimdExt for Simd<i8, 16>`

type Elem = i8;
unsafe fn splat(v: i64) -> Self

`impl SimdExt for Simd<i8, 32>`

type Elem = i8;
unsafe fn splat(v: i64) -> Self

`impl SimdExt for Simd<u128, 2>`

type Elem = u128;
unsafe fn splat(v: i64) -> Self

`impl SimdExt for Simd<u128, 4>`

type Elem = u128;
unsafe fn splat(v: i64) -> Self

`impl SimdExt for Simd<u16, 16>`

type Elem = u16;
unsafe fn splat(v: i64) -> Self

`impl SimdExt for Simd<u16, 32>`

type Elem = u16;
unsafe fn splat(v: i64) -> Self

`impl SimdExt for Simd<u16, 8>`

type Elem = u16;
unsafe fn splat(v: i64) -> Self

`impl SimdExt for Simd<u32, 16>`

type Elem = u32;
unsafe fn splat(v: i64) -> Self

`impl SimdExt for Simd<u32, 4>`

type Elem = u32;
unsafe fn splat(v: i64) -> Self

`impl SimdExt for Simd<u32, 8>`

type Elem = u32;
unsafe fn splat(v: i64) -> Self

`impl SimdExt for Simd<u64, 2>`

type Elem = u64;
unsafe fn splat(v: i64) -> Self

`impl SimdExt for Simd<u64, 4>`

type Elem = u64;
unsafe fn splat(v: i64) -> Self

`impl SimdExt for Simd<u64, 8>`

type Elem = u64;
unsafe fn splat(v: i64) -> Self

`impl SimdExt for Simd<u8, 16>`

type Elem = u8;
unsafe fn splat(v: i64) -> Self

`impl SimdExt for Simd<u8, 32>`

type Elem = u8;
unsafe fn splat(v: i64) -> Self

`impl<T: Copy + SimdElement, const N: usize> Copy for Simd<T, N>`

`impl<T: SimdElement, const N: usize> Clone for Simd<T, N>`

fn clone(&self) -> Self

`impl<T: SimdElement, const N: usize> Debug for Simd<T, N>`

fn fmt(&self, f: &mut Formatter<'_>) -> Result

`impl<T: SimdElement, const N: usize> PartialEq for Simd<T, N>`

fn eq(&self, other: &Self) -> bool

Auto Trait Implementations

`impl<T, const N: usize> Freeze for Simd<T, N> where [T; N]: Freeze,`

`impl<T, const N: usize> RefUnwindSafe for Simd<T, N> where [T; N]: RefUnwindSafe,`

`impl<T, const N: usize> Send for Simd<T, N> where [T; N]: Send,`

`impl<T, const N: usize> Sync for Simd<T, N> where [T; N]: Sync,`

`impl<T, const N: usize> Unpin for Simd<T, N> where [T; N]: Unpin,`

`impl<T, const N: usize> UnsafeUnpin for Simd<T, N> where [T; N]: UnsafeUnpin,`

`impl<T, const N: usize> UnwindSafe for Simd<T, N> where [T; N]: UnwindSafe,`

Blanket Implementations

`impl<T> Any for Simd<T, N> where T: 'static + ?Sized,`

fn type_id(&self) -> TypeId

`impl<T> Borrow<T> for Simd<T, N> where T: ?Sized,`

fn borrow(&self) -> &T

`impl<T> BorrowMut<T> for Simd<T, N> where T: ?Sized,`

fn borrow_mut(&mut self) -> &mut T

`impl<T> CloneToUninit for Simd<T, N> where T: Clone,`

unsafe fn clone_to_uninit(&self, dest: *mut u8)

`impl<T> From<T> for Simd<T, N>`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T> Printable for Simd<T, N> where T: Copy + Debug,`

`impl<T> SizeHint for Simd<T, N> where T: ?Sized,`

fn lower_bound(&self) -> usize
fn upper_bound(&self) -> Option<usize>

`impl<T> SizedTypeProperties for Simd<T, N>`

`impl<T, U> Into for Simd<T, N> where U: From<T>,`

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

`impl<T, U> TryFrom for Simd<T, N> where U: Into<T>,`

type Error = Infallible;
fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

`impl<T, U> TryInto for Simd<T, N> where U: TryFrom<T>,`

type Error = >::Error;
fn try_into(self) -> Result<U, >::Error>