Trait SimdBehaviour 

pub trait SimdBehaviour<const N: usize>: Construct
where
    VecLen<N>: SupportedVecLen,
{
    type VectorRepr: SoundVectorRepr<N, Self>;

    // Provided methods
    fn vec_from_array(array: [Self; N]) -> Vector<N, Self, Simd>
       where Self: Scalar { ... }
    fn vec_splat(value: Self) -> Vector<N, Self, Simd>
       where Self: Scalar { ... }
    unsafe fn vec_swizzle2<const X_SRC: usize, const Y_SRC: usize>(
        vec: Vector<N, Self, Simd>,
    ) -> Vector<2, Self, Simd>
       where Self: Scalar { ... }
    unsafe fn vec_swizzle3<const X_SRC: usize, const Y_SRC: usize, const Z_SRC: usize>(
        vec: Vector<N, Self, Simd>,
    ) -> Vector<3, Self, Simd>
       where Self: Scalar { ... }
    unsafe fn vec_swizzle4<const X_SRC: usize, const Y_SRC: usize, const Z_SRC: usize, const W_SRC: usize>(
        vec: Vector<N, Self, Simd>,
    ) -> Vector<4, Self, Simd>
       where Self: Scalar { ... }
    fn vec_eq(vec: Vector<N, Self, Simd>, other: Vector<N, Self, Simd>) -> bool
       where Self: Scalar + PartialEq { ... }
    fn vec_ne(vec: Vector<N, Self, Simd>, other: Vector<N, Self, Simd>) -> bool
       where Self: Scalar + PartialEq { ... }
    fn vec_neg(vec: Vector<N, Self, Simd>) -> Vector<N, Self, Simd>
       where Self: Scalar + Neg<Output = Self> { ... }
    fn vec_not(vec: Vector<N, Self, Simd>) -> Vector<N, Self, Simd>
       where Self: Scalar + Not<Output = Self> { ... }
    fn vec_add(
        vec: Vector<N, Self, Simd>,
        rhs: Vector<N, Self, Simd>,
    ) -> Vector<N, Self, Simd>
       where Self: Scalar + Add<Output = Self> { ... }
    fn vec_sub(
        vec: Vector<N, Self, Simd>,
        rhs: Vector<N, Self, Simd>,
    ) -> Vector<N, Self, Simd>
       where Self: Scalar + Sub<Output = Self> { ... }
    fn vec_mul(
        vec: Vector<N, Self, Simd>,
        rhs: Vector<N, Self, Simd>,
    ) -> Vector<N, Self, Simd>
       where Self: Scalar + Mul<Output = Self> { ... }
    fn vec_div(
        vec: Vector<N, Self, Simd>,
        rhs: Vector<N, Self, Simd>,
    ) -> Vector<N, Self, Simd>
       where Self: Scalar + Div<Output = Self> { ... }
    fn vec_rem(
        vec: Vector<N, Self, Simd>,
        rhs: Vector<N, Self, Simd>,
    ) -> Vector<N, Self, Simd>
       where Self: Scalar + Rem<Output = Self> { ... }
    fn vec_shl(
        vec: Vector<N, Self, Simd>,
        rhs: Vector<N, Self, Simd>,
    ) -> Vector<N, Self, Simd>
       where Self: Scalar + Shl<Output = Self> { ... }
    fn vec_shr(
        vec: Vector<N, Self, Simd>,
        rhs: Vector<N, Self, Simd>,
    ) -> Vector<N, Self, Simd>
       where Self: Scalar + Shr<Output = Self> { ... }
    fn vec_bitand(
        vec: Vector<N, Self, Simd>,
        rhs: Vector<N, Self, Simd>,
    ) -> Vector<N, Self, Simd>
       where Self: Scalar + BitAnd<Output = Self> { ... }
    fn vec_bitor(
        vec: Vector<N, Self, Simd>,
        rhs: Vector<N, Self, Simd>,
    ) -> Vector<N, Self, Simd>
       where Self: Scalar + BitOr<Output = Self> { ... }
    fn vec_bitxor(
        vec: Vector<N, Self, Simd>,
        rhs: Vector<N, Self, Simd>,
    ) -> Vector<N, Self, Simd>
       where Self: Scalar + BitXor<Output = Self> { ... }
}

Controls the implementation details of Vector<N, Self, Simd>. For example, f32 implementing SimdBehaviour<4> controls Vector<4, f32, Simd>.

The goal of implementing this trait is to enable SIMD optimizations, but it’s acceptable not to use SIMD if it doesn’t provide a performance benefit, or if it’s only a placeholder implementation.

Required Associated Types

type VectorRepr: SoundVectorRepr<N, Self>

The internal representation of the vector.

There are two ways to define the internal representation:

1. Array:
   If the internal representation is [Self; N], there is no SIMD alignment.
   In this case, the behavior of Simd and NonSimd is the same, with no SIMD optimizations.

2. Wrapped Vector Type:
   If Self is a wrapper around an existing scalar type,
   the internal representation can be a vector of that scalar type.
   This allows you to leverage the SIMD-optimized API of the base type.
   To enable this, Self must implement ScalarWrapper<TInner>.

Example

use ggmath::*;

#[repr(transparent)]
#[derive(Copy, Clone)]
struct CustomScalar(f32);

impl Scalar for CustomScalar {}

// SAFETY: CustomScalar is a direct wrapper around f32, so it's safe to
// implement ScalarWrapper<f32> for it.
unsafe impl ScalarWrapper<f32> for CustomScalar {}

impl<const N: usize> SimdBehaviour<N> for CustomScalar
where
    VecLen<N>: SupportedVecLen,
{
    type VectorRepr = Vector<N, f32, Simd>;

    // Now you can use f32's SIMD-optimized vector API to optimize your vector
    // implementation.
}

Provided Methods

fn vec_from_array(array: [Self; N]) -> Vector<N, Self, Simd>

where Self: Scalar,

Overridable implementation of Vector::from_array.

fn vec_splat(value: Self) -> Vector<N, Self, Simd>

where Self: Scalar,

Overridable implementation of Vector::splat.

unsafe fn vec_swizzle2<const X_SRC: usize, const Y_SRC: usize>( vec: Vector<N, Self, Simd>, ) -> Vector<2, Self, Simd>

where Self: Scalar,

Overridable implementation of Vector::swizzle2.

unsafe fn vec_swizzle3<const X_SRC: usize, const Y_SRC: usize, const Z_SRC: usize>( vec: Vector<N, Self, Simd>, ) -> Vector<3, Self, Simd>

where Self: Scalar,

Overridable implementation of Vector::swizzle3.

unsafe fn vec_swizzle4<const X_SRC: usize, const Y_SRC: usize, const Z_SRC: usize, const W_SRC: usize>( vec: Vector<N, Self, Simd>, ) -> Vector<4, Self, Simd>

where Self: Scalar,

Overridable implementation of Vector::swizzle4.

fn vec_eq(vec: Vector<N, Self, Simd>, other: Vector<N, Self, Simd>) -> bool

where Self: Scalar + PartialEq,

Overridable implementation of Vector::eq.

fn vec_ne(vec: Vector<N, Self, Simd>, other: Vector<N, Self, Simd>) -> bool

where Self: Scalar + PartialEq,

Overridable implementation of Vector::ne.

fn vec_neg(vec: Vector<N, Self, Simd>) -> Vector<N, Self, Simd>

where Self: Scalar + Neg<Output = Self>,

Overridable implementation of Vector::neg.

Implementations may deviate from Self as Neg in edge cases, but should otherwise closely follow the behavior of Self as Neg.

fn vec_not(vec: Vector<N, Self, Simd>) -> Vector<N, Self, Simd>

where Self: Scalar + Not<Output = Self>,

Overridable implementation of Vector::not.

Implementations may deviate from Self as Not in edge cases, but should otherwise closely follow the behavior of Self as Not.

fn vec_add( vec: Vector<N, Self, Simd>, rhs: Vector<N, Self, Simd>, ) -> Vector<N, Self, Simd>

where Self: Scalar + Add<Output = Self>,

Overridable implementation of Vector::add.

Implementations may deviate from Self as Add in edge cases, but should otherwise closely follow the behavior of Self as Add.

fn vec_sub( vec: Vector<N, Self, Simd>, rhs: Vector<N, Self, Simd>, ) -> Vector<N, Self, Simd>

where Self: Scalar + Sub<Output = Self>,

Overridable implementation of Vector::sub.

Implementations may deviate from Self as Sub in edge cases, but should otherwise closely follow the behavior of Self as Sub.

fn vec_mul( vec: Vector<N, Self, Simd>, rhs: Vector<N, Self, Simd>, ) -> Vector<N, Self, Simd>

where Self: Scalar + Mul<Output = Self>,

Overridable implementation of Vector::mul.

Implementations may deviate from Self as Mul in edge cases, but should otherwise closely follow the behavior of Self as Mul.

fn vec_div( vec: Vector<N, Self, Simd>, rhs: Vector<N, Self, Simd>, ) -> Vector<N, Self, Simd>

where Self: Scalar + Div<Output = Self>,

Overridable implementation of Vector::div.

Implementations may deviate from Self as Div in edge cases, but should otherwise closely follow the behavior of Self as Div.

fn vec_rem( vec: Vector<N, Self, Simd>, rhs: Vector<N, Self, Simd>, ) -> Vector<N, Self, Simd>

where Self: Scalar + Rem<Output = Self>,

Overridable implementation of Vector::rem.

Implementations may deviate from Self as Rem in edge cases, but should otherwise closely follow the behavior of Self as Rem.

fn vec_shl( vec: Vector<N, Self, Simd>, rhs: Vector<N, Self, Simd>, ) -> Vector<N, Self, Simd>

where Self: Scalar + Shl<Output = Self>,

Overridable implementation of Vector::shl.

Implementations may deviate from Self as Shl in edge cases, but should otherwise closely follow the behavior of Self as Shl.

fn vec_shr( vec: Vector<N, Self, Simd>, rhs: Vector<N, Self, Simd>, ) -> Vector<N, Self, Simd>

where Self: Scalar + Shr<Output = Self>,

Overridable implementation of Vector::shr.

Implementations may deviate from Self as Shr in edge cases, but should otherwise closely follow the behavior of Self as Shr.

fn vec_bitand( vec: Vector<N, Self, Simd>, rhs: Vector<N, Self, Simd>, ) -> Vector<N, Self, Simd>

where Self: Scalar + BitAnd<Output = Self>,

Overridable implementation of Vector::bitand.

Implementations may deviate from Self as BitAnd in edge cases, but should otherwise closely follow the behavior of Self as BitAnd.

fn vec_bitor( vec: Vector<N, Self, Simd>, rhs: Vector<N, Self, Simd>, ) -> Vector<N, Self, Simd>

where Self: Scalar + BitOr<Output = Self>,

Overridable implementation of Vector::bitor.

Implementations may deviate from Self as BitOr in edge cases, but should otherwise closely follow the behavior of Self as BitOr.

fn vec_bitxor( vec: Vector<N, Self, Simd>, rhs: Vector<N, Self, Simd>, ) -> Vector<N, Self, Simd>

where Self: Scalar + BitXor<Output = Self>,

Overridable implementation of Vector::bitxor.

Implementations may deviate from Self as BitXor in edge cases, but should otherwise closely follow the behavior of Self as BitXor.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementations on Foreign Types

impl SimdBehaviour<2> for bool

type VectorRepr = [bool; 2]

impl SimdBehaviour<2> for f32

type VectorRepr = [f32; 2]

impl SimdBehaviour<2> for f64

type VectorRepr = [f64; 2]

impl SimdBehaviour<2> for i8

type VectorRepr = [i8; 2]

impl SimdBehaviour<2> for i16

type VectorRepr = [i16; 2]

impl SimdBehaviour<2> for i32

type VectorRepr = [i32; 2]

impl SimdBehaviour<2> for i64

type VectorRepr = [i64; 2]

impl SimdBehaviour<2> for i128

type VectorRepr = [i128; 2]

impl SimdBehaviour<2> for isize

type VectorRepr = [isize; 2]

impl SimdBehaviour<2> for u8

type VectorRepr = [u8; 2]

impl SimdBehaviour<2> for u16

type VectorRepr = [u16; 2]

impl SimdBehaviour<2> for u32

type VectorRepr = [u32; 2]

impl SimdBehaviour<2> for u64

type VectorRepr = [u64; 2]

impl SimdBehaviour<2> for u128

type VectorRepr = [u128; 2]

impl SimdBehaviour<2> for usize

type VectorRepr = [usize; 2]

impl SimdBehaviour<3> for bool

type VectorRepr = [bool; 3]

impl SimdBehaviour<3> for f32

type VectorRepr = __m128

fn vec_from_array(array: [Self; 3]) -> Vec3<Self>

fn vec_splat(value: Self) -> Vec3<Self>

unsafe fn vec_swizzle2<const X_SRC: usize, const Y_SRC: usize>( vec: Vec3<Self>, ) -> Vec2<Self>

unsafe fn vec_swizzle3<const X_SRC: usize, const Y_SRC: usize, const Z_SRC: usize>( vec: Vec3<Self>, ) -> Vec3<Self>

unsafe fn vec_swizzle4<const X_SRC: usize, const Y_SRC: usize, const Z_SRC: usize, const W_SRC: usize>( vec: Vec3<Self>, ) -> Vec4<Self>

fn vec_neg(vec: Vec3<Self>) -> Vec3<Self>

fn vec_add(vec: Vec3<Self>, rhs: Vec3<Self>) -> Vec3<Self>

fn vec_sub(vec: Vec3<Self>, rhs: Vec3<Self>) -> Vec3<Self>

fn vec_mul(vec: Vec3<Self>, rhs: Vec3<Self>) -> Vec3<Self>

fn vec_div(vec: Vec3<Self>, rhs: Vec3<Self>) -> Vec3<Self>

fn vec_rem(vec: Vec3<Self>, rhs: Vec3<Self>) -> Vec3<Self>

impl SimdBehaviour<3> for f64

type VectorRepr = [f64; 3]

impl SimdBehaviour<3> for i8

type VectorRepr = [i8; 3]

impl SimdBehaviour<3> for i16

type VectorRepr = [i16; 3]

impl SimdBehaviour<3> for i32

type VectorRepr = __m128i

fn vec_from_array(array: [Self; 3]) -> Vec3<Self>

fn vec_splat(value: Self) -> Vec3<Self>

unsafe fn vec_swizzle2<const X_SRC: usize, const Y_SRC: usize>( vec: Vec3<Self>, ) -> Vec2<Self>

unsafe fn vec_swizzle3<const X_SRC: usize, const Y_SRC: usize, const Z_SRC: usize>( vec: Vec3<Self>, ) -> Vec3<Self>

unsafe fn vec_swizzle4<const X_SRC: usize, const Y_SRC: usize, const Z_SRC: usize, const W_SRC: usize>( vec: Vec3<Self>, ) -> Vec4<Self>

fn vec_neg(vec: Vec3<Self>) -> Vec3<Self>

fn vec_not(vec: Vec3<Self>) -> Vec3<Self>

fn vec_add(vec: Vec3<Self>, rhs: Vec3<Self>) -> Vec3<Self>

fn vec_sub(vec: Vec3<Self>, rhs: Vec3<Self>) -> Vec3<Self>

fn vec_mul(vec: Vec3<Self>, rhs: Vec3<Self>) -> Vec3<Self>

fn vec_div(vec: Vec3<Self>, rhs: Vec3<Self>) -> Vec3<Self>

fn vec_rem(vec: Vec3<Self>, rhs: Vec3<Self>) -> Vec3<Self>

fn vec_shl(vec: Vec3<Self>, rhs: Vec3<Self>) -> Vec3<Self>

fn vec_shr(vec: Vec3<Self>, rhs: Vec3<Self>) -> Vec3<Self>

fn vec_bitand(vec: Vec3<Self>, rhs: Vec3<Self>) -> Vec3<Self>

fn vec_bitor(vec: Vec3<Self>, rhs: Vec3<Self>) -> Vec3<Self>

fn vec_bitxor(vec: Vec3<Self>, rhs: Vec3<Self>) -> Vec3<Self>

impl SimdBehaviour<3> for i64

type VectorRepr = [i64; 3]

impl SimdBehaviour<3> for i128

type VectorRepr = [i128; 3]

impl SimdBehaviour<3> for isize

type VectorRepr = [isize; 3]

impl SimdBehaviour<3> for u8

type VectorRepr = [u8; 3]

impl SimdBehaviour<3> for u16

type VectorRepr = [u16; 3]

impl SimdBehaviour<3> for u32

type VectorRepr = __m128i

fn vec_from_array(array: [Self; 3]) -> Vec3<Self>

fn vec_splat(value: Self) -> Vec3<Self>

unsafe fn vec_swizzle2<const X_SRC: usize, const Y_SRC: usize>( vec: Vec3<Self>, ) -> Vec2<Self>

unsafe fn vec_swizzle3<const X_SRC: usize, const Y_SRC: usize, const Z_SRC: usize>( vec: Vec3<Self>, ) -> Vec3<Self>

unsafe fn vec_swizzle4<const X_SRC: usize, const Y_SRC: usize, const Z_SRC: usize, const W_SRC: usize>( vec: Vec3<Self>, ) -> Vec4<Self>

fn vec_not(vec: Vec3<Self>) -> Vec3<Self>

fn vec_add(vec: Vec3<Self>, rhs: Vec3<Self>) -> Vec3<Self>

fn vec_sub(vec: Vec3<Self>, rhs: Vec3<Self>) -> Vec3<Self>

fn vec_mul(vec: Vec3<Self>, rhs: Vec3<Self>) -> Vec3<Self>

fn vec_div(vec: Vec3<Self>, rhs: Vec3<Self>) -> Vec3<Self>

fn vec_rem(vec: Vec3<Self>, rhs: Vec3<Self>) -> Vec3<Self>

fn vec_shl(vec: Vec3<Self>, rhs: Vec3<Self>) -> Vec3<Self>

fn vec_shr(vec: Vec3<Self>, rhs: Vec3<Self>) -> Vec3<Self>

fn vec_bitand(vec: Vec3<Self>, rhs: Vec3<Self>) -> Vec3<Self>

fn vec_bitor(vec: Vec3<Self>, rhs: Vec3<Self>) -> Vec3<Self>

fn vec_bitxor(vec: Vec3<Self>, rhs: Vec3<Self>) -> Vec3<Self>

impl SimdBehaviour<3> for u64

type VectorRepr = [u64; 3]

impl SimdBehaviour<3> for u128

type VectorRepr = [u128; 3]

impl SimdBehaviour<3> for usize

type VectorRepr = [usize; 3]

impl SimdBehaviour<4> for bool

type VectorRepr = [bool; 4]

impl SimdBehaviour<4> for f32

type VectorRepr = __m128

fn vec_from_array(array: [Self; 4]) -> Vec4<Self>

fn vec_splat(value: Self) -> Vec4<Self>

unsafe fn vec_swizzle2<const X_SRC: usize, const Y_SRC: usize>( vec: Vec4<Self>, ) -> Vec2<Self>

unsafe fn vec_swizzle3<const X_SRC: usize, const Y_SRC: usize, const Z_SRC: usize>( vec: Vec4<Self>, ) -> Vec3<Self>

unsafe fn vec_swizzle4<const X_SRC: usize, const Y_SRC: usize, const Z_SRC: usize, const W_SRC: usize>( vec: Vec4<Self>, ) -> Vec4<Self>

fn vec_neg(vec: Vec4<Self>) -> Vec4<Self>

fn vec_add(vec: Vec4<Self>, rhs: Vec4<Self>) -> Vec4<Self>

fn vec_sub(vec: Vec4<Self>, rhs: Vec4<Self>) -> Vec4<Self>

fn vec_mul(vec: Vec4<Self>, rhs: Vec4<Self>) -> Vec4<Self>

fn vec_div(vec: Vec4<Self>, rhs: Vec4<Self>) -> Vec4<Self>

fn vec_rem(vec: Vec4<Self>, rhs: Vec4<Self>) -> Vec4<Self>

impl SimdBehaviour<4> for f64

type VectorRepr = [f64; 4]

impl SimdBehaviour<4> for i8

type VectorRepr = [i8; 4]

impl SimdBehaviour<4> for i16

type VectorRepr = [i16; 4]

impl SimdBehaviour<4> for i32

type VectorRepr = __m128i

fn vec_from_array(array: [Self; 4]) -> Vec4<Self>

fn vec_splat(value: Self) -> Vec4<Self>

unsafe fn vec_swizzle2<const X_SRC: usize, const Y_SRC: usize>( vec: Vec4<Self>, ) -> Vec2<Self>

unsafe fn vec_swizzle3<const X_SRC: usize, const Y_SRC: usize, const Z_SRC: usize>( vec: Vec4<Self>, ) -> Vec3<Self>

unsafe fn vec_swizzle4<const X_SRC: usize, const Y_SRC: usize, const Z_SRC: usize, const W_SRC: usize>( vec: Vec4<Self>, ) -> Vec4<Self>

fn vec_neg(vec: Vec4<Self>) -> Vec4<Self>

fn vec_not(vec: Vec4<Self>) -> Vec4<Self>

fn vec_add(vec: Vec4<Self>, rhs: Vec4<Self>) -> Vec4<Self>

fn vec_sub(vec: Vec4<Self>, rhs: Vec4<Self>) -> Vec4<Self>

fn vec_mul(vec: Vec4<Self>, rhs: Vec4<Self>) -> Vec4<Self>

fn vec_div(vec: Vec4<Self>, rhs: Vec4<Self>) -> Vec4<Self>

fn vec_rem(vec: Vec4<Self>, rhs: Vec4<Self>) -> Vec4<Self>

fn vec_shl(vec: Vec4<Self>, rhs: Vec4<Self>) -> Vec4<Self>

fn vec_shr(vec: Vec4<Self>, rhs: Vec4<Self>) -> Vec4<Self>

fn vec_bitand(vec: Vec4<Self>, rhs: Vec4<Self>) -> Vec4<Self>

fn vec_bitor(vec: Vec4<Self>, rhs: Vec4<Self>) -> Vec4<Self>

fn vec_bitxor(vec: Vec4<Self>, rhs: Vec4<Self>) -> Vec4<Self>

impl SimdBehaviour<4> for i64

type VectorRepr = [i64; 4]

impl SimdBehaviour<4> for i128

type VectorRepr = [i128; 4]

impl SimdBehaviour<4> for isize

type VectorRepr = [isize; 4]

impl SimdBehaviour<4> for u8

type VectorRepr = [u8; 4]

impl SimdBehaviour<4> for u16

type VectorRepr = [u16; 4]

impl SimdBehaviour<4> for u32

type VectorRepr = __m128i

fn vec_from_array(array: [Self; 4]) -> Vec4<Self>

fn vec_splat(value: Self) -> Vec4<Self>

unsafe fn vec_swizzle2<const X_SRC: usize, const Y_SRC: usize>( vec: Vec4<Self>, ) -> Vec2<Self>

unsafe fn vec_swizzle3<const X_SRC: usize, const Y_SRC: usize, const Z_SRC: usize>( vec: Vec4<Self>, ) -> Vec3<Self>

unsafe fn vec_swizzle4<const X_SRC: usize, const Y_SRC: usize, const Z_SRC: usize, const W_SRC: usize>( vec: Vec4<Self>, ) -> Vec4<Self>

fn vec_not(vec: Vec4<Self>) -> Vec4<Self>

fn vec_add(vec: Vec4<Self>, rhs: Vec4<Self>) -> Vec4<Self>

fn vec_sub(vec: Vec4<Self>, rhs: Vec4<Self>) -> Vec4<Self>

fn vec_mul(vec: Vec4<Self>, rhs: Vec4<Self>) -> Vec4<Self>

fn vec_div(vec: Vec4<Self>, rhs: Vec4<Self>) -> Vec4<Self>

fn vec_rem(vec: Vec4<Self>, rhs: Vec4<Self>) -> Vec4<Self>

fn vec_shl(vec: Vec4<Self>, rhs: Vec4<Self>) -> Vec4<Self>

fn vec_shr(vec: Vec4<Self>, rhs: Vec4<Self>) -> Vec4<Self>

fn vec_bitand(vec: Vec4<Self>, rhs: Vec4<Self>) -> Vec4<Self>

fn vec_bitor(vec: Vec4<Self>, rhs: Vec4<Self>) -> Vec4<Self>

fn vec_bitxor(vec: Vec4<Self>, rhs: Vec4<Self>) -> Vec4<Self>

impl SimdBehaviour<4> for u64

type VectorRepr = [u64; 4]

impl SimdBehaviour<4> for u128

type VectorRepr = [u128; 4]

impl SimdBehaviour<4> for usize

type VectorRepr = [usize; 4]

impl<const N: usize, T: Scalar> SimdBehaviour<N> for Option<T>

where VecLen<N>: SupportedVecLen,

type VectorRepr = [Option<T>; N]

impl<const N: usize, T: Scalar> SimdBehaviour<N> for MaybeUninit<T>

where VecLen<N>: SupportedVecLen,

type VectorRepr = MaybeUninit<Vector<N, T, Simd>>

Implementors