Trait packed_simd::SimdArray

pub trait SimdArray: Seal {
    type Tuple: Copy + Clone;
    type T;
    type NT;

    const N: usize;
}

Expand description

Trait implemented by arrays that can be SIMD types.

Required Associated Types§

type Tuple: Copy + Clone

The type of the #[repr(simd)] type.

type T

The element type of the vector.

type NT

The type: [u32; Self::N].

Required Associated Constants§

const N: usize

The number of elements in the array.

Implementations on Foreign Types§

impl SimdArray for [u8; 32]

type Tuple = u8x32

type T = u8

const N: usize = 32usize

type NT = [u32; 32]

impl SimdArray for [i64; 1]

type Tuple = i64x1

type T = i64

const N: usize = 1usize

type NT = [u32; 1]

impl SimdArray for [m128; 2]

type Tuple = m128x2

type T = m128

const N: usize = 2usize

type NT = [u32; 2]

impl SimdArray for [i8; 2]

type Tuple = i8x2

type T = i8

const N: usize = 2usize

type NT = [u32; 2]

impl SimdArray for [i8; 32]

type Tuple = i8x32

type T = i8

const N: usize = 32usize

type NT = [u32; 32]

impl SimdArray for [u32; 8]

type Tuple = u32x8

type T = u32

const N: usize = 8usize

type NT = [u32; 8]

impl SimdArray for [m128; 1]

type Tuple = m128x1

type T = m128

const N: usize = 1usize

type NT = [u32; 1]

impl SimdArray for [u16; 16]

type Tuple = u16x16

type T = u16

const N: usize = 16usize

type NT = [u32; 16]

impl SimdArray for [u16; 2]

type Tuple = u16x2

type T = u16

const N: usize = 2usize

type NT = [u32; 2]

impl SimdArray for [u8; 4]

type Tuple = u8x4

type T = u8

const N: usize = 4usize

type NT = [u32; 4]

impl SimdArray for [u128; 2]

type Tuple = u128x2

type T = u128

const N: usize = 2usize

type NT = [u32; 2]

impl SimdArray for [usize; 2]

type Tuple = usizex2

type T = usize

const N: usize = 2usize

type NT = [u32; 2]

impl SimdArray for [f64; 1]

type Tuple = f64x1

type T = f64

const N: usize = 1usize

type NT = [u32; 1]

impl SimdArray for [i64; 2]

type Tuple = i64x2

type T = i64

const N: usize = 2usize

type NT = [u32; 2]

impl SimdArray for [m8; 4]

type Tuple = m8x4

type T = m8

const N: usize = 4usize

type NT = [u32; 4]

impl SimdArray for [m16; 4]

type Tuple = m16x4

type T = m16

const N: usize = 4usize

type NT = [u32; 4]

impl SimdArray for [msize; 2]

type Tuple = msizex2

type T = msize

const N: usize = 2usize

type NT = [u32; 2]

impl SimdArray for [i8; 4]

type Tuple = i8x4

type T = i8

const N: usize = 4usize

type NT = [u32; 4]

impl SimdArray for [m64; 2]

type Tuple = m64x2

type T = m64

const N: usize = 2usize

type NT = [u32; 2]

impl SimdArray for [msize; 8]

type Tuple = msizex8

type T = msize

const N: usize = 8usize

type NT = [u32; 8]

impl<T> SimdArray for [*const T; 2]

type Tuple = cptrx2<*const T>

type T = *const T

const N: usize = 2usize

type NT = [u32; 2]

impl SimdArray for [i8; 8]

type Tuple = i8x8

type T = i8

const N: usize = 8usize

type NT = [u32; 8]

impl SimdArray for [m32; 8]

type Tuple = m32x8

type T = m32

const N: usize = 8usize

type NT = [u32; 8]

impl SimdArray for [f32; 8]

type Tuple = f32x8

type T = f32

const N: usize = 8usize

type NT = [u32; 8]

impl SimdArray for [i128; 1]

type Tuple = i128x1

type T = i128

const N: usize = 1usize

type NT = [u32; 1]

impl SimdArray for [m16; 16]

type Tuple = m16x16

type T = m16

const N: usize = 16usize

type NT = [u32; 16]

impl SimdArray for [u128; 4]

type Tuple = u128x4

type T = u128

const N: usize = 4usize

type NT = [u32; 4]

impl SimdArray for [u8; 2]

type Tuple = u8x2

type T = u8

const N: usize = 2usize

type NT = [u32; 2]

impl SimdArray for [i16; 16]

type Tuple = i16x16

type T = i16

const N: usize = 16usize

type NT = [u32; 16]

impl SimdArray for [u64; 1]

type Tuple = u64x1

type T = u64

const N: usize = 1usize

type NT = [u32; 1]

impl SimdArray for [f32; 16]

type Tuple = f32x16

type T = f32

const N: usize = 16usize

type NT = [u32; 16]

impl SimdArray for [i8; 64]

type Tuple = i8x64

type T = i8

const N: usize = 64usize

type NT = [u32; 64]

impl SimdArray for [i64; 8]

type Tuple = i64x8

type T = i64

const N: usize = 8usize

type NT = [u32; 8]

impl SimdArray for [i32; 8]

type Tuple = i32x8

type T = i32

const N: usize = 8usize

type NT = [u32; 8]

impl SimdArray for [i16; 4]

type Tuple = i16x4

type T = i16

const N: usize = 4usize

type NT = [u32; 4]

impl SimdArray for [f32; 4]

type Tuple = f32x4

type T = f32

const N: usize = 4usize

type NT = [u32; 4]

impl SimdArray for [u64; 4]

type Tuple = u64x4

type T = u64

const N: usize = 4usize

type NT = [u32; 4]

impl SimdArray for [u16; 4]

type Tuple = u16x4

type T = u16

const N: usize = 4usize

type NT = [u32; 4]

impl SimdArray for [i64; 4]

type Tuple = i64x4

type T = i64

const N: usize = 4usize

type NT = [u32; 4]

impl SimdArray for [u16; 8]

type Tuple = u16x8

type T = u16

const N: usize = 8usize

type NT = [u32; 8]

impl<T> SimdArray for [*mut T; 2]

type Tuple = mptrx2<*mut T>

type T = *mut T

const N: usize = 2usize

type NT = [u32; 2]

impl SimdArray for [f32; 2]

type Tuple = f32x2

type T = f32

const N: usize = 2usize

type NT = [u32; 2]

impl SimdArray for [u64; 8]

type Tuple = u64x8

type T = u64

const N: usize = 8usize

type NT = [u32; 8]

impl SimdArray for [isize; 4]

type Tuple = isizex4

type T = isize

const N: usize = 4usize

type NT = [u32; 4]

impl SimdArray for [i16; 32]

type Tuple = i16x32

type T = i16

const N: usize = 32usize

type NT = [u32; 32]

impl SimdArray for [m8; 16]

type Tuple = m8x16

type T = m8

const N: usize = 16usize

type NT = [u32; 16]

impl SimdArray for [usize; 4]

type Tuple = usizex4

type T = usize

const N: usize = 4usize

type NT = [u32; 4]

impl SimdArray for [m128; 4]

type Tuple = m128x4

type T = m128

const N: usize = 4usize

type NT = [u32; 4]

impl SimdArray for [m64; 8]

type Tuple = m64x8

type T = m64

const N: usize = 8usize

type NT = [u32; 8]

impl SimdArray for [m32; 4]

type Tuple = m32x4

type T = m32

const N: usize = 4usize

type NT = [u32; 4]

impl<T> SimdArray for [*const T; 8]

type Tuple = cptrx8<*const T>

type T = *const T

const N: usize = 8usize

type NT = [u32; 8]

impl SimdArray for [u8; 8]

type Tuple = u8x8

type T = u8

const N: usize = 8usize

type NT = [u32; 8]

impl SimdArray for [u8; 16]

type Tuple = u8x16

type T = u8

const N: usize = 16usize

type NT = [u32; 16]

impl SimdArray for [isize; 2]

type Tuple = isizex2

type T = isize

const N: usize = 2usize

type NT = [u32; 2]

impl SimdArray for [isize; 8]

type Tuple = isizex8

type T = isize

const N: usize = 8usize

type NT = [u32; 8]

impl SimdArray for [m8; 8]

type Tuple = m8x8

type T = m8

const N: usize = 8usize

type NT = [u32; 8]

impl SimdArray for [i32; 2]

type Tuple = i32x2

type T = i32

const N: usize = 2usize

type NT = [u32; 2]

impl SimdArray for [u32; 16]

type Tuple = u32x16

type T = u32

const N: usize = 16usize

type NT = [u32; 16]

impl SimdArray for [m16; 2]

type Tuple = m16x2

type T = m16

const N: usize = 2usize

type NT = [u32; 2]

impl SimdArray for [m8; 32]

type Tuple = m8x32

type T = m8

const N: usize = 32usize

type NT = [u32; 32]

impl SimdArray for [m8; 64]

type Tuple = m8x64

type T = m8

const N: usize = 64usize

type NT = [u32; 64]

impl<T> SimdArray for [*const T; 4]

type Tuple = cptrx4<*const T>

type T = *const T

const N: usize = 4usize

type NT = [u32; 4]

impl<T> SimdArray for [*mut T; 4]

type Tuple = mptrx4<*mut T>

type T = *mut T

const N: usize = 4usize

type NT = [u32; 4]

impl SimdArray for [m64; 4]

type Tuple = m64x4

type T = m64

const N: usize = 4usize

type NT = [u32; 4]

impl SimdArray for [u8; 64]

type Tuple = u8x64

type T = u8

const N: usize = 64usize

type NT = [u32; 64]

impl SimdArray for [f64; 4]

type Tuple = f64x4

type T = f64

const N: usize = 4usize

type NT = [u32; 4]

impl SimdArray for [m16; 8]

type Tuple = m16x8

type T = m16

const N: usize = 8usize

type NT = [u32; 8]

impl SimdArray for [m32; 2]

type Tuple = m32x2

type T = m32

const N: usize = 2usize

type NT = [u32; 2]

impl SimdArray for [u64; 2]

type Tuple = u64x2

type T = u64

const N: usize = 2usize

type NT = [u32; 2]

impl SimdArray for [u32; 2]

type Tuple = u32x2

type T = u32

const N: usize = 2usize

type NT = [u32; 2]

impl SimdArray for [f64; 8]

type Tuple = f64x8

type T = f64

const N: usize = 8usize

type NT = [u32; 8]

impl SimdArray for [u32; 4]

type Tuple = u32x4

type T = u32

const N: usize = 4usize

type NT = [u32; 4]

impl SimdArray for [u128; 1]

type Tuple = u128x1

type T = u128

const N: usize = 1usize

type NT = [u32; 1]

impl SimdArray for [u16; 32]

type Tuple = u16x32

type T = u16

const N: usize = 32usize

type NT = [u32; 32]

impl SimdArray for [usize; 8]

type Tuple = usizex8

type T = usize

const N: usize = 8usize

type NT = [u32; 8]

impl SimdArray for [i16; 8]

type Tuple = i16x8

type T = i16

const N: usize = 8usize

type NT = [u32; 8]

impl SimdArray for [i8; 16]

type Tuple = i8x16

type T = i8

const N: usize = 16usize

type NT = [u32; 16]

impl SimdArray for [m8; 2]

type Tuple = m8x2

type T = m8

const N: usize = 2usize

type NT = [u32; 2]

impl SimdArray for [msize; 4]

type Tuple = msizex4

type T = msize

const N: usize = 4usize

type NT = [u32; 4]

impl SimdArray for [m16; 32]

type Tuple = m16x32

type T = m16

const N: usize = 32usize

type NT = [u32; 32]

impl SimdArray for [f64; 2]

type Tuple = f64x2

type T = f64

const N: usize = 2usize

type NT = [u32; 2]

impl SimdArray for [i16; 2]

type Tuple = i16x2

type T = i16

const N: usize = 2usize

type NT = [u32; 2]

impl SimdArray for [i128; 2]

type Tuple = i128x2

type T = i128

const N: usize = 2usize

type NT = [u32; 2]

impl SimdArray for [m64; 1]

type Tuple = m64x1

type T = m64

const N: usize = 1usize

type NT = [u32; 1]

impl SimdArray for [i32; 16]

type Tuple = i32x16

type T = i32

const N: usize = 16usize

type NT = [u32; 16]

impl SimdArray for [i32; 4]

type Tuple = i32x4

type T = i32

const N: usize = 4usize

type NT = [u32; 4]

impl<T> SimdArray for [*mut T; 8]

type Tuple = mptrx8<*mut T>

type T = *mut T

const N: usize = 8usize

type NT = [u32; 8]

impl SimdArray for [m32; 16]

type Tuple = m32x16

type T = m32

const N: usize = 16usize

type NT = [u32; 16]

impl SimdArray for [i128; 4]

type Tuple = i128x4

type T = i128

const N: usize = 4usize

type NT = [u32; 4]

Implementors§