Trait Simd 

pub trait Simd:
    'static
    + Sync
    + Send {
    type Vi8: SimdInt8<Scalar = i8> + SimdBaseIo;
    type Vi16: SimdInt16<Scalar = i16> + SimdBaseIo;
    type Vi32: SimdInt32<Engine = Self, Scalar = i32> + SimdBaseIo;
    type Vi64: SimdInt64<Engine = Self, Scalar = i64> + SimdBaseIo;
    type Vf32: SimdFloat32<Engine = Self, Scalar = f32> + SimdBaseIo;
    type Vf64: SimdFloat64<Engine = Self, Scalar = f64> + SimdBaseIo;

    const VF32_WIDTH: usize = <Self::Vf32>::WIDTH;
    const VF64_WIDTH: usize = <Self::Vf64>::WIDTH;
    const VI16_WIDTH: usize = <Self::Vi16>::WIDTH;
    const VI32_WIDTH: usize = <Self::Vi32>::WIDTH;
    const VI64_WIDTH: usize = <Self::Vi64>::WIDTH;

    // Required method
    fn invoke<R>(f: impl FnOnce() -> R) -> R;

    // Provided methods
    unsafe fn mul_ps(a: Self::Vf32, b: Self::Vf32) -> Self::Vf32 { ... }
    unsafe fn mul_pd(a: Self::Vf64, b: Self::Vf64) -> Self::Vf64 { ... }
    unsafe fn not_epi32(a: Self::Vi32) -> Self::Vi32 { ... }
    unsafe fn not_epi64(a: Self::Vi64) -> Self::Vi64 { ... }
    unsafe fn or_epi32(a: Self::Vi32, b: Self::Vi32) -> Self::Vi32 { ... }
    unsafe fn or_epi64(a: Self::Vi64, b: Self::Vi64) -> Self::Vi64 { ... }
    unsafe fn or_ps(a: Self::Vf32, b: Self::Vf32) -> Self::Vf32 { ... }
    unsafe fn or_pd(a: Self::Vf64, b: Self::Vf64) -> Self::Vf64 { ... }
    unsafe fn xor_epi32(a: Self::Vi32, b: Self::Vi32) -> Self::Vi32 { ... }
    unsafe fn xor_epi64(a: Self::Vi64, b: Self::Vi64) -> Self::Vi64 { ... }
    unsafe fn xor_ps(a: Self::Vf32, b: Self::Vf32) -> Self::Vf32 { ... }
    unsafe fn xor_pd(a: Self::Vf64, b: Self::Vf64) -> Self::Vf64 { ... }
    unsafe fn slli_epi32(a: Self::Vi32, amt_const: i32) -> Self::Vi32 { ... }
    unsafe fn srai_epi32(a: Self::Vi32, amt_const: i32) -> Self::Vi32 { ... }
    unsafe fn div_ps(a: Self::Vf32, b: Self::Vf32) -> Self::Vf32 { ... }
    unsafe fn div_pd(a: Self::Vf64, b: Self::Vf64) -> Self::Vf64 { ... }
    unsafe fn add_epi16(a: Self::Vi16, b: Self::Vi16) -> Self::Vi16 { ... }
    unsafe fn sub_epi16(a: Self::Vi16, b: Self::Vi16) -> Self::Vi16 { ... }
    unsafe fn add_epi32(a: Self::Vi32, b: Self::Vi32) -> Self::Vi32 { ... }
    unsafe fn add_epi64(a: Self::Vi64, b: Self::Vi64) -> Self::Vi64 { ... }
    unsafe fn add_ps(a: Self::Vf32, b: Self::Vf32) -> Self::Vf32 { ... }
    unsafe fn add_pd(a: Self::Vf64, b: Self::Vf64) -> Self::Vf64 { ... }
    unsafe fn and_epi32(a: Self::Vi32, b: Self::Vi32) -> Self::Vi32 { ... }
    unsafe fn and_epi64(a: Self::Vi64, b: Self::Vi64) -> Self::Vi64 { ... }
    unsafe fn and_ps(a: Self::Vf32, b: Self::Vf32) -> Self::Vf32 { ... }
    unsafe fn and_pd(a: Self::Vf64, b: Self::Vf64) -> Self::Vf64 { ... }
    unsafe fn abs_ps(a: Self::Vf32) -> Self::Vf32 { ... }
    unsafe fn abs_pd(a: Self::Vf64) -> Self::Vf64 { ... }
    unsafe fn mullo_epi32(a: Self::Vi32, b: Self::Vi32) -> Self::Vi32 { ... }
    unsafe fn mullo_epi64(a: Self::Vi64, b: Self::Vi64) -> Self::Vi64 { ... }
    unsafe fn mullo_epi16(a: Self::Vi16, b: Self::Vi16) -> Self::Vi16 { ... }
    unsafe fn andnot_ps(a: Self::Vf32, b: Self::Vf32) -> Self::Vf32 { ... }
    unsafe fn andnot_pd(a: Self::Vf64, b: Self::Vf64) -> Self::Vf64 { ... }
    unsafe fn andnot_epi32(a: Self::Vi32, b: Self::Vi32) -> Self::Vi32 { ... }
    unsafe fn andnot_epi64(a: Self::Vi64, b: Self::Vi64) -> Self::Vi64 { ... }
    unsafe fn blendv_epi32(
        a: Self::Vi32,
        b: Self::Vi32,
        mask: Self::Vi32,
    ) -> Self::Vi32 { ... }
    unsafe fn blendv_epi64(
        a: Self::Vi64,
        b: Self::Vi64,
        mask: Self::Vi64,
    ) -> Self::Vi64 { ... }
    unsafe fn blendv_ps(
        a: Self::Vf32,
        b: Self::Vf32,
        mask: Self::Vf32,
    ) -> Self::Vf32 { ... }
    unsafe fn blendv_pd(
        a: Self::Vf64,
        b: Self::Vf64,
        mask: Self::Vf64,
    ) -> Self::Vf64 { ... }
    unsafe fn castps_epi32(a: Self::Vf32) -> Self::Vi32 { ... }
    unsafe fn castpd_epi64(a: Self::Vf64) -> Self::Vi64 { ... }
    unsafe fn castepi32_ps(a: Self::Vi32) -> Self::Vf32 { ... }
    unsafe fn castepi64_pd(a: Self::Vi64) -> Self::Vf64 { ... }
    unsafe fn castps_pd(_a: Self::Vf32) -> Self::Vf64 { ... }
    unsafe fn castpd_ps(_a: Self::Vf64) -> Self::Vf32 { ... }
    unsafe fn cvtps_epi32(a: Self::Vf32) -> Self::Vi32 { ... }
    unsafe fn cvtpd_epi64(a: Self::Vf64) -> Self::Vi64 { ... }
    unsafe fn cvtepi32_ps(a: Self::Vi32) -> Self::Vf32 { ... }
    unsafe fn cvtepi64_pd(a: Self::Vi64) -> Self::Vf64 { ... }
    unsafe fn cmpeq_epi64(a: Self::Vi64, b: Self::Vi64) -> Self::Vi64 { ... }
    unsafe fn cmpneq_epi64(a: Self::Vi64, b: Self::Vi64) -> Self::Vi64 { ... }
    unsafe fn cmpge_epi64(a: Self::Vi64, b: Self::Vi64) -> Self::Vi64 { ... }
    unsafe fn cmpgt_epi64(a: Self::Vi64, b: Self::Vi64) -> Self::Vi64 { ... }
    unsafe fn cmple_epi64(a: Self::Vi64, b: Self::Vi64) -> Self::Vi64 { ... }
    unsafe fn cmplt_epi64(a: Self::Vi64, b: Self::Vi64) -> Self::Vi64 { ... }
    unsafe fn cmpeq_epi32(a: Self::Vi32, b: Self::Vi32) -> Self::Vi32 { ... }
    unsafe fn cmpneq_epi32(a: Self::Vi32, b: Self::Vi32) -> Self::Vi32 { ... }
    unsafe fn cmpge_epi32(a: Self::Vi32, b: Self::Vi32) -> Self::Vi32 { ... }
    unsafe fn cmpgt_epi32(a: Self::Vi32, b: Self::Vi32) -> Self::Vi32 { ... }
    unsafe fn cmple_epi32(a: Self::Vi32, b: Self::Vi32) -> Self::Vi32 { ... }
    unsafe fn cmplt_epi32(a: Self::Vi32, b: Self::Vi32) -> Self::Vi32 { ... }
    unsafe fn cmpeq_ps(a: Self::Vf32, b: Self::Vf32) -> Self::Vf32 { ... }
    unsafe fn cmpneq_ps(a: Self::Vf32, b: Self::Vf32) -> Self::Vf32 { ... }
    unsafe fn cmpge_ps(a: Self::Vf32, b: Self::Vf32) -> Self::Vf32 { ... }
    unsafe fn cmpgt_ps(a: Self::Vf32, b: Self::Vf32) -> Self::Vf32 { ... }
    unsafe fn cmple_ps(a: Self::Vf32, b: Self::Vf32) -> Self::Vf32 { ... }
    unsafe fn cmplt_ps(a: Self::Vf32, b: Self::Vf32) -> Self::Vf32 { ... }
    unsafe fn cmpeq_pd(a: Self::Vf64, b: Self::Vf64) -> Self::Vf64 { ... }
    unsafe fn cmpneq_pd(a: Self::Vf64, b: Self::Vf64) -> Self::Vf64 { ... }
    unsafe fn cmpge_pd(a: Self::Vf64, b: Self::Vf64) -> Self::Vf64 { ... }
    unsafe fn cmpgt_pd(a: Self::Vf64, b: Self::Vf64) -> Self::Vf64 { ... }
    unsafe fn cmple_pd(a: Self::Vf64, b: Self::Vf64) -> Self::Vf64 { ... }
    unsafe fn cmplt_pd(a: Self::Vf64, b: Self::Vf64) -> Self::Vf64 { ... }
    unsafe fn ceil_ps(a: Self::Vf32) -> Self::Vf32 { ... }
    unsafe fn ceil_pd(a: Self::Vf64) -> Self::Vf64 { ... }
    unsafe fn floor_ps(a: Self::Vf32) -> Self::Vf32 { ... }
    unsafe fn floor_pd(a: Self::Vf64) -> Self::Vf64 { ... }
    unsafe fn fast_round_ps(a: Self::Vf32) -> Self::Vf32 { ... }
    unsafe fn fast_ceil_ps(a: Self::Vf32) -> Self::Vf32 { ... }
    unsafe fn fast_floor_ps(a: Self::Vf32) -> Self::Vf32 { ... }
    unsafe fn fast_floor_pd(a: Self::Vf64) -> Self::Vf64 { ... }
    unsafe fn fmadd_ps(
        a: Self::Vf32,
        b: Self::Vf32,
        c: Self::Vf32,
    ) -> Self::Vf32 { ... }
    unsafe fn fnmadd_ps(
        a: Self::Vf32,
        b: Self::Vf32,
        c: Self::Vf32,
    ) -> Self::Vf32 { ... }
    unsafe fn fmadd_pd(
        a: Self::Vf64,
        b: Self::Vf64,
        c: Self::Vf64,
    ) -> Self::Vf64 { ... }
    unsafe fn fnmadd_pd(
        a: Self::Vf64,
        b: Self::Vf64,
        c: Self::Vf64,
    ) -> Self::Vf64 { ... }
    unsafe fn fmsub_ps(
        a: Self::Vf32,
        b: Self::Vf32,
        c: Self::Vf32,
    ) -> Self::Vf32 { ... }
    unsafe fn fnmsub_ps(
        a: Self::Vf32,
        b: Self::Vf32,
        c: Self::Vf32,
    ) -> Self::Vf32 { ... }
    unsafe fn fmsub_pd(
        a: Self::Vf64,
        b: Self::Vf64,
        c: Self::Vf64,
    ) -> Self::Vf64 { ... }
    unsafe fn fnmsub_pd(
        a: Self::Vf64,
        b: Self::Vf64,
        c: Self::Vf64,
    ) -> Self::Vf64 { ... }
    unsafe fn horizontal_add_ps(a: Self::Vf32) -> f32 { ... }
    unsafe fn horizontal_add_pd(a: Self::Vf64) -> f64 { ... }
    unsafe fn i32gather_epi32(_arr: &[i32], _index: Self::Vi32) -> Self::Vi32 { ... }
    unsafe fn i64gather_epi64(_arr: &[i64], _index: Self::Vi64) -> Self::Vi64 { ... }
    unsafe fn i32gather_ps(_arr: &[f32], _index: Self::Vi32) -> Self::Vf32 { ... }
    unsafe fn load_ps(a: &f32) -> Self::Vf32 { ... }
    unsafe fn load_pd(a: &f64) -> Self::Vf64 { ... }
    unsafe fn load_epi16(a: &i16) -> Self::Vi16 { ... }
    unsafe fn load_epi32(a: &i32) -> Self::Vi32 { ... }
    unsafe fn load_epi64(a: &i64) -> Self::Vi64 { ... }
    unsafe fn loadu_ps(a: &f32) -> Self::Vf32 { ... }
    unsafe fn loadu_pd(a: &f64) -> Self::Vf64 { ... }
    unsafe fn loadu_epi32(a: &i32) -> Self::Vi32 { ... }
    unsafe fn loadu_epi64(a: &i64) -> Self::Vi64 { ... }
    unsafe fn maskload_epi32(_mem_addr: &i32, _mask: Self::Vi32) -> Self::Vi32 { ... }
    unsafe fn maskload_epi64(_mem_addr: &i64, _mask: Self::Vi64) -> Self::Vi64 { ... }
    unsafe fn maskload_ps(_mem_addr: &f32, _mask: Self::Vi32) -> Self::Vf32 { ... }
    unsafe fn maskload_pd(_mem_addr: &f64, _mask: Self::Vi64) -> Self::Vf64 { ... }
    unsafe fn store_ps(mem_addr: &mut f32, a: Self::Vf32) { ... }
    unsafe fn store_pd(mem_addr: &mut f64, a: Self::Vf64) { ... }
    unsafe fn store_epi32(mem_addr: &mut i32, a: Self::Vi32) { ... }
    unsafe fn store_epi64(mem_addr: &mut i64, a: Self::Vi64) { ... }
    unsafe fn storeu_ps(mem_addr: &mut f32, a: Self::Vf32) { ... }
    unsafe fn storeu_pd(mem_addr: &mut f64, a: Self::Vf64) { ... }
    unsafe fn storeu_epi32(mem_addr: &mut i32, a: Self::Vi32) { ... }
    unsafe fn storeu_epi64(mem_addr: &mut i64, a: Self::Vi64) { ... }
    unsafe fn maskstore_epi32(
        mem_addr: &mut i32,
        mask: Self::Vi32,
        a: Self::Vi32,
    ) { ... }
    unsafe fn maskstore_epi64(
        mem_addr: &mut i64,
        mask: Self::Vi64,
        a: Self::Vi64,
    ) { ... }
    unsafe fn maskstore_ps(mem_addr: &mut f32, mask: Self::Vi32, a: Self::Vf32) { ... }
    unsafe fn maskstore_pd(mem_addr: &mut f64, mask: Self::Vi64, a: Self::Vf64) { ... }
    unsafe fn max_epi32(a: Self::Vi32, b: Self::Vi32) -> Self::Vi32 { ... }
    unsafe fn min_epi32(a: Self::Vi32, b: Self::Vi32) -> Self::Vi32 { ... }
    unsafe fn max_ps(a: Self::Vf32, b: Self::Vf32) -> Self::Vf32 { ... }
    unsafe fn min_ps(a: Self::Vf32, b: Self::Vf32) -> Self::Vf32 { ... }
    unsafe fn max_pd(a: Self::Vf64, b: Self::Vf64) -> Self::Vf64 { ... }
    unsafe fn min_pd(a: Self::Vf64, b: Self::Vf64) -> Self::Vf64 { ... }
    unsafe fn rcp_ps(a: Self::Vf32) -> Self::Vf32 { ... }
    unsafe fn round_ps(a: Self::Vf32) -> Self::Vf32 { ... }
    unsafe fn round_pd(a: Self::Vf64) -> Self::Vf64 { ... }
    unsafe fn set1_epi32(a: i32) -> Self::Vi32 { ... }
    unsafe fn set1_epi64(a: i64) -> Self::Vi64 { ... }
    unsafe fn set1_ps(a: f32) -> Self::Vf32 { ... }
    unsafe fn set1_pd(a: f64) -> Self::Vf64 { ... }
    unsafe fn setzero_ps() -> Self::Vf32 { ... }
    unsafe fn setzero_pd() -> Self::Vf64 { ... }
    unsafe fn setzero_epi32() -> Self::Vi32 { ... }
    unsafe fn setzero_epi64() -> Self::Vi64 { ... }
    unsafe fn srai_epi64(a: Self::Vi64, amt_const: i32) -> Self::Vi64 { ... }
    unsafe fn srli_epi32(a: Self::Vi32, amt_const: i32) -> Self::Vi32 { ... }
    unsafe fn sra_epi32(a: Self::Vi32, amt: i32) -> Self::Vi32 { ... }
    unsafe fn srl_epi32(a: Self::Vi32, amt: i32) -> Self::Vi32 { ... }
    unsafe fn sll_epi32(a: Self::Vi32, amt: i32) -> Self::Vi32 { ... }
    unsafe fn sub_epi32(a: Self::Vi32, b: Self::Vi32) -> Self::Vi32 { ... }
    unsafe fn sub_epi64(a: Self::Vi64, b: Self::Vi64) -> Self::Vi64 { ... }
    unsafe fn sub_ps(a: Self::Vf32, b: Self::Vf32) -> Self::Vf32 { ... }
    unsafe fn sub_pd(a: Self::Vf64, b: Self::Vf64) -> Self::Vf64 { ... }
    unsafe fn sqrt_ps(a: Self::Vf32) -> Self::Vf32 { ... }
    unsafe fn rsqrt_ps(a: Self::Vf32) -> Self::Vf32 { ... }
    unsafe fn sqrt_pd(a: Self::Vf64) -> Self::Vf64 { ... }
    unsafe fn rsqrt_pd(a: Self::Vf64) -> Self::Vf64 { ... }
    unsafe fn shuffle_epi32<const IMM8: i32>(_a: Self::Vi32) -> Self::Vi32 { ... }
}

The abstract SIMD trait which is implemented by Avx2, Sse41, etc

Provided Associated Constants

const VF32_WIDTH: usize = <Self::Vf32>::WIDTH

👎Deprecated: The VF32_WIDTH is deprecated, please use the Vf32::WIDTH instead.

const VF64_WIDTH: usize = <Self::Vf64>::WIDTH

👎Deprecated: The VF64_WIDTH is deprecated, please use the Vf64::WIDTH instead.

const VI16_WIDTH: usize = <Self::Vi16>::WIDTH

👎Deprecated: The VI16_WIDTH is deprecated, please use the Vi16::WIDTH instead.

const VI32_WIDTH: usize = <Self::Vi32>::WIDTH

👎Deprecated: The VI32_WIDTH is deprecated, please use the Vi32::WIDTH instead.

const VI64_WIDTH: usize = <Self::Vi64>::WIDTH

👎Deprecated: The VI64_WIDTH is deprecated, please use the Vi64::WIDTH instead.

Required Associated Types

type Vi8: SimdInt8<Scalar = i8> + SimdBaseIo

Vector of i8s. Corresponds to __m128i when used with the Sse impl, __m256i when used with Avx2, or a single i8 when used with Scalar.

type Vi16: SimdInt16<Scalar = i16> + SimdBaseIo

Vector of i16s. Corresponds to __m128i when used with the Sse impl, __m256i when used with Avx2, or a single i16 when used with Scalar.

type Vi32: SimdInt32<Engine = Self, Scalar = i32> + SimdBaseIo

Vector of i32s. Corresponds to __m128i when used with the Sse impl, __m256i when used with Avx2, or a single i32 when used with Scalar.

type Vi64: SimdInt64<Engine = Self, Scalar = i64> + SimdBaseIo

Vector of i64s. Corresponds to __m128i when used with the Sse impl, __m256i when used with Avx2, or a single i64 when used with Scalar.

type Vf32: SimdFloat32<Engine = Self, Scalar = f32> + SimdBaseIo

Vector of f32s. Corresponds to __m128 when used with the Sse impl, __m256 when used with Avx2, or a single f32 when used with Scalar.

type Vf64: SimdFloat64<Engine = Self, Scalar = f64> + SimdBaseIo

Vector of f64s. Corresponds to __m128d when used with the Sse impl, __m256d when used with Avx2, or a single f64 when used with Scalar.

Required Methods

fn invoke<R>(f: impl FnOnce() -> R) -> R

Provided Methods

unsafe fn mul_ps(a: Self::Vf32, b: Self::Vf32) -> Self::Vf32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn mul_pd(a: Self::Vf64, b: Self::Vf64) -> Self::Vf64

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn not_epi32(a: Self::Vi32) -> Self::Vi32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn not_epi64(a: Self::Vi64) -> Self::Vi64

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn or_epi32(a: Self::Vi32, b: Self::Vi32) -> Self::Vi32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn or_epi64(a: Self::Vi64, b: Self::Vi64) -> Self::Vi64

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn or_ps(a: Self::Vf32, b: Self::Vf32) -> Self::Vf32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn or_pd(a: Self::Vf64, b: Self::Vf64) -> Self::Vf64

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn xor_epi32(a: Self::Vi32, b: Self::Vi32) -> Self::Vi32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn xor_epi64(a: Self::Vi64, b: Self::Vi64) -> Self::Vi64

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn xor_ps(a: Self::Vf32, b: Self::Vf32) -> Self::Vf32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn xor_pd(a: Self::Vf64, b: Self::Vf64) -> Self::Vf64

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn slli_epi32(a: Self::Vi32, amt_const: i32) -> Self::Vi32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

amt must be a constant

unsafe fn srai_epi32(a: Self::Vi32, amt_const: i32) -> Self::Vi32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

amt must be a constant

unsafe fn div_ps(a: Self::Vf32, b: Self::Vf32) -> Self::Vf32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn div_pd(a: Self::Vf64, b: Self::Vf64) -> Self::Vf64

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn add_epi16(a: Self::Vi16, b: Self::Vi16) -> Self::Vi16

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn sub_epi16(a: Self::Vi16, b: Self::Vi16) -> Self::Vi16

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn add_epi32(a: Self::Vi32, b: Self::Vi32) -> Self::Vi32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn add_epi64(a: Self::Vi64, b: Self::Vi64) -> Self::Vi64

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn add_ps(a: Self::Vf32, b: Self::Vf32) -> Self::Vf32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn add_pd(a: Self::Vf64, b: Self::Vf64) -> Self::Vf64

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn and_epi32(a: Self::Vi32, b: Self::Vi32) -> Self::Vi32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn and_epi64(a: Self::Vi64, b: Self::Vi64) -> Self::Vi64

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn and_ps(a: Self::Vf32, b: Self::Vf32) -> Self::Vf32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn and_pd(a: Self::Vf64, b: Self::Vf64) -> Self::Vf64

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn abs_ps(a: Self::Vf32) -> Self::Vf32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn abs_pd(a: Self::Vf64) -> Self::Vf64

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn mullo_epi32(a: Self::Vi32, b: Self::Vi32) -> Self::Vi32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn mullo_epi64(a: Self::Vi64, b: Self::Vi64) -> Self::Vi64

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn mullo_epi16(a: Self::Vi16, b: Self::Vi16) -> Self::Vi16

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn andnot_ps(a: Self::Vf32, b: Self::Vf32) -> Self::Vf32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn andnot_pd(a: Self::Vf64, b: Self::Vf64) -> Self::Vf64

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn andnot_epi32(a: Self::Vi32, b: Self::Vi32) -> Self::Vi32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn andnot_epi64(a: Self::Vi64, b: Self::Vi64) -> Self::Vi64

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn blendv_epi32( a: Self::Vi32, b: Self::Vi32, mask: Self::Vi32, ) -> Self::Vi32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

Note SSE2 will select B only when all bits are 1, while SSE41 and AVX2 only check the high bit. To maintain portability ensure all bits are 1 when using blend. Results of comparison operations adhere to this.

unsafe fn blendv_epi64( a: Self::Vi64, b: Self::Vi64, mask: Self::Vi64, ) -> Self::Vi64

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

Note SSE2 will select B only when all bits are 1, while SSE41 and AVX2 only check the high bit. To maintain portability ensure all bits are 1 when using blend. Results of comparison operations adhere to this.

unsafe fn blendv_ps( a: Self::Vf32, b: Self::Vf32, mask: Self::Vf32, ) -> Self::Vf32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

Note SSE2 will select B only when all bits are 1, while SSE41 and AVX2 only check the high bit. To maintain portability ensure all bits are 1 when using blend. Results of comparison operations adhere to this.

unsafe fn blendv_pd( a: Self::Vf64, b: Self::Vf64, mask: Self::Vf64, ) -> Self::Vf64

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

Note SSE2 will select B only when all bits are 1, while SSE41 and AVX2 only check the high bit. To maintain portability ensure all bits are 1 when using blend. Results of comparison operations adhere to this.

unsafe fn castps_epi32(a: Self::Vf32) -> Self::Vi32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn castpd_epi64(a: Self::Vf64) -> Self::Vi64

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn castepi32_ps(a: Self::Vi32) -> Self::Vf32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn castepi64_pd(a: Self::Vi64) -> Self::Vf64

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn castps_pd(_a: Self::Vf32) -> Self::Vf64

👎Deprecated: These functions have unpredictable behavior and will be deleted in the future. Please use a manual implementation instead.

Converts the type of a f32 vector to a f64 vector without changing the underlying bits.

unsafe fn castpd_ps(_a: Self::Vf64) -> Self::Vf32

👎Deprecated: These functions have unpredictable behavior and will be deleted in the future. Please use a manual implementation instead.

Converts the type of a f64 vector to a f32 vector without changing the underlying bits.

unsafe fn cvtps_epi32(a: Self::Vf32) -> Self::Vi32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

Currently scalar will have different results in some cases depending on the current SSE rounding mode.

unsafe fn cvtpd_epi64(a: Self::Vf64) -> Self::Vi64

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn cvtepi32_ps(a: Self::Vi32) -> Self::Vf32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn cvtepi64_pd(a: Self::Vi64) -> Self::Vf64

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn cmpeq_epi64(a: Self::Vi64, b: Self::Vi64) -> Self::Vi64

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn cmpneq_epi64(a: Self::Vi64, b: Self::Vi64) -> Self::Vi64

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn cmpge_epi64(a: Self::Vi64, b: Self::Vi64) -> Self::Vi64

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn cmpgt_epi64(a: Self::Vi64, b: Self::Vi64) -> Self::Vi64

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn cmple_epi64(a: Self::Vi64, b: Self::Vi64) -> Self::Vi64

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn cmplt_epi64(a: Self::Vi64, b: Self::Vi64) -> Self::Vi64

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn cmpeq_epi32(a: Self::Vi32, b: Self::Vi32) -> Self::Vi32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn cmpneq_epi32(a: Self::Vi32, b: Self::Vi32) -> Self::Vi32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn cmpge_epi32(a: Self::Vi32, b: Self::Vi32) -> Self::Vi32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn cmpgt_epi32(a: Self::Vi32, b: Self::Vi32) -> Self::Vi32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn cmple_epi32(a: Self::Vi32, b: Self::Vi32) -> Self::Vi32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn cmplt_epi32(a: Self::Vi32, b: Self::Vi32) -> Self::Vi32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn cmpeq_ps(a: Self::Vf32, b: Self::Vf32) -> Self::Vf32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn cmpneq_ps(a: Self::Vf32, b: Self::Vf32) -> Self::Vf32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn cmpge_ps(a: Self::Vf32, b: Self::Vf32) -> Self::Vf32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn cmpgt_ps(a: Self::Vf32, b: Self::Vf32) -> Self::Vf32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn cmple_ps(a: Self::Vf32, b: Self::Vf32) -> Self::Vf32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn cmplt_ps(a: Self::Vf32, b: Self::Vf32) -> Self::Vf32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn cmpeq_pd(a: Self::Vf64, b: Self::Vf64) -> Self::Vf64

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn cmpneq_pd(a: Self::Vf64, b: Self::Vf64) -> Self::Vf64

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn cmpge_pd(a: Self::Vf64, b: Self::Vf64) -> Self::Vf64

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn cmpgt_pd(a: Self::Vf64, b: Self::Vf64) -> Self::Vf64

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn cmple_pd(a: Self::Vf64, b: Self::Vf64) -> Self::Vf64

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn cmplt_pd(a: Self::Vf64, b: Self::Vf64) -> Self::Vf64

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn ceil_ps(a: Self::Vf32) -> Self::Vf32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn ceil_pd(a: Self::Vf64) -> Self::Vf64

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn floor_ps(a: Self::Vf32) -> Self::Vf32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn floor_pd(a: Self::Vf64) -> Self::Vf64

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn fast_round_ps(a: Self::Vf32) -> Self::Vf32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

When using Sse2, fastround uses a faster version of floor that only works on floating point values small enough to fit in an i32. This is a big performance boost if you don’t need a complete floor.

unsafe fn fast_ceil_ps(a: Self::Vf32) -> Self::Vf32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

When using Sse2, fastceil uses a faster version of floor that only works on floating point values small enough to fit in an i32. This is a big performance boost if you don’t need a complete floor.

unsafe fn fast_floor_ps(a: Self::Vf32) -> Self::Vf32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

When using Sse2, fastfloor uses a faster version of floor that only works on floating point values small enough to fit in an i32. This is a big performance boost if you don’t need a complete floor.

unsafe fn fast_floor_pd(a: Self::Vf64) -> Self::Vf64

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn fmadd_ps(a: Self::Vf32, b: Self::Vf32, c: Self::Vf32) -> Self::Vf32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

Actual FMA instructions will be used when Avx2 is used, otherwise a mul and add are used to replicate it, allowing you to just always use FMA in your code and get best perf in both cases.

unsafe fn fnmadd_ps(a: Self::Vf32, b: Self::Vf32, c: Self::Vf32) -> Self::Vf32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

Actual FMA instructions will be used when Avx2 is used, otherwise a mul and add are used to replicate it, allowing you to just always use FMA in your code and get best perf in both cases.

unsafe fn fmadd_pd(a: Self::Vf64, b: Self::Vf64, c: Self::Vf64) -> Self::Vf64

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

Actual FMA instructions will be used when Avx2 is used, otherwise a mul and add are used to replicate it, allowing you to just always use FMA in your code and get best perf in both cases.

unsafe fn fnmadd_pd(a: Self::Vf64, b: Self::Vf64, c: Self::Vf64) -> Self::Vf64

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

Actual FMA instructions will be used when Avx2 is used, otherwise a mul and add are used to replicate it, allowing you to just always use FMA in your code and get best perf in both cases.

unsafe fn fmsub_ps(a: Self::Vf32, b: Self::Vf32, c: Self::Vf32) -> Self::Vf32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

Actual FMA instructions will be used when Avx2 is used, otherwise a mul and sub are used to replicate it, allowing you to just always use FMA in your code and get best perf in both cases.

unsafe fn fnmsub_ps(a: Self::Vf32, b: Self::Vf32, c: Self::Vf32) -> Self::Vf32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

Actual FMA instructions will be used when Avx2 is used, otherwise a mul and sub are used to replicate it, allowing you to just always use FMA in your code and get best perf in both cases.

unsafe fn fmsub_pd(a: Self::Vf64, b: Self::Vf64, c: Self::Vf64) -> Self::Vf64

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

Actual FMA instructions will be used when Avx2 is used, otherwise a mul and sub are used to replicate it, allowing you to just always use FMA in your code and get best perf in both cases.

unsafe fn fnmsub_pd(a: Self::Vf64, b: Self::Vf64, c: Self::Vf64) -> Self::Vf64

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

Actual FMA instructions will be used when Avx2 is used, otherwise a mul and sub are used to replicate it, allowing you to just always use FMA in your code and get best perf in both cases.

unsafe fn horizontal_add_ps(a: Self::Vf32) -> f32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

Adds all lanes together. Distinct from h_add which adds pairs.

unsafe fn horizontal_add_pd(a: Self::Vf64) -> f64

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

Adds all lanes together. Distinct from h_add which adds pairs.

unsafe fn i32gather_epi32(_arr: &[i32], _index: Self::Vi32) -> Self::Vi32

👎Deprecated: These functions have unpredictable behavior and will be deleted in the future. Please use a manual implementation instead.

Sse2 and Sse41 paths will simulate a gather by breaking out and doing scalar array accesses, because gather doesn’t exist until Avx2.

unsafe fn i64gather_epi64(_arr: &[i64], _index: Self::Vi64) -> Self::Vi64

👎Deprecated: These functions have unpredictable behavior and will be deleted in the future. Please use a manual implementation instead.

unsafe fn i32gather_ps(_arr: &[f32], _index: Self::Vi32) -> Self::Vf32

👎Deprecated: These functions have unpredictable behavior and will be deleted in the future. Please use a manual implementation instead.

Sse2 and Sse41 paths will simulate a gather by breaking out and doing scalar array accesses, because gather doesn’t exist until Avx2.

unsafe fn load_ps(a: &f32) -> Self::Vf32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn load_pd(a: &f64) -> Self::Vf64

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn load_epi16(a: &i16) -> Self::Vi16

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn load_epi32(a: &i32) -> Self::Vi32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn load_epi64(a: &i64) -> Self::Vi64

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn loadu_ps(a: &f32) -> Self::Vf32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn loadu_pd(a: &f64) -> Self::Vf64

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn loadu_epi32(a: &i32) -> Self::Vi32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn loadu_epi64(a: &i64) -> Self::Vi64

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn maskload_epi32(_mem_addr: &i32, _mask: Self::Vi32) -> Self::Vi32

👎Deprecated: These functions have unpredictable behavior and will be deleted in the future. Please use a manual implementation instead.

Note, SSE2 and SSE4 will load when mask[i] is nonzero, where AVX2 will store only when the high bit is set. To ensure portability ensure that the high bit is set.

unsafe fn maskload_epi64(_mem_addr: &i64, _mask: Self::Vi64) -> Self::Vi64

👎Deprecated: These functions have unpredictable behavior and will be deleted in the future. Please use a manual implementation instead.

Note, SSE2 and SSE4 will load when mask[i] is nonzero, where AVX2 will store only when the high bit is set. To ensure portability ensure that the high bit is set.

unsafe fn maskload_ps(_mem_addr: &f32, _mask: Self::Vi32) -> Self::Vf32

👎Deprecated: These functions have unpredictable behavior and will be deleted in the future. Please use a manual implementation instead.

Note, SSE2 and SSE4 will load when mask[i] is nonzero, where AVX2 will store only when the high bit is set. To ensure portability ensure that the high bit is set.

unsafe fn maskload_pd(_mem_addr: &f64, _mask: Self::Vi64) -> Self::Vf64

👎Deprecated: These functions have unpredictable behavior and will be deleted in the future. Please use a manual implementation instead.

Note, SSE2 and SSE4 will load when mask[i] is nonzero, where AVX2 will store only when the high bit is set. To ensure portability ensure that the high bit is set.

unsafe fn store_ps(mem_addr: &mut f32, a: Self::Vf32)

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn store_pd(mem_addr: &mut f64, a: Self::Vf64)

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn store_epi32(mem_addr: &mut i32, a: Self::Vi32)

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn store_epi64(mem_addr: &mut i64, a: Self::Vi64)

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn storeu_ps(mem_addr: &mut f32, a: Self::Vf32)

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn storeu_pd(mem_addr: &mut f64, a: Self::Vf64)

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn storeu_epi32(mem_addr: &mut i32, a: Self::Vi32)

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn storeu_epi64(mem_addr: &mut i64, a: Self::Vi64)

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn maskstore_epi32(mem_addr: &mut i32, mask: Self::Vi32, a: Self::Vi32)

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

Note, SSE2 and SSE4 will store when mask[i] is nonzero, where AVX2 will store only when the high bit is set. To ensure portability ensure the high bit is set.

unsafe fn maskstore_epi64(mem_addr: &mut i64, mask: Self::Vi64, a: Self::Vi64)

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

Note, SSE2 and SSE4 will store when mask[i] is nonzero, where AVX2 will store only when the high bit is set. To ensure portability ensure the high bit is set.

unsafe fn maskstore_ps(mem_addr: &mut f32, mask: Self::Vi32, a: Self::Vf32)

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

Note, SSE2 and SSE4 will store when mask[i] is nonzero, where AVX2 will store only when the high bit is set. To ensure portability ensure the high bit is set.

unsafe fn maskstore_pd(mem_addr: &mut f64, mask: Self::Vi64, a: Self::Vf64)

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

Note, SSE2 and SSE4 will store when mask[i] is nonzero, where AVX2 will store only when the high bit is set. To ensure portability ensure the high bit is set.

unsafe fn max_epi32(a: Self::Vi32, b: Self::Vi32) -> Self::Vi32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn min_epi32(a: Self::Vi32, b: Self::Vi32) -> Self::Vi32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn max_ps(a: Self::Vf32, b: Self::Vf32) -> Self::Vf32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn min_ps(a: Self::Vf32, b: Self::Vf32) -> Self::Vf32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn max_pd(a: Self::Vf64, b: Self::Vf64) -> Self::Vf64

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn min_pd(a: Self::Vf64, b: Self::Vf64) -> Self::Vf64

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn rcp_ps(a: Self::Vf32) -> Self::Vf32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn round_ps(a: Self::Vf32) -> Self::Vf32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

Round is implemented for Sse2 by combining other Sse2 operations.

unsafe fn round_pd(a: Self::Vf64) -> Self::Vf64

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn set1_epi32(a: i32) -> Self::Vi32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn set1_epi64(a: i64) -> Self::Vi64

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn set1_ps(a: f32) -> Self::Vf32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn set1_pd(a: f64) -> Self::Vf64

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn setzero_ps() -> Self::Vf32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn setzero_pd() -> Self::Vf64

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn setzero_epi32() -> Self::Vi32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn setzero_epi64() -> Self::Vi64

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn srai_epi64(a: Self::Vi64, amt_const: i32) -> Self::Vi64

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

amt must be a constant

unsafe fn srli_epi32(a: Self::Vi32, amt_const: i32) -> Self::Vi32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

amt must be a constant

unsafe fn sra_epi32(a: Self::Vi32, amt: i32) -> Self::Vi32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

amt does not have to be a constant, but may be slower than the srai version

unsafe fn srl_epi32(a: Self::Vi32, amt: i32) -> Self::Vi32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

amt does not have to be a constant, but may be slower than the srli version

unsafe fn sll_epi32(a: Self::Vi32, amt: i32) -> Self::Vi32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

amt does not have to be a constant, but may be slower than the slli version

unsafe fn sub_epi32(a: Self::Vi32, b: Self::Vi32) -> Self::Vi32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn sub_epi64(a: Self::Vi64, b: Self::Vi64) -> Self::Vi64

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn sub_ps(a: Self::Vf32, b: Self::Vf32) -> Self::Vf32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn sub_pd(a: Self::Vf64, b: Self::Vf64) -> Self::Vf64

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn sqrt_ps(a: Self::Vf32) -> Self::Vf32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn rsqrt_ps(a: Self::Vf32) -> Self::Vf32

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn sqrt_pd(a: Self::Vf64) -> Self::Vf64

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn rsqrt_pd(a: Self::Vf64) -> Self::Vf64

👎Deprecated: Functions on the Simd trait are deprecated, please use the functions on the Vf32, Vf64, Vi16, Vi32, and Vi64 types instead.

unsafe fn shuffle_epi32<const IMM8: i32>(_a: Self::Vi32) -> Self::Vi32

👎Deprecated: These functions have unpredictable behavior and will be deleted in the future. Please use a manual implementation instead.

Using the shuffle function is undefined behavior because imm8 behaves differently on different architectures.

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.

Implementors

impl Simd for Scalar

type Vi8 = I8x1

type Vi16 = I16x1

type Vi32 = I32x1

type Vf32 = F32x1

type Vf64 = F64x1

type Vi64 = I64x1