use crate::{Level, arch_types::ArchTypes, prelude::*, seal::Seal};
use crate::{
f32x4, f32x8, f32x16, f64x2, f64x4, f64x8, i8x16, i8x32, i8x64, i16x8, i16x16, i16x32, i32x4,
i32x8, i32x16, i64x2, i64x4, i64x8, mask8x16, mask8x32, mask8x64, mask16x8, mask16x16,
mask16x32, mask32x4, mask32x8, mask32x16, mask64x2, mask64x4, mask64x8, u8x16, u8x32, u8x64,
u16x8, u16x16, u16x32, u32x4, u32x8, u32x16, u64x2, u64x4, u64x8,
};
use core::ops::*;
#[cfg(all(feature = "libm", not(feature = "std")))]
#[allow(
dead_code,
reason = "Generated backends use different subsets of these helpers"
)]
trait FloatExt {
fn floor(self) -> Self;
fn ceil(self) -> Self;
fn round_ties_even(self) -> Self;
fn fract(self) -> Self;
fn sqrt(self) -> Self;
fn trunc(self) -> Self;
}
#[cfg(all(feature = "libm", not(feature = "std")))]
impl FloatExt for f32 {
#[inline(always)]
fn floor(self) -> f32 {
libm::floorf(self)
}
#[inline(always)]
fn ceil(self) -> f32 {
libm::ceilf(self)
}
#[inline(always)]
fn round_ties_even(self) -> f32 {
libm::rintf(self)
}
#[inline(always)]
fn sqrt(self) -> f32 {
libm::sqrtf(self)
}
#[inline(always)]
fn fract(self) -> f32 {
self - self.trunc()
}
#[inline(always)]
fn trunc(self) -> f32 {
libm::truncf(self)
}
}
#[cfg(all(feature = "libm", not(feature = "std")))]
impl FloatExt for f64 {
#[inline(always)]
fn floor(self) -> f64 {
libm::floor(self)
}
#[inline(always)]
fn ceil(self) -> f64 {
libm::ceil(self)
}
#[inline(always)]
fn round_ties_even(self) -> f64 {
libm::rint(self)
}
#[inline(always)]
fn sqrt(self) -> f64 {
libm::sqrt(self)
}
#[inline(always)]
fn fract(self) -> f64 {
self - self.trunc()
}
#[inline(always)]
fn trunc(self) -> f64 {
libm::trunc(self)
}
}
#[doc = "A token for scalar fallback SIMD, representing the \"fallback\" level."]
#[doc = "# Browsing the documentation"]
#[doc = "The method list on this struct is very verbose."]
#[doc = "A better way to browse the docs is by looking at vector types such as [`u32x4`], [`f32x4`] or [`mask32x4`]."]
#[doc = "They include all the operations listed here, and also provide some additional convenience methods."]
#[derive(Clone, Copy, Debug)]
pub struct Fallback {
_private: (),
}
impl Fallback {
#[doc = r" Create a scalar fallback token."]
#[inline]
pub const fn new() -> Self {
Self { _private: () }
}
}
impl Seal for Fallback {}
impl ArchTypes for Fallback {
type f32x4 = crate::support::Aligned128<[f32; 4usize]>;
type i8x16 = crate::support::Aligned128<[i8; 16usize]>;
type u8x16 = crate::support::Aligned128<[u8; 16usize]>;
type mask8x16 = crate::support::Aligned128<[i8; 16usize]>;
type i16x8 = crate::support::Aligned128<[i16; 8usize]>;
type u16x8 = crate::support::Aligned128<[u16; 8usize]>;
type mask16x8 = crate::support::Aligned128<[i16; 8usize]>;
type i32x4 = crate::support::Aligned128<[i32; 4usize]>;
type u32x4 = crate::support::Aligned128<[u32; 4usize]>;
type mask32x4 = crate::support::Aligned128<[i32; 4usize]>;
type f64x2 = crate::support::Aligned128<[f64; 2usize]>;
type i64x2 = crate::support::Aligned128<[i64; 2usize]>;
type u64x2 = crate::support::Aligned128<[u64; 2usize]>;
type mask64x2 = crate::support::Aligned128<[i64; 2usize]>;
type f32x8 = crate::support::Aligned256<[f32; 8usize]>;
type i8x32 = crate::support::Aligned256<[i8; 32usize]>;
type u8x32 = crate::support::Aligned256<[u8; 32usize]>;
type mask8x32 = crate::support::Aligned256<[i8; 32usize]>;
type i16x16 = crate::support::Aligned256<[i16; 16usize]>;
type u16x16 = crate::support::Aligned256<[u16; 16usize]>;
type mask16x16 = crate::support::Aligned256<[i16; 16usize]>;
type i32x8 = crate::support::Aligned256<[i32; 8usize]>;
type u32x8 = crate::support::Aligned256<[u32; 8usize]>;
type mask32x8 = crate::support::Aligned256<[i32; 8usize]>;
type f64x4 = crate::support::Aligned256<[f64; 4usize]>;
type i64x4 = crate::support::Aligned256<[i64; 4usize]>;
type u64x4 = crate::support::Aligned256<[u64; 4usize]>;
type mask64x4 = crate::support::Aligned256<[i64; 4usize]>;
type f32x16 = crate::support::Aligned512<[f32; 16usize]>;
type i8x64 = crate::support::Aligned512<[i8; 64usize]>;
type u8x64 = crate::support::Aligned512<[u8; 64usize]>;
type mask8x64 = crate::support::Aligned512<[i8; 64usize]>;
type i16x32 = crate::support::Aligned512<[i16; 32usize]>;
type u16x32 = crate::support::Aligned512<[u16; 32usize]>;
type mask16x32 = crate::support::Aligned512<[i16; 32usize]>;
type i32x16 = crate::support::Aligned512<[i32; 16usize]>;
type u32x16 = crate::support::Aligned512<[u32; 16usize]>;
type mask32x16 = crate::support::Aligned512<[i32; 16usize]>;
type f64x8 = crate::support::Aligned512<[f64; 8usize]>;
type i64x8 = crate::support::Aligned512<[i64; 8usize]>;
type u64x8 = crate::support::Aligned512<[u64; 8usize]>;
type mask64x8 = crate::support::Aligned512<[i64; 8usize]>;
}
impl Simd for Fallback {
type f32s = f32x4<Self>;
type f64s = f64x2<Self>;
type u8s = u8x16<Self>;
type i8s = i8x16<Self>;
type u16s = u16x8<Self>;
type i16s = i16x8<Self>;
type u32s = u32x4<Self>;
type i32s = i32x4<Self>;
type u64s = u64x2<Self>;
type i64s = i64x2<Self>;
type mask8s = mask8x16<Self>;
type mask16s = mask16x8<Self>;
type mask32s = mask32x4<Self>;
type mask64s = mask64x2<Self>;
#[inline(always)]
fn level(self) -> Level {
#[cfg(feature = "force_support_fallback")]
return Level::Fallback(self);
#[cfg(not(feature = "force_support_fallback"))]
Level::baseline()
}
#[inline]
fn vectorize<F: FnOnce() -> R, R>(self, f: F) -> R {
fn vectorize_inner<F: FnOnce() -> R, R>(f: F) -> R {
f()
}
vectorize_inner(f)
}
#[inline(always)]
fn splat_f32x4(self, val: f32) -> f32x4<Self> {
[val; 4usize].simd_into(self)
}
#[inline(always)]
fn slide_f32x4<const SHIFT: usize>(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self> {
let mut dest = [Default::default(); 4usize];
dest[..4usize - SHIFT].copy_from_slice(&a.val.0[SHIFT..]);
dest[4usize - SHIFT..].copy_from_slice(&b.val.0[..SHIFT]);
dest.simd_into(self)
}
#[inline(always)]
fn abs_f32x4(self, a: f32x4<Self>) -> f32x4<Self> {
[
f32::abs(a[0usize]),
f32::abs(a[1usize]),
f32::abs(a[2usize]),
f32::abs(a[3usize]),
]
.simd_into(self)
}
#[inline(always)]
fn neg_f32x4(self, a: f32x4<Self>) -> f32x4<Self> {
[
f32::neg(a[0usize]),
f32::neg(a[1usize]),
f32::neg(a[2usize]),
f32::neg(a[3usize]),
]
.simd_into(self)
}
#[inline(always)]
fn sqrt_f32x4(self, a: f32x4<Self>) -> f32x4<Self> {
[
f32::sqrt(a[0usize]),
f32::sqrt(a[1usize]),
f32::sqrt(a[2usize]),
f32::sqrt(a[3usize]),
]
.simd_into(self)
}
#[inline(always)]
fn approximate_recip_f32x4(self, a: f32x4<Self>) -> f32x4<Self> {
1.0 / a
}
#[inline(always)]
fn add_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self> {
[
f32::add(a[0usize], &b[0usize]),
f32::add(a[1usize], &b[1usize]),
f32::add(a[2usize], &b[2usize]),
f32::add(a[3usize], &b[3usize]),
]
.simd_into(self)
}
#[inline(always)]
fn sub_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self> {
[
f32::sub(a[0usize], &b[0usize]),
f32::sub(a[1usize], &b[1usize]),
f32::sub(a[2usize], &b[2usize]),
f32::sub(a[3usize], &b[3usize]),
]
.simd_into(self)
}
#[inline(always)]
fn mul_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self> {
[
f32::mul(a[0usize], &b[0usize]),
f32::mul(a[1usize], &b[1usize]),
f32::mul(a[2usize], &b[2usize]),
f32::mul(a[3usize], &b[3usize]),
]
.simd_into(self)
}
#[inline(always)]
fn div_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self> {
[
f32::div(a[0usize], &b[0usize]),
f32::div(a[1usize], &b[1usize]),
f32::div(a[2usize], &b[2usize]),
f32::div(a[3usize], &b[3usize]),
]
.simd_into(self)
}
#[inline(always)]
fn copysign_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self> {
[
f32::copysign(a[0usize], b[0usize]),
f32::copysign(a[1usize], b[1usize]),
f32::copysign(a[2usize], b[2usize]),
f32::copysign(a[3usize], b[3usize]),
]
.simd_into(self)
}
#[inline(always)]
fn max_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self> {
[
f32::max(a[0usize], b[0usize]),
f32::max(a[1usize], b[1usize]),
f32::max(a[2usize], b[2usize]),
f32::max(a[3usize], b[3usize]),
]
.simd_into(self)
}
#[inline(always)]
fn min_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self> {
[
f32::min(a[0usize], b[0usize]),
f32::min(a[1usize], b[1usize]),
f32::min(a[2usize], b[2usize]),
f32::min(a[3usize], b[3usize]),
]
.simd_into(self)
}
#[inline(always)]
fn max_precise_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self> {
[
f32::max(a[0usize], b[0usize]),
f32::max(a[1usize], b[1usize]),
f32::max(a[2usize], b[2usize]),
f32::max(a[3usize], b[3usize]),
]
.simd_into(self)
}
#[inline(always)]
fn min_precise_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self> {
[
f32::min(a[0usize], b[0usize]),
f32::min(a[1usize], b[1usize]),
f32::min(a[2usize], b[2usize]),
f32::min(a[3usize], b[3usize]),
]
.simd_into(self)
}
#[inline(always)]
fn simd_eq_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> mask32x4<Self> {
[
-(f32::eq(&a[0usize], &b[0usize]) as i32),
-(f32::eq(&a[1usize], &b[1usize]) as i32),
-(f32::eq(&a[2usize], &b[2usize]) as i32),
-(f32::eq(&a[3usize], &b[3usize]) as i32),
]
.simd_into(self)
}
#[inline(always)]
fn simd_lt_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> mask32x4<Self> {
[
-(f32::lt(&a[0usize], &b[0usize]) as i32),
-(f32::lt(&a[1usize], &b[1usize]) as i32),
-(f32::lt(&a[2usize], &b[2usize]) as i32),
-(f32::lt(&a[3usize], &b[3usize]) as i32),
]
.simd_into(self)
}
#[inline(always)]
fn simd_le_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> mask32x4<Self> {
[
-(f32::le(&a[0usize], &b[0usize]) as i32),
-(f32::le(&a[1usize], &b[1usize]) as i32),
-(f32::le(&a[2usize], &b[2usize]) as i32),
-(f32::le(&a[3usize], &b[3usize]) as i32),
]
.simd_into(self)
}
#[inline(always)]
fn zip_low_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self> {
[a[0usize], b[0usize], a[1usize], b[1usize]].simd_into(self)
}
#[inline(always)]
fn zip_high_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self> {
[a[2usize], b[2usize], a[3usize], b[3usize]].simd_into(self)
}
#[inline(always)]
fn unzip_low_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self> {
[a[0usize], a[2usize], b[0usize], b[2usize]].simd_into(self)
}
#[inline(always)]
fn unzip_high_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x4<Self> {
[a[1usize], a[3usize], b[1usize], b[3usize]].simd_into(self)
}
#[inline(always)]
fn interleave_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> (f32x4<Self>, f32x4<Self>) {
(self.zip_low_f32x4(a, b), self.zip_high_f32x4(a, b))
}
#[inline(always)]
fn deinterleave_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> (f32x4<Self>, f32x4<Self>) {
(self.unzip_low_f32x4(a, b), self.unzip_high_f32x4(a, b))
}
#[inline(always)]
fn mul_add_f32x4(self, a: f32x4<Self>, b: f32x4<Self>, c: f32x4<Self>) -> f32x4<Self> {
a.mul(b).add(c)
}
#[inline(always)]
fn mul_sub_f32x4(self, a: f32x4<Self>, b: f32x4<Self>, c: f32x4<Self>) -> f32x4<Self> {
a.mul(b).sub(c)
}
#[inline(always)]
fn floor_f32x4(self, a: f32x4<Self>) -> f32x4<Self> {
[
f32::floor(a[0usize]),
f32::floor(a[1usize]),
f32::floor(a[2usize]),
f32::floor(a[3usize]),
]
.simd_into(self)
}
#[inline(always)]
fn ceil_f32x4(self, a: f32x4<Self>) -> f32x4<Self> {
[
f32::ceil(a[0usize]),
f32::ceil(a[1usize]),
f32::ceil(a[2usize]),
f32::ceil(a[3usize]),
]
.simd_into(self)
}
#[inline(always)]
fn round_ties_even_f32x4(self, a: f32x4<Self>) -> f32x4<Self> {
[
f32::round_ties_even(a[0usize]),
f32::round_ties_even(a[1usize]),
f32::round_ties_even(a[2usize]),
f32::round_ties_even(a[3usize]),
]
.simd_into(self)
}
#[inline(always)]
fn fract_f32x4(self, a: f32x4<Self>) -> f32x4<Self> {
[
f32::fract(a[0usize]),
f32::fract(a[1usize]),
f32::fract(a[2usize]),
f32::fract(a[3usize]),
]
.simd_into(self)
}
#[inline(always)]
fn trunc_f32x4(self, a: f32x4<Self>) -> f32x4<Self> {
[
f32::trunc(a[0usize]),
f32::trunc(a[1usize]),
f32::trunc(a[2usize]),
f32::trunc(a[3usize]),
]
.simd_into(self)
}
#[inline(always)]
fn select_f32x4(self, a: mask32x4<Self>, b: f32x4<Self>, c: f32x4<Self>) -> f32x4<Self> {
[
if a.val.0[0usize] != 0 {
b[0usize]
} else {
c[0usize]
},
if a.val.0[1usize] != 0 {
b[1usize]
} else {
c[1usize]
},
if a.val.0[2usize] != 0 {
b[2usize]
} else {
c[2usize]
},
if a.val.0[3usize] != 0 {
b[3usize]
} else {
c[3usize]
},
]
.simd_into(self)
}
#[inline(always)]
fn combine_f32x4(self, a: f32x4<Self>, b: f32x4<Self>) -> f32x8<Self> {
let mut result = [0.0; 8usize];
result[0..4usize].copy_from_slice(&a.val.0);
result[4usize..8usize].copy_from_slice(&b.val.0);
result.simd_into(self)
}
#[inline(always)]
fn load_four_interleaved_f32x4(self, src: &[f32; 16usize]) -> [f32x4<Self>; 4usize] {
[
[src[0usize], src[4usize], src[8usize], src[12usize]].simd_into(self),
[src[1usize], src[5usize], src[9usize], src[13usize]].simd_into(self),
[src[2usize], src[6usize], src[10usize], src[14usize]].simd_into(self),
[src[3usize], src[7usize], src[11usize], src[15usize]].simd_into(self),
]
}
#[inline(always)]
fn store_four_interleaved_f32x4(
self,
vectors: [f32x4<Self>; 4usize],
dest: &mut [f32; 16usize],
) -> () {
*dest = [
vectors[0usize][0usize],
vectors[1usize][0usize],
vectors[2usize][0usize],
vectors[3usize][0usize],
vectors[0usize][1usize],
vectors[1usize][1usize],
vectors[2usize][1usize],
vectors[3usize][1usize],
vectors[0usize][2usize],
vectors[1usize][2usize],
vectors[2usize][2usize],
vectors[3usize][2usize],
vectors[0usize][3usize],
vectors[1usize][3usize],
vectors[2usize][3usize],
vectors[3usize][3usize],
];
}
#[inline(always)]
fn widen_f32x4(self, a: f32x4<Self>) -> (f64x2<Self>, f64x2<Self>) {
(
[a[0usize] as f64, a[1usize] as f64].simd_into(self),
[a[2usize] as f64, a[3usize] as f64].simd_into(self),
)
}
#[inline(always)]
fn cvt_u32_f32x4(self, a: f32x4<Self>) -> u32x4<Self> {
[
a[0usize] as u32,
a[1usize] as u32,
a[2usize] as u32,
a[3usize] as u32,
]
.simd_into(self)
}
#[inline(always)]
fn cvt_u32_precise_f32x4(self, a: f32x4<Self>) -> u32x4<Self> {
[
a[0usize] as u32,
a[1usize] as u32,
a[2usize] as u32,
a[3usize] as u32,
]
.simd_into(self)
}
#[inline(always)]
fn cvt_i32_f32x4(self, a: f32x4<Self>) -> i32x4<Self> {
[
a[0usize] as i32,
a[1usize] as i32,
a[2usize] as i32,
a[3usize] as i32,
]
.simd_into(self)
}
#[inline(always)]
fn cvt_i32_precise_f32x4(self, a: f32x4<Self>) -> i32x4<Self> {
[
a[0usize] as i32,
a[1usize] as i32,
a[2usize] as i32,
a[3usize] as i32,
]
.simd_into(self)
}
#[inline(always)]
fn splat_i8x16(self, val: i8) -> i8x16<Self> {
[val; 16usize].simd_into(self)
}
#[inline(always)]
fn slide_i8x16<const SHIFT: usize>(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self> {
let mut dest = [Default::default(); 16usize];
dest[..16usize - SHIFT].copy_from_slice(&a.val.0[SHIFT..]);
dest[16usize - SHIFT..].copy_from_slice(&b.val.0[..SHIFT]);
dest.simd_into(self)
}
#[inline(always)]
fn add_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self> {
[
i8::wrapping_add(a[0usize], b[0usize]),
i8::wrapping_add(a[1usize], b[1usize]),
i8::wrapping_add(a[2usize], b[2usize]),
i8::wrapping_add(a[3usize], b[3usize]),
i8::wrapping_add(a[4usize], b[4usize]),
i8::wrapping_add(a[5usize], b[5usize]),
i8::wrapping_add(a[6usize], b[6usize]),
i8::wrapping_add(a[7usize], b[7usize]),
i8::wrapping_add(a[8usize], b[8usize]),
i8::wrapping_add(a[9usize], b[9usize]),
i8::wrapping_add(a[10usize], b[10usize]),
i8::wrapping_add(a[11usize], b[11usize]),
i8::wrapping_add(a[12usize], b[12usize]),
i8::wrapping_add(a[13usize], b[13usize]),
i8::wrapping_add(a[14usize], b[14usize]),
i8::wrapping_add(a[15usize], b[15usize]),
]
.simd_into(self)
}
#[inline(always)]
fn sub_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self> {
[
i8::wrapping_sub(a[0usize], b[0usize]),
i8::wrapping_sub(a[1usize], b[1usize]),
i8::wrapping_sub(a[2usize], b[2usize]),
i8::wrapping_sub(a[3usize], b[3usize]),
i8::wrapping_sub(a[4usize], b[4usize]),
i8::wrapping_sub(a[5usize], b[5usize]),
i8::wrapping_sub(a[6usize], b[6usize]),
i8::wrapping_sub(a[7usize], b[7usize]),
i8::wrapping_sub(a[8usize], b[8usize]),
i8::wrapping_sub(a[9usize], b[9usize]),
i8::wrapping_sub(a[10usize], b[10usize]),
i8::wrapping_sub(a[11usize], b[11usize]),
i8::wrapping_sub(a[12usize], b[12usize]),
i8::wrapping_sub(a[13usize], b[13usize]),
i8::wrapping_sub(a[14usize], b[14usize]),
i8::wrapping_sub(a[15usize], b[15usize]),
]
.simd_into(self)
}
#[inline(always)]
fn mul_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self> {
[
i8::wrapping_mul(a[0usize], b[0usize]),
i8::wrapping_mul(a[1usize], b[1usize]),
i8::wrapping_mul(a[2usize], b[2usize]),
i8::wrapping_mul(a[3usize], b[3usize]),
i8::wrapping_mul(a[4usize], b[4usize]),
i8::wrapping_mul(a[5usize], b[5usize]),
i8::wrapping_mul(a[6usize], b[6usize]),
i8::wrapping_mul(a[7usize], b[7usize]),
i8::wrapping_mul(a[8usize], b[8usize]),
i8::wrapping_mul(a[9usize], b[9usize]),
i8::wrapping_mul(a[10usize], b[10usize]),
i8::wrapping_mul(a[11usize], b[11usize]),
i8::wrapping_mul(a[12usize], b[12usize]),
i8::wrapping_mul(a[13usize], b[13usize]),
i8::wrapping_mul(a[14usize], b[14usize]),
i8::wrapping_mul(a[15usize], b[15usize]),
]
.simd_into(self)
}
#[inline(always)]
fn and_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self> {
[
i8::bitand(a[0usize], &b[0usize]),
i8::bitand(a[1usize], &b[1usize]),
i8::bitand(a[2usize], &b[2usize]),
i8::bitand(a[3usize], &b[3usize]),
i8::bitand(a[4usize], &b[4usize]),
i8::bitand(a[5usize], &b[5usize]),
i8::bitand(a[6usize], &b[6usize]),
i8::bitand(a[7usize], &b[7usize]),
i8::bitand(a[8usize], &b[8usize]),
i8::bitand(a[9usize], &b[9usize]),
i8::bitand(a[10usize], &b[10usize]),
i8::bitand(a[11usize], &b[11usize]),
i8::bitand(a[12usize], &b[12usize]),
i8::bitand(a[13usize], &b[13usize]),
i8::bitand(a[14usize], &b[14usize]),
i8::bitand(a[15usize], &b[15usize]),
]
.simd_into(self)
}
#[inline(always)]
fn or_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self> {
[
i8::bitor(a[0usize], &b[0usize]),
i8::bitor(a[1usize], &b[1usize]),
i8::bitor(a[2usize], &b[2usize]),
i8::bitor(a[3usize], &b[3usize]),
i8::bitor(a[4usize], &b[4usize]),
i8::bitor(a[5usize], &b[5usize]),
i8::bitor(a[6usize], &b[6usize]),
i8::bitor(a[7usize], &b[7usize]),
i8::bitor(a[8usize], &b[8usize]),
i8::bitor(a[9usize], &b[9usize]),
i8::bitor(a[10usize], &b[10usize]),
i8::bitor(a[11usize], &b[11usize]),
i8::bitor(a[12usize], &b[12usize]),
i8::bitor(a[13usize], &b[13usize]),
i8::bitor(a[14usize], &b[14usize]),
i8::bitor(a[15usize], &b[15usize]),
]
.simd_into(self)
}
#[inline(always)]
fn xor_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self> {
[
i8::bitxor(a[0usize], &b[0usize]),
i8::bitxor(a[1usize], &b[1usize]),
i8::bitxor(a[2usize], &b[2usize]),
i8::bitxor(a[3usize], &b[3usize]),
i8::bitxor(a[4usize], &b[4usize]),
i8::bitxor(a[5usize], &b[5usize]),
i8::bitxor(a[6usize], &b[6usize]),
i8::bitxor(a[7usize], &b[7usize]),
i8::bitxor(a[8usize], &b[8usize]),
i8::bitxor(a[9usize], &b[9usize]),
i8::bitxor(a[10usize], &b[10usize]),
i8::bitxor(a[11usize], &b[11usize]),
i8::bitxor(a[12usize], &b[12usize]),
i8::bitxor(a[13usize], &b[13usize]),
i8::bitxor(a[14usize], &b[14usize]),
i8::bitxor(a[15usize], &b[15usize]),
]
.simd_into(self)
}
#[inline(always)]
fn not_i8x16(self, a: i8x16<Self>) -> i8x16<Self> {
[
i8::not(a[0usize]),
i8::not(a[1usize]),
i8::not(a[2usize]),
i8::not(a[3usize]),
i8::not(a[4usize]),
i8::not(a[5usize]),
i8::not(a[6usize]),
i8::not(a[7usize]),
i8::not(a[8usize]),
i8::not(a[9usize]),
i8::not(a[10usize]),
i8::not(a[11usize]),
i8::not(a[12usize]),
i8::not(a[13usize]),
i8::not(a[14usize]),
i8::not(a[15usize]),
]
.simd_into(self)
}
#[inline(always)]
fn shl_i8x16(self, a: i8x16<Self>, shift: u32) -> i8x16<Self> {
[
i8::wrapping_shl(a[0usize], shift),
i8::wrapping_shl(a[1usize], shift),
i8::wrapping_shl(a[2usize], shift),
i8::wrapping_shl(a[3usize], shift),
i8::wrapping_shl(a[4usize], shift),
i8::wrapping_shl(a[5usize], shift),
i8::wrapping_shl(a[6usize], shift),
i8::wrapping_shl(a[7usize], shift),
i8::wrapping_shl(a[8usize], shift),
i8::wrapping_shl(a[9usize], shift),
i8::wrapping_shl(a[10usize], shift),
i8::wrapping_shl(a[11usize], shift),
i8::wrapping_shl(a[12usize], shift),
i8::wrapping_shl(a[13usize], shift),
i8::wrapping_shl(a[14usize], shift),
i8::wrapping_shl(a[15usize], shift),
]
.simd_into(self)
}
#[inline(always)]
fn shlv_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self> {
[
i8::wrapping_shl(a[0usize], b[0usize] as u32),
i8::wrapping_shl(a[1usize], b[1usize] as u32),
i8::wrapping_shl(a[2usize], b[2usize] as u32),
i8::wrapping_shl(a[3usize], b[3usize] as u32),
i8::wrapping_shl(a[4usize], b[4usize] as u32),
i8::wrapping_shl(a[5usize], b[5usize] as u32),
i8::wrapping_shl(a[6usize], b[6usize] as u32),
i8::wrapping_shl(a[7usize], b[7usize] as u32),
i8::wrapping_shl(a[8usize], b[8usize] as u32),
i8::wrapping_shl(a[9usize], b[9usize] as u32),
i8::wrapping_shl(a[10usize], b[10usize] as u32),
i8::wrapping_shl(a[11usize], b[11usize] as u32),
i8::wrapping_shl(a[12usize], b[12usize] as u32),
i8::wrapping_shl(a[13usize], b[13usize] as u32),
i8::wrapping_shl(a[14usize], b[14usize] as u32),
i8::wrapping_shl(a[15usize], b[15usize] as u32),
]
.simd_into(self)
}
#[inline(always)]
fn shr_i8x16(self, a: i8x16<Self>, shift: u32) -> i8x16<Self> {
[
i8::wrapping_shr(a[0usize], shift),
i8::wrapping_shr(a[1usize], shift),
i8::wrapping_shr(a[2usize], shift),
i8::wrapping_shr(a[3usize], shift),
i8::wrapping_shr(a[4usize], shift),
i8::wrapping_shr(a[5usize], shift),
i8::wrapping_shr(a[6usize], shift),
i8::wrapping_shr(a[7usize], shift),
i8::wrapping_shr(a[8usize], shift),
i8::wrapping_shr(a[9usize], shift),
i8::wrapping_shr(a[10usize], shift),
i8::wrapping_shr(a[11usize], shift),
i8::wrapping_shr(a[12usize], shift),
i8::wrapping_shr(a[13usize], shift),
i8::wrapping_shr(a[14usize], shift),
i8::wrapping_shr(a[15usize], shift),
]
.simd_into(self)
}
#[inline(always)]
fn shrv_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self> {
[
i8::wrapping_shr(a[0usize], b[0usize] as u32),
i8::wrapping_shr(a[1usize], b[1usize] as u32),
i8::wrapping_shr(a[2usize], b[2usize] as u32),
i8::wrapping_shr(a[3usize], b[3usize] as u32),
i8::wrapping_shr(a[4usize], b[4usize] as u32),
i8::wrapping_shr(a[5usize], b[5usize] as u32),
i8::wrapping_shr(a[6usize], b[6usize] as u32),
i8::wrapping_shr(a[7usize], b[7usize] as u32),
i8::wrapping_shr(a[8usize], b[8usize] as u32),
i8::wrapping_shr(a[9usize], b[9usize] as u32),
i8::wrapping_shr(a[10usize], b[10usize] as u32),
i8::wrapping_shr(a[11usize], b[11usize] as u32),
i8::wrapping_shr(a[12usize], b[12usize] as u32),
i8::wrapping_shr(a[13usize], b[13usize] as u32),
i8::wrapping_shr(a[14usize], b[14usize] as u32),
i8::wrapping_shr(a[15usize], b[15usize] as u32),
]
.simd_into(self)
}
#[inline(always)]
fn max_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self> {
[
i8::max(a[0usize], b[0usize]),
i8::max(a[1usize], b[1usize]),
i8::max(a[2usize], b[2usize]),
i8::max(a[3usize], b[3usize]),
i8::max(a[4usize], b[4usize]),
i8::max(a[5usize], b[5usize]),
i8::max(a[6usize], b[6usize]),
i8::max(a[7usize], b[7usize]),
i8::max(a[8usize], b[8usize]),
i8::max(a[9usize], b[9usize]),
i8::max(a[10usize], b[10usize]),
i8::max(a[11usize], b[11usize]),
i8::max(a[12usize], b[12usize]),
i8::max(a[13usize], b[13usize]),
i8::max(a[14usize], b[14usize]),
i8::max(a[15usize], b[15usize]),
]
.simd_into(self)
}
#[inline(always)]
fn min_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self> {
[
i8::min(a[0usize], b[0usize]),
i8::min(a[1usize], b[1usize]),
i8::min(a[2usize], b[2usize]),
i8::min(a[3usize], b[3usize]),
i8::min(a[4usize], b[4usize]),
i8::min(a[5usize], b[5usize]),
i8::min(a[6usize], b[6usize]),
i8::min(a[7usize], b[7usize]),
i8::min(a[8usize], b[8usize]),
i8::min(a[9usize], b[9usize]),
i8::min(a[10usize], b[10usize]),
i8::min(a[11usize], b[11usize]),
i8::min(a[12usize], b[12usize]),
i8::min(a[13usize], b[13usize]),
i8::min(a[14usize], b[14usize]),
i8::min(a[15usize], b[15usize]),
]
.simd_into(self)
}
#[inline(always)]
fn simd_eq_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> mask8x16<Self> {
[
-(i8::eq(&a[0usize], &b[0usize]) as i8),
-(i8::eq(&a[1usize], &b[1usize]) as i8),
-(i8::eq(&a[2usize], &b[2usize]) as i8),
-(i8::eq(&a[3usize], &b[3usize]) as i8),
-(i8::eq(&a[4usize], &b[4usize]) as i8),
-(i8::eq(&a[5usize], &b[5usize]) as i8),
-(i8::eq(&a[6usize], &b[6usize]) as i8),
-(i8::eq(&a[7usize], &b[7usize]) as i8),
-(i8::eq(&a[8usize], &b[8usize]) as i8),
-(i8::eq(&a[9usize], &b[9usize]) as i8),
-(i8::eq(&a[10usize], &b[10usize]) as i8),
-(i8::eq(&a[11usize], &b[11usize]) as i8),
-(i8::eq(&a[12usize], &b[12usize]) as i8),
-(i8::eq(&a[13usize], &b[13usize]) as i8),
-(i8::eq(&a[14usize], &b[14usize]) as i8),
-(i8::eq(&a[15usize], &b[15usize]) as i8),
]
.simd_into(self)
}
#[inline(always)]
fn simd_lt_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> mask8x16<Self> {
[
-(i8::lt(&a[0usize], &b[0usize]) as i8),
-(i8::lt(&a[1usize], &b[1usize]) as i8),
-(i8::lt(&a[2usize], &b[2usize]) as i8),
-(i8::lt(&a[3usize], &b[3usize]) as i8),
-(i8::lt(&a[4usize], &b[4usize]) as i8),
-(i8::lt(&a[5usize], &b[5usize]) as i8),
-(i8::lt(&a[6usize], &b[6usize]) as i8),
-(i8::lt(&a[7usize], &b[7usize]) as i8),
-(i8::lt(&a[8usize], &b[8usize]) as i8),
-(i8::lt(&a[9usize], &b[9usize]) as i8),
-(i8::lt(&a[10usize], &b[10usize]) as i8),
-(i8::lt(&a[11usize], &b[11usize]) as i8),
-(i8::lt(&a[12usize], &b[12usize]) as i8),
-(i8::lt(&a[13usize], &b[13usize]) as i8),
-(i8::lt(&a[14usize], &b[14usize]) as i8),
-(i8::lt(&a[15usize], &b[15usize]) as i8),
]
.simd_into(self)
}
#[inline(always)]
fn simd_le_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> mask8x16<Self> {
[
-(i8::le(&a[0usize], &b[0usize]) as i8),
-(i8::le(&a[1usize], &b[1usize]) as i8),
-(i8::le(&a[2usize], &b[2usize]) as i8),
-(i8::le(&a[3usize], &b[3usize]) as i8),
-(i8::le(&a[4usize], &b[4usize]) as i8),
-(i8::le(&a[5usize], &b[5usize]) as i8),
-(i8::le(&a[6usize], &b[6usize]) as i8),
-(i8::le(&a[7usize], &b[7usize]) as i8),
-(i8::le(&a[8usize], &b[8usize]) as i8),
-(i8::le(&a[9usize], &b[9usize]) as i8),
-(i8::le(&a[10usize], &b[10usize]) as i8),
-(i8::le(&a[11usize], &b[11usize]) as i8),
-(i8::le(&a[12usize], &b[12usize]) as i8),
-(i8::le(&a[13usize], &b[13usize]) as i8),
-(i8::le(&a[14usize], &b[14usize]) as i8),
-(i8::le(&a[15usize], &b[15usize]) as i8),
]
.simd_into(self)
}
#[inline(always)]
fn zip_low_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self> {
[
a[0usize], b[0usize], a[1usize], b[1usize], a[2usize], b[2usize], a[3usize], b[3usize],
a[4usize], b[4usize], a[5usize], b[5usize], a[6usize], b[6usize], a[7usize], b[7usize],
]
.simd_into(self)
}
#[inline(always)]
fn zip_high_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self> {
[
a[8usize], b[8usize], a[9usize], b[9usize], a[10usize], b[10usize], a[11usize],
b[11usize], a[12usize], b[12usize], a[13usize], b[13usize], a[14usize], b[14usize],
a[15usize], b[15usize],
]
.simd_into(self)
}
#[inline(always)]
fn unzip_low_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self> {
[
a[0usize], a[2usize], a[4usize], a[6usize], a[8usize], a[10usize], a[12usize],
a[14usize], b[0usize], b[2usize], b[4usize], b[6usize], b[8usize], b[10usize],
b[12usize], b[14usize],
]
.simd_into(self)
}
#[inline(always)]
fn unzip_high_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x16<Self> {
[
a[1usize], a[3usize], a[5usize], a[7usize], a[9usize], a[11usize], a[13usize],
a[15usize], b[1usize], b[3usize], b[5usize], b[7usize], b[9usize], b[11usize],
b[13usize], b[15usize],
]
.simd_into(self)
}
#[inline(always)]
fn interleave_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> (i8x16<Self>, i8x16<Self>) {
(self.zip_low_i8x16(a, b), self.zip_high_i8x16(a, b))
}
#[inline(always)]
fn deinterleave_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> (i8x16<Self>, i8x16<Self>) {
(self.unzip_low_i8x16(a, b), self.unzip_high_i8x16(a, b))
}
#[inline(always)]
fn select_i8x16(self, a: mask8x16<Self>, b: i8x16<Self>, c: i8x16<Self>) -> i8x16<Self> {
[
if a.val.0[0usize] != 0 {
b[0usize]
} else {
c[0usize]
},
if a.val.0[1usize] != 0 {
b[1usize]
} else {
c[1usize]
},
if a.val.0[2usize] != 0 {
b[2usize]
} else {
c[2usize]
},
if a.val.0[3usize] != 0 {
b[3usize]
} else {
c[3usize]
},
if a.val.0[4usize] != 0 {
b[4usize]
} else {
c[4usize]
},
if a.val.0[5usize] != 0 {
b[5usize]
} else {
c[5usize]
},
if a.val.0[6usize] != 0 {
b[6usize]
} else {
c[6usize]
},
if a.val.0[7usize] != 0 {
b[7usize]
} else {
c[7usize]
},
if a.val.0[8usize] != 0 {
b[8usize]
} else {
c[8usize]
},
if a.val.0[9usize] != 0 {
b[9usize]
} else {
c[9usize]
},
if a.val.0[10usize] != 0 {
b[10usize]
} else {
c[10usize]
},
if a.val.0[11usize] != 0 {
b[11usize]
} else {
c[11usize]
},
if a.val.0[12usize] != 0 {
b[12usize]
} else {
c[12usize]
},
if a.val.0[13usize] != 0 {
b[13usize]
} else {
c[13usize]
},
if a.val.0[14usize] != 0 {
b[14usize]
} else {
c[14usize]
},
if a.val.0[15usize] != 0 {
b[15usize]
} else {
c[15usize]
},
]
.simd_into(self)
}
#[inline(always)]
fn combine_i8x16(self, a: i8x16<Self>, b: i8x16<Self>) -> i8x32<Self> {
let mut result = [0; 32usize];
result[0..16usize].copy_from_slice(&a.val.0);
result[16usize..32usize].copy_from_slice(&b.val.0);
result.simd_into(self)
}
#[inline(always)]
fn neg_i8x16(self, a: i8x16<Self>) -> i8x16<Self> {
[
i8::wrapping_neg(a[0usize]),
i8::wrapping_neg(a[1usize]),
i8::wrapping_neg(a[2usize]),
i8::wrapping_neg(a[3usize]),
i8::wrapping_neg(a[4usize]),
i8::wrapping_neg(a[5usize]),
i8::wrapping_neg(a[6usize]),
i8::wrapping_neg(a[7usize]),
i8::wrapping_neg(a[8usize]),
i8::wrapping_neg(a[9usize]),
i8::wrapping_neg(a[10usize]),
i8::wrapping_neg(a[11usize]),
i8::wrapping_neg(a[12usize]),
i8::wrapping_neg(a[13usize]),
i8::wrapping_neg(a[14usize]),
i8::wrapping_neg(a[15usize]),
]
.simd_into(self)
}
#[inline(always)]
fn load_four_interleaved_i8x16(self, src: &[i8; 64usize]) -> [i8x16<Self>; 4usize] {
[
[
src[0usize],
src[4usize],
src[8usize],
src[12usize],
src[16usize],
src[20usize],
src[24usize],
src[28usize],
src[32usize],
src[36usize],
src[40usize],
src[44usize],
src[48usize],
src[52usize],
src[56usize],
src[60usize],
]
.simd_into(self),
[
src[1usize],
src[5usize],
src[9usize],
src[13usize],
src[17usize],
src[21usize],
src[25usize],
src[29usize],
src[33usize],
src[37usize],
src[41usize],
src[45usize],
src[49usize],
src[53usize],
src[57usize],
src[61usize],
]
.simd_into(self),
[
src[2usize],
src[6usize],
src[10usize],
src[14usize],
src[18usize],
src[22usize],
src[26usize],
src[30usize],
src[34usize],
src[38usize],
src[42usize],
src[46usize],
src[50usize],
src[54usize],
src[58usize],
src[62usize],
]
.simd_into(self),
[
src[3usize],
src[7usize],
src[11usize],
src[15usize],
src[19usize],
src[23usize],
src[27usize],
src[31usize],
src[35usize],
src[39usize],
src[43usize],
src[47usize],
src[51usize],
src[55usize],
src[59usize],
src[63usize],
]
.simd_into(self),
]
}
#[inline(always)]
fn store_four_interleaved_i8x16(
self,
vectors: [i8x16<Self>; 4usize],
dest: &mut [i8; 64usize],
) -> () {
*dest = [
vectors[0usize][0usize],
vectors[1usize][0usize],
vectors[2usize][0usize],
vectors[3usize][0usize],
vectors[0usize][1usize],
vectors[1usize][1usize],
vectors[2usize][1usize],
vectors[3usize][1usize],
vectors[0usize][2usize],
vectors[1usize][2usize],
vectors[2usize][2usize],
vectors[3usize][2usize],
vectors[0usize][3usize],
vectors[1usize][3usize],
vectors[2usize][3usize],
vectors[3usize][3usize],
vectors[0usize][4usize],
vectors[1usize][4usize],
vectors[2usize][4usize],
vectors[3usize][4usize],
vectors[0usize][5usize],
vectors[1usize][5usize],
vectors[2usize][5usize],
vectors[3usize][5usize],
vectors[0usize][6usize],
vectors[1usize][6usize],
vectors[2usize][6usize],
vectors[3usize][6usize],
vectors[0usize][7usize],
vectors[1usize][7usize],
vectors[2usize][7usize],
vectors[3usize][7usize],
vectors[0usize][8usize],
vectors[1usize][8usize],
vectors[2usize][8usize],
vectors[3usize][8usize],
vectors[0usize][9usize],
vectors[1usize][9usize],
vectors[2usize][9usize],
vectors[3usize][9usize],
vectors[0usize][10usize],
vectors[1usize][10usize],
vectors[2usize][10usize],
vectors[3usize][10usize],
vectors[0usize][11usize],
vectors[1usize][11usize],
vectors[2usize][11usize],
vectors[3usize][11usize],
vectors[0usize][12usize],
vectors[1usize][12usize],
vectors[2usize][12usize],
vectors[3usize][12usize],
vectors[0usize][13usize],
vectors[1usize][13usize],
vectors[2usize][13usize],
vectors[3usize][13usize],
vectors[0usize][14usize],
vectors[1usize][14usize],
vectors[2usize][14usize],
vectors[3usize][14usize],
vectors[0usize][15usize],
vectors[1usize][15usize],
vectors[2usize][15usize],
vectors[3usize][15usize],
];
}
#[inline(always)]
fn widen_i8x16(self, a: i8x16<Self>) -> (i16x8<Self>, i16x8<Self>) {
(
[
a[0usize] as i16,
a[1usize] as i16,
a[2usize] as i16,
a[3usize] as i16,
a[4usize] as i16,
a[5usize] as i16,
a[6usize] as i16,
a[7usize] as i16,
]
.simd_into(self),
[
a[8usize] as i16,
a[9usize] as i16,
a[10usize] as i16,
a[11usize] as i16,
a[12usize] as i16,
a[13usize] as i16,
a[14usize] as i16,
a[15usize] as i16,
]
.simd_into(self),
)
}
#[inline(always)]
fn splat_u8x16(self, val: u8) -> u8x16<Self> {
[val; 16usize].simd_into(self)
}
#[inline(always)]
fn slide_u8x16<const SHIFT: usize>(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self> {
let mut dest = [Default::default(); 16usize];
dest[..16usize - SHIFT].copy_from_slice(&a.val.0[SHIFT..]);
dest[16usize - SHIFT..].copy_from_slice(&b.val.0[..SHIFT]);
dest.simd_into(self)
}
#[inline(always)]
fn swizzle_dyn_within_blocks_u8x16(self, a: u8x16<Self>, indices: u8x16<Self>) -> u8x16<Self> {
let bytes = Bytes::to_bytes(a);
let result: u8x16<Self> = [
{
let index = indices[0usize] as usize;
bytes[index % 16usize]
},
{
let index = indices[1usize] as usize;
bytes[index % 16usize]
},
{
let index = indices[2usize] as usize;
bytes[index % 16usize]
},
{
let index = indices[3usize] as usize;
bytes[index % 16usize]
},
{
let index = indices[4usize] as usize;
bytes[index % 16usize]
},
{
let index = indices[5usize] as usize;
bytes[index % 16usize]
},
{
let index = indices[6usize] as usize;
bytes[index % 16usize]
},
{
let index = indices[7usize] as usize;
bytes[index % 16usize]
},
{
let index = indices[8usize] as usize;
bytes[index % 16usize]
},
{
let index = indices[9usize] as usize;
bytes[index % 16usize]
},
{
let index = indices[10usize] as usize;
bytes[index % 16usize]
},
{
let index = indices[11usize] as usize;
bytes[index % 16usize]
},
{
let index = indices[12usize] as usize;
bytes[index % 16usize]
},
{
let index = indices[13usize] as usize;
bytes[index % 16usize]
},
{
let index = indices[14usize] as usize;
bytes[index % 16usize]
},
{
let index = indices[15usize] as usize;
bytes[index % 16usize]
},
]
.simd_into(self);
Bytes::from_bytes(result)
}
#[inline(always)]
fn swizzle_dyn_u8x16(self, a: u8x16<Self>, indices: u8x16<Self>) -> u8x16<Self> {
let bytes = Bytes::to_bytes(a);
let mut output = [0u8; 16usize];
for lane in 0..16usize {
let index = indices[lane] as usize;
output[lane] = bytes[index % 16usize];
}
let result: u8x16<Self> = output.simd_into(self);
Bytes::from_bytes(result)
}
#[inline(always)]
fn swizzle_dyn_precise_u8x16(self, a: u8x16<Self>, indices: u8x16<Self>) -> u8x16<Self> {
let bytes = Bytes::to_bytes(a);
let mut output = [0u8; 16usize];
for lane in 0..16usize {
let index = indices[lane] as usize;
let value = bytes[index % 16usize];
output[lane] = if index < 16usize { value } else { 0 };
}
let result: u8x16<Self> = output.simd_into(self);
Bytes::from_bytes(result)
}
#[inline(always)]
fn add_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self> {
[
u8::wrapping_add(a[0usize], b[0usize]),
u8::wrapping_add(a[1usize], b[1usize]),
u8::wrapping_add(a[2usize], b[2usize]),
u8::wrapping_add(a[3usize], b[3usize]),
u8::wrapping_add(a[4usize], b[4usize]),
u8::wrapping_add(a[5usize], b[5usize]),
u8::wrapping_add(a[6usize], b[6usize]),
u8::wrapping_add(a[7usize], b[7usize]),
u8::wrapping_add(a[8usize], b[8usize]),
u8::wrapping_add(a[9usize], b[9usize]),
u8::wrapping_add(a[10usize], b[10usize]),
u8::wrapping_add(a[11usize], b[11usize]),
u8::wrapping_add(a[12usize], b[12usize]),
u8::wrapping_add(a[13usize], b[13usize]),
u8::wrapping_add(a[14usize], b[14usize]),
u8::wrapping_add(a[15usize], b[15usize]),
]
.simd_into(self)
}
#[inline(always)]
fn sub_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self> {
[
u8::wrapping_sub(a[0usize], b[0usize]),
u8::wrapping_sub(a[1usize], b[1usize]),
u8::wrapping_sub(a[2usize], b[2usize]),
u8::wrapping_sub(a[3usize], b[3usize]),
u8::wrapping_sub(a[4usize], b[4usize]),
u8::wrapping_sub(a[5usize], b[5usize]),
u8::wrapping_sub(a[6usize], b[6usize]),
u8::wrapping_sub(a[7usize], b[7usize]),
u8::wrapping_sub(a[8usize], b[8usize]),
u8::wrapping_sub(a[9usize], b[9usize]),
u8::wrapping_sub(a[10usize], b[10usize]),
u8::wrapping_sub(a[11usize], b[11usize]),
u8::wrapping_sub(a[12usize], b[12usize]),
u8::wrapping_sub(a[13usize], b[13usize]),
u8::wrapping_sub(a[14usize], b[14usize]),
u8::wrapping_sub(a[15usize], b[15usize]),
]
.simd_into(self)
}
#[inline(always)]
fn mul_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self> {
[
u8::wrapping_mul(a[0usize], b[0usize]),
u8::wrapping_mul(a[1usize], b[1usize]),
u8::wrapping_mul(a[2usize], b[2usize]),
u8::wrapping_mul(a[3usize], b[3usize]),
u8::wrapping_mul(a[4usize], b[4usize]),
u8::wrapping_mul(a[5usize], b[5usize]),
u8::wrapping_mul(a[6usize], b[6usize]),
u8::wrapping_mul(a[7usize], b[7usize]),
u8::wrapping_mul(a[8usize], b[8usize]),
u8::wrapping_mul(a[9usize], b[9usize]),
u8::wrapping_mul(a[10usize], b[10usize]),
u8::wrapping_mul(a[11usize], b[11usize]),
u8::wrapping_mul(a[12usize], b[12usize]),
u8::wrapping_mul(a[13usize], b[13usize]),
u8::wrapping_mul(a[14usize], b[14usize]),
u8::wrapping_mul(a[15usize], b[15usize]),
]
.simd_into(self)
}
#[inline(always)]
fn and_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self> {
[
u8::bitand(a[0usize], &b[0usize]),
u8::bitand(a[1usize], &b[1usize]),
u8::bitand(a[2usize], &b[2usize]),
u8::bitand(a[3usize], &b[3usize]),
u8::bitand(a[4usize], &b[4usize]),
u8::bitand(a[5usize], &b[5usize]),
u8::bitand(a[6usize], &b[6usize]),
u8::bitand(a[7usize], &b[7usize]),
u8::bitand(a[8usize], &b[8usize]),
u8::bitand(a[9usize], &b[9usize]),
u8::bitand(a[10usize], &b[10usize]),
u8::bitand(a[11usize], &b[11usize]),
u8::bitand(a[12usize], &b[12usize]),
u8::bitand(a[13usize], &b[13usize]),
u8::bitand(a[14usize], &b[14usize]),
u8::bitand(a[15usize], &b[15usize]),
]
.simd_into(self)
}
#[inline(always)]
fn or_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self> {
[
u8::bitor(a[0usize], &b[0usize]),
u8::bitor(a[1usize], &b[1usize]),
u8::bitor(a[2usize], &b[2usize]),
u8::bitor(a[3usize], &b[3usize]),
u8::bitor(a[4usize], &b[4usize]),
u8::bitor(a[5usize], &b[5usize]),
u8::bitor(a[6usize], &b[6usize]),
u8::bitor(a[7usize], &b[7usize]),
u8::bitor(a[8usize], &b[8usize]),
u8::bitor(a[9usize], &b[9usize]),
u8::bitor(a[10usize], &b[10usize]),
u8::bitor(a[11usize], &b[11usize]),
u8::bitor(a[12usize], &b[12usize]),
u8::bitor(a[13usize], &b[13usize]),
u8::bitor(a[14usize], &b[14usize]),
u8::bitor(a[15usize], &b[15usize]),
]
.simd_into(self)
}
#[inline(always)]
fn xor_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self> {
[
u8::bitxor(a[0usize], &b[0usize]),
u8::bitxor(a[1usize], &b[1usize]),
u8::bitxor(a[2usize], &b[2usize]),
u8::bitxor(a[3usize], &b[3usize]),
u8::bitxor(a[4usize], &b[4usize]),
u8::bitxor(a[5usize], &b[5usize]),
u8::bitxor(a[6usize], &b[6usize]),
u8::bitxor(a[7usize], &b[7usize]),
u8::bitxor(a[8usize], &b[8usize]),
u8::bitxor(a[9usize], &b[9usize]),
u8::bitxor(a[10usize], &b[10usize]),
u8::bitxor(a[11usize], &b[11usize]),
u8::bitxor(a[12usize], &b[12usize]),
u8::bitxor(a[13usize], &b[13usize]),
u8::bitxor(a[14usize], &b[14usize]),
u8::bitxor(a[15usize], &b[15usize]),
]
.simd_into(self)
}
#[inline(always)]
fn not_u8x16(self, a: u8x16<Self>) -> u8x16<Self> {
[
u8::not(a[0usize]),
u8::not(a[1usize]),
u8::not(a[2usize]),
u8::not(a[3usize]),
u8::not(a[4usize]),
u8::not(a[5usize]),
u8::not(a[6usize]),
u8::not(a[7usize]),
u8::not(a[8usize]),
u8::not(a[9usize]),
u8::not(a[10usize]),
u8::not(a[11usize]),
u8::not(a[12usize]),
u8::not(a[13usize]),
u8::not(a[14usize]),
u8::not(a[15usize]),
]
.simd_into(self)
}
#[inline(always)]
fn shl_u8x16(self, a: u8x16<Self>, shift: u32) -> u8x16<Self> {
[
u8::wrapping_shl(a[0usize], shift),
u8::wrapping_shl(a[1usize], shift),
u8::wrapping_shl(a[2usize], shift),
u8::wrapping_shl(a[3usize], shift),
u8::wrapping_shl(a[4usize], shift),
u8::wrapping_shl(a[5usize], shift),
u8::wrapping_shl(a[6usize], shift),
u8::wrapping_shl(a[7usize], shift),
u8::wrapping_shl(a[8usize], shift),
u8::wrapping_shl(a[9usize], shift),
u8::wrapping_shl(a[10usize], shift),
u8::wrapping_shl(a[11usize], shift),
u8::wrapping_shl(a[12usize], shift),
u8::wrapping_shl(a[13usize], shift),
u8::wrapping_shl(a[14usize], shift),
u8::wrapping_shl(a[15usize], shift),
]
.simd_into(self)
}
#[inline(always)]
fn shlv_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self> {
[
u8::wrapping_shl(a[0usize], b[0usize] as u32),
u8::wrapping_shl(a[1usize], b[1usize] as u32),
u8::wrapping_shl(a[2usize], b[2usize] as u32),
u8::wrapping_shl(a[3usize], b[3usize] as u32),
u8::wrapping_shl(a[4usize], b[4usize] as u32),
u8::wrapping_shl(a[5usize], b[5usize] as u32),
u8::wrapping_shl(a[6usize], b[6usize] as u32),
u8::wrapping_shl(a[7usize], b[7usize] as u32),
u8::wrapping_shl(a[8usize], b[8usize] as u32),
u8::wrapping_shl(a[9usize], b[9usize] as u32),
u8::wrapping_shl(a[10usize], b[10usize] as u32),
u8::wrapping_shl(a[11usize], b[11usize] as u32),
u8::wrapping_shl(a[12usize], b[12usize] as u32),
u8::wrapping_shl(a[13usize], b[13usize] as u32),
u8::wrapping_shl(a[14usize], b[14usize] as u32),
u8::wrapping_shl(a[15usize], b[15usize] as u32),
]
.simd_into(self)
}
#[inline(always)]
fn shr_u8x16(self, a: u8x16<Self>, shift: u32) -> u8x16<Self> {
[
u8::wrapping_shr(a[0usize], shift),
u8::wrapping_shr(a[1usize], shift),
u8::wrapping_shr(a[2usize], shift),
u8::wrapping_shr(a[3usize], shift),
u8::wrapping_shr(a[4usize], shift),
u8::wrapping_shr(a[5usize], shift),
u8::wrapping_shr(a[6usize], shift),
u8::wrapping_shr(a[7usize], shift),
u8::wrapping_shr(a[8usize], shift),
u8::wrapping_shr(a[9usize], shift),
u8::wrapping_shr(a[10usize], shift),
u8::wrapping_shr(a[11usize], shift),
u8::wrapping_shr(a[12usize], shift),
u8::wrapping_shr(a[13usize], shift),
u8::wrapping_shr(a[14usize], shift),
u8::wrapping_shr(a[15usize], shift),
]
.simd_into(self)
}
#[inline(always)]
fn shrv_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self> {
[
u8::wrapping_shr(a[0usize], b[0usize] as u32),
u8::wrapping_shr(a[1usize], b[1usize] as u32),
u8::wrapping_shr(a[2usize], b[2usize] as u32),
u8::wrapping_shr(a[3usize], b[3usize] as u32),
u8::wrapping_shr(a[4usize], b[4usize] as u32),
u8::wrapping_shr(a[5usize], b[5usize] as u32),
u8::wrapping_shr(a[6usize], b[6usize] as u32),
u8::wrapping_shr(a[7usize], b[7usize] as u32),
u8::wrapping_shr(a[8usize], b[8usize] as u32),
u8::wrapping_shr(a[9usize], b[9usize] as u32),
u8::wrapping_shr(a[10usize], b[10usize] as u32),
u8::wrapping_shr(a[11usize], b[11usize] as u32),
u8::wrapping_shr(a[12usize], b[12usize] as u32),
u8::wrapping_shr(a[13usize], b[13usize] as u32),
u8::wrapping_shr(a[14usize], b[14usize] as u32),
u8::wrapping_shr(a[15usize], b[15usize] as u32),
]
.simd_into(self)
}
#[inline(always)]
fn max_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self> {
[
u8::max(a[0usize], b[0usize]),
u8::max(a[1usize], b[1usize]),
u8::max(a[2usize], b[2usize]),
u8::max(a[3usize], b[3usize]),
u8::max(a[4usize], b[4usize]),
u8::max(a[5usize], b[5usize]),
u8::max(a[6usize], b[6usize]),
u8::max(a[7usize], b[7usize]),
u8::max(a[8usize], b[8usize]),
u8::max(a[9usize], b[9usize]),
u8::max(a[10usize], b[10usize]),
u8::max(a[11usize], b[11usize]),
u8::max(a[12usize], b[12usize]),
u8::max(a[13usize], b[13usize]),
u8::max(a[14usize], b[14usize]),
u8::max(a[15usize], b[15usize]),
]
.simd_into(self)
}
#[inline(always)]
fn min_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self> {
[
u8::min(a[0usize], b[0usize]),
u8::min(a[1usize], b[1usize]),
u8::min(a[2usize], b[2usize]),
u8::min(a[3usize], b[3usize]),
u8::min(a[4usize], b[4usize]),
u8::min(a[5usize], b[5usize]),
u8::min(a[6usize], b[6usize]),
u8::min(a[7usize], b[7usize]),
u8::min(a[8usize], b[8usize]),
u8::min(a[9usize], b[9usize]),
u8::min(a[10usize], b[10usize]),
u8::min(a[11usize], b[11usize]),
u8::min(a[12usize], b[12usize]),
u8::min(a[13usize], b[13usize]),
u8::min(a[14usize], b[14usize]),
u8::min(a[15usize], b[15usize]),
]
.simd_into(self)
}
#[inline(always)]
fn simd_eq_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> mask8x16<Self> {
[
-(u8::eq(&a[0usize], &b[0usize]) as i8),
-(u8::eq(&a[1usize], &b[1usize]) as i8),
-(u8::eq(&a[2usize], &b[2usize]) as i8),
-(u8::eq(&a[3usize], &b[3usize]) as i8),
-(u8::eq(&a[4usize], &b[4usize]) as i8),
-(u8::eq(&a[5usize], &b[5usize]) as i8),
-(u8::eq(&a[6usize], &b[6usize]) as i8),
-(u8::eq(&a[7usize], &b[7usize]) as i8),
-(u8::eq(&a[8usize], &b[8usize]) as i8),
-(u8::eq(&a[9usize], &b[9usize]) as i8),
-(u8::eq(&a[10usize], &b[10usize]) as i8),
-(u8::eq(&a[11usize], &b[11usize]) as i8),
-(u8::eq(&a[12usize], &b[12usize]) as i8),
-(u8::eq(&a[13usize], &b[13usize]) as i8),
-(u8::eq(&a[14usize], &b[14usize]) as i8),
-(u8::eq(&a[15usize], &b[15usize]) as i8),
]
.simd_into(self)
}
#[inline(always)]
fn simd_lt_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> mask8x16<Self> {
[
-(u8::lt(&a[0usize], &b[0usize]) as i8),
-(u8::lt(&a[1usize], &b[1usize]) as i8),
-(u8::lt(&a[2usize], &b[2usize]) as i8),
-(u8::lt(&a[3usize], &b[3usize]) as i8),
-(u8::lt(&a[4usize], &b[4usize]) as i8),
-(u8::lt(&a[5usize], &b[5usize]) as i8),
-(u8::lt(&a[6usize], &b[6usize]) as i8),
-(u8::lt(&a[7usize], &b[7usize]) as i8),
-(u8::lt(&a[8usize], &b[8usize]) as i8),
-(u8::lt(&a[9usize], &b[9usize]) as i8),
-(u8::lt(&a[10usize], &b[10usize]) as i8),
-(u8::lt(&a[11usize], &b[11usize]) as i8),
-(u8::lt(&a[12usize], &b[12usize]) as i8),
-(u8::lt(&a[13usize], &b[13usize]) as i8),
-(u8::lt(&a[14usize], &b[14usize]) as i8),
-(u8::lt(&a[15usize], &b[15usize]) as i8),
]
.simd_into(self)
}
#[inline(always)]
fn simd_le_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> mask8x16<Self> {
[
-(u8::le(&a[0usize], &b[0usize]) as i8),
-(u8::le(&a[1usize], &b[1usize]) as i8),
-(u8::le(&a[2usize], &b[2usize]) as i8),
-(u8::le(&a[3usize], &b[3usize]) as i8),
-(u8::le(&a[4usize], &b[4usize]) as i8),
-(u8::le(&a[5usize], &b[5usize]) as i8),
-(u8::le(&a[6usize], &b[6usize]) as i8),
-(u8::le(&a[7usize], &b[7usize]) as i8),
-(u8::le(&a[8usize], &b[8usize]) as i8),
-(u8::le(&a[9usize], &b[9usize]) as i8),
-(u8::le(&a[10usize], &b[10usize]) as i8),
-(u8::le(&a[11usize], &b[11usize]) as i8),
-(u8::le(&a[12usize], &b[12usize]) as i8),
-(u8::le(&a[13usize], &b[13usize]) as i8),
-(u8::le(&a[14usize], &b[14usize]) as i8),
-(u8::le(&a[15usize], &b[15usize]) as i8),
]
.simd_into(self)
}
#[inline(always)]
fn zip_low_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self> {
[
a[0usize], b[0usize], a[1usize], b[1usize], a[2usize], b[2usize], a[3usize], b[3usize],
a[4usize], b[4usize], a[5usize], b[5usize], a[6usize], b[6usize], a[7usize], b[7usize],
]
.simd_into(self)
}
#[inline(always)]
fn zip_high_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self> {
[
a[8usize], b[8usize], a[9usize], b[9usize], a[10usize], b[10usize], a[11usize],
b[11usize], a[12usize], b[12usize], a[13usize], b[13usize], a[14usize], b[14usize],
a[15usize], b[15usize],
]
.simd_into(self)
}
#[inline(always)]
fn unzip_low_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self> {
[
a[0usize], a[2usize], a[4usize], a[6usize], a[8usize], a[10usize], a[12usize],
a[14usize], b[0usize], b[2usize], b[4usize], b[6usize], b[8usize], b[10usize],
b[12usize], b[14usize],
]
.simd_into(self)
}
#[inline(always)]
fn unzip_high_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x16<Self> {
[
a[1usize], a[3usize], a[5usize], a[7usize], a[9usize], a[11usize], a[13usize],
a[15usize], b[1usize], b[3usize], b[5usize], b[7usize], b[9usize], b[11usize],
b[13usize], b[15usize],
]
.simd_into(self)
}
#[inline(always)]
fn interleave_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> (u8x16<Self>, u8x16<Self>) {
(self.zip_low_u8x16(a, b), self.zip_high_u8x16(a, b))
}
#[inline(always)]
fn deinterleave_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> (u8x16<Self>, u8x16<Self>) {
(self.unzip_low_u8x16(a, b), self.unzip_high_u8x16(a, b))
}
#[inline(always)]
fn select_u8x16(self, a: mask8x16<Self>, b: u8x16<Self>, c: u8x16<Self>) -> u8x16<Self> {
[
if a.val.0[0usize] != 0 {
b[0usize]
} else {
c[0usize]
},
if a.val.0[1usize] != 0 {
b[1usize]
} else {
c[1usize]
},
if a.val.0[2usize] != 0 {
b[2usize]
} else {
c[2usize]
},
if a.val.0[3usize] != 0 {
b[3usize]
} else {
c[3usize]
},
if a.val.0[4usize] != 0 {
b[4usize]
} else {
c[4usize]
},
if a.val.0[5usize] != 0 {
b[5usize]
} else {
c[5usize]
},
if a.val.0[6usize] != 0 {
b[6usize]
} else {
c[6usize]
},
if a.val.0[7usize] != 0 {
b[7usize]
} else {
c[7usize]
},
if a.val.0[8usize] != 0 {
b[8usize]
} else {
c[8usize]
},
if a.val.0[9usize] != 0 {
b[9usize]
} else {
c[9usize]
},
if a.val.0[10usize] != 0 {
b[10usize]
} else {
c[10usize]
},
if a.val.0[11usize] != 0 {
b[11usize]
} else {
c[11usize]
},
if a.val.0[12usize] != 0 {
b[12usize]
} else {
c[12usize]
},
if a.val.0[13usize] != 0 {
b[13usize]
} else {
c[13usize]
},
if a.val.0[14usize] != 0 {
b[14usize]
} else {
c[14usize]
},
if a.val.0[15usize] != 0 {
b[15usize]
} else {
c[15usize]
},
]
.simd_into(self)
}
#[inline(always)]
fn combine_u8x16(self, a: u8x16<Self>, b: u8x16<Self>) -> u8x32<Self> {
let mut result = [0; 32usize];
result[0..16usize].copy_from_slice(&a.val.0);
result[16usize..32usize].copy_from_slice(&b.val.0);
result.simd_into(self)
}
#[inline(always)]
fn load_four_interleaved_u8x16(self, src: &[u8; 64usize]) -> [u8x16<Self>; 4usize] {
[
[
src[0usize],
src[4usize],
src[8usize],
src[12usize],
src[16usize],
src[20usize],
src[24usize],
src[28usize],
src[32usize],
src[36usize],
src[40usize],
src[44usize],
src[48usize],
src[52usize],
src[56usize],
src[60usize],
]
.simd_into(self),
[
src[1usize],
src[5usize],
src[9usize],
src[13usize],
src[17usize],
src[21usize],
src[25usize],
src[29usize],
src[33usize],
src[37usize],
src[41usize],
src[45usize],
src[49usize],
src[53usize],
src[57usize],
src[61usize],
]
.simd_into(self),
[
src[2usize],
src[6usize],
src[10usize],
src[14usize],
src[18usize],
src[22usize],
src[26usize],
src[30usize],
src[34usize],
src[38usize],
src[42usize],
src[46usize],
src[50usize],
src[54usize],
src[58usize],
src[62usize],
]
.simd_into(self),
[
src[3usize],
src[7usize],
src[11usize],
src[15usize],
src[19usize],
src[23usize],
src[27usize],
src[31usize],
src[35usize],
src[39usize],
src[43usize],
src[47usize],
src[51usize],
src[55usize],
src[59usize],
src[63usize],
]
.simd_into(self),
]
}
#[inline(always)]
fn store_four_interleaved_u8x16(
self,
vectors: [u8x16<Self>; 4usize],
dest: &mut [u8; 64usize],
) -> () {
*dest = [
vectors[0usize][0usize],
vectors[1usize][0usize],
vectors[2usize][0usize],
vectors[3usize][0usize],
vectors[0usize][1usize],
vectors[1usize][1usize],
vectors[2usize][1usize],
vectors[3usize][1usize],
vectors[0usize][2usize],
vectors[1usize][2usize],
vectors[2usize][2usize],
vectors[3usize][2usize],
vectors[0usize][3usize],
vectors[1usize][3usize],
vectors[2usize][3usize],
vectors[3usize][3usize],
vectors[0usize][4usize],
vectors[1usize][4usize],
vectors[2usize][4usize],
vectors[3usize][4usize],
vectors[0usize][5usize],
vectors[1usize][5usize],
vectors[2usize][5usize],
vectors[3usize][5usize],
vectors[0usize][6usize],
vectors[1usize][6usize],
vectors[2usize][6usize],
vectors[3usize][6usize],
vectors[0usize][7usize],
vectors[1usize][7usize],
vectors[2usize][7usize],
vectors[3usize][7usize],
vectors[0usize][8usize],
vectors[1usize][8usize],
vectors[2usize][8usize],
vectors[3usize][8usize],
vectors[0usize][9usize],
vectors[1usize][9usize],
vectors[2usize][9usize],
vectors[3usize][9usize],
vectors[0usize][10usize],
vectors[1usize][10usize],
vectors[2usize][10usize],
vectors[3usize][10usize],
vectors[0usize][11usize],
vectors[1usize][11usize],
vectors[2usize][11usize],
vectors[3usize][11usize],
vectors[0usize][12usize],
vectors[1usize][12usize],
vectors[2usize][12usize],
vectors[3usize][12usize],
vectors[0usize][13usize],
vectors[1usize][13usize],
vectors[2usize][13usize],
vectors[3usize][13usize],
vectors[0usize][14usize],
vectors[1usize][14usize],
vectors[2usize][14usize],
vectors[3usize][14usize],
vectors[0usize][15usize],
vectors[1usize][15usize],
vectors[2usize][15usize],
vectors[3usize][15usize],
];
}
#[inline(always)]
fn widen_u8x16(self, a: u8x16<Self>) -> (u16x8<Self>, u16x8<Self>) {
(
[
a[0usize] as u16,
a[1usize] as u16,
a[2usize] as u16,
a[3usize] as u16,
a[4usize] as u16,
a[5usize] as u16,
a[6usize] as u16,
a[7usize] as u16,
]
.simd_into(self),
[
a[8usize] as u16,
a[9usize] as u16,
a[10usize] as u16,
a[11usize] as u16,
a[12usize] as u16,
a[13usize] as u16,
a[14usize] as u16,
a[15usize] as u16,
]
.simd_into(self),
)
}
#[inline(always)]
fn splat_mask8x16(self, val: bool) -> mask8x16<Self> {
let val: i8 = if val { !0 } else { 0 };
[val; 16usize].simd_into(self)
}
#[inline(always)]
fn from_bitmask_mask8x16(self, bits: u64) -> mask8x16<Self> {
let lanes: [i8; 16usize] = [
if bits & 1 != 0 { !0 } else { 0 },
if (bits >> 1usize) & 1 != 0 { !0 } else { 0 },
if (bits >> 2usize) & 1 != 0 { !0 } else { 0 },
if (bits >> 3usize) & 1 != 0 { !0 } else { 0 },
if (bits >> 4usize) & 1 != 0 { !0 } else { 0 },
if (bits >> 5usize) & 1 != 0 { !0 } else { 0 },
if (bits >> 6usize) & 1 != 0 { !0 } else { 0 },
if (bits >> 7usize) & 1 != 0 { !0 } else { 0 },
if (bits >> 8usize) & 1 != 0 { !0 } else { 0 },
if (bits >> 9usize) & 1 != 0 { !0 } else { 0 },
if (bits >> 10usize) & 1 != 0 { !0 } else { 0 },
if (bits >> 11usize) & 1 != 0 { !0 } else { 0 },
if (bits >> 12usize) & 1 != 0 { !0 } else { 0 },
if (bits >> 13usize) & 1 != 0 { !0 } else { 0 },
if (bits >> 14usize) & 1 != 0 { !0 } else { 0 },
if (bits >> 15usize) & 1 != 0 { !0 } else { 0 },
];
lanes.simd_into(self)
}
#[inline(always)]
fn to_bitmask_mask8x16(self, a: mask8x16<Self>) -> u64 {
let lanes: [i8; 16usize] = a.into();
let mut bits = 0u64;
let mut i = 0;
while i < 16usize {
if lanes[i] != 0 {
bits |= 1u64 << i;
}
i += 1;
}
bits
}
#[inline(always)]
fn set_mask8x16(self, a: &mut mask8x16<Self>, index: usize, value: bool) -> () {
assert!(
index < 16usize,
"mask lane index {index} is out of bounds for {} lanes",
16usize
);
let mut lanes: [i8; 16usize] = (*a).into();
lanes[index] = if value { !0 } else { 0 };
*a = lanes.simd_into(self);
}
#[inline(always)]
fn and_mask8x16(self, a: mask8x16<Self>, b: mask8x16<Self>) -> mask8x16<Self> {
[
i8::bitand(a.val.0[0usize], &b.val.0[0usize]),
i8::bitand(a.val.0[1usize], &b.val.0[1usize]),
i8::bitand(a.val.0[2usize], &b.val.0[2usize]),
i8::bitand(a.val.0[3usize], &b.val.0[3usize]),
i8::bitand(a.val.0[4usize], &b.val.0[4usize]),
i8::bitand(a.val.0[5usize], &b.val.0[5usize]),
i8::bitand(a.val.0[6usize], &b.val.0[6usize]),
i8::bitand(a.val.0[7usize], &b.val.0[7usize]),
i8::bitand(a.val.0[8usize], &b.val.0[8usize]),
i8::bitand(a.val.0[9usize], &b.val.0[9usize]),
i8::bitand(a.val.0[10usize], &b.val.0[10usize]),
i8::bitand(a.val.0[11usize], &b.val.0[11usize]),
i8::bitand(a.val.0[12usize], &b.val.0[12usize]),
i8::bitand(a.val.0[13usize], &b.val.0[13usize]),
i8::bitand(a.val.0[14usize], &b.val.0[14usize]),
i8::bitand(a.val.0[15usize], &b.val.0[15usize]),
]
.simd_into(self)
}
#[inline(always)]
fn or_mask8x16(self, a: mask8x16<Self>, b: mask8x16<Self>) -> mask8x16<Self> {
[
i8::bitor(a.val.0[0usize], &b.val.0[0usize]),
i8::bitor(a.val.0[1usize], &b.val.0[1usize]),
i8::bitor(a.val.0[2usize], &b.val.0[2usize]),
i8::bitor(a.val.0[3usize], &b.val.0[3usize]),
i8::bitor(a.val.0[4usize], &b.val.0[4usize]),
i8::bitor(a.val.0[5usize], &b.val.0[5usize]),
i8::bitor(a.val.0[6usize], &b.val.0[6usize]),
i8::bitor(a.val.0[7usize], &b.val.0[7usize]),
i8::bitor(a.val.0[8usize], &b.val.0[8usize]),
i8::bitor(a.val.0[9usize], &b.val.0[9usize]),
i8::bitor(a.val.0[10usize], &b.val.0[10usize]),
i8::bitor(a.val.0[11usize], &b.val.0[11usize]),
i8::bitor(a.val.0[12usize], &b.val.0[12usize]),
i8::bitor(a.val.0[13usize], &b.val.0[13usize]),
i8::bitor(a.val.0[14usize], &b.val.0[14usize]),
i8::bitor(a.val.0[15usize], &b.val.0[15usize]),
]
.simd_into(self)
}
#[inline(always)]
fn xor_mask8x16(self, a: mask8x16<Self>, b: mask8x16<Self>) -> mask8x16<Self> {
[
i8::bitxor(a.val.0[0usize], &b.val.0[0usize]),
i8::bitxor(a.val.0[1usize], &b.val.0[1usize]),
i8::bitxor(a.val.0[2usize], &b.val.0[2usize]),
i8::bitxor(a.val.0[3usize], &b.val.0[3usize]),
i8::bitxor(a.val.0[4usize], &b.val.0[4usize]),
i8::bitxor(a.val.0[5usize], &b.val.0[5usize]),
i8::bitxor(a.val.0[6usize], &b.val.0[6usize]),
i8::bitxor(a.val.0[7usize], &b.val.0[7usize]),
i8::bitxor(a.val.0[8usize], &b.val.0[8usize]),
i8::bitxor(a.val.0[9usize], &b.val.0[9usize]),
i8::bitxor(a.val.0[10usize], &b.val.0[10usize]),
i8::bitxor(a.val.0[11usize], &b.val.0[11usize]),
i8::bitxor(a.val.0[12usize], &b.val.0[12usize]),
i8::bitxor(a.val.0[13usize], &b.val.0[13usize]),
i8::bitxor(a.val.0[14usize], &b.val.0[14usize]),
i8::bitxor(a.val.0[15usize], &b.val.0[15usize]),
]
.simd_into(self)
}
#[inline(always)]
fn not_mask8x16(self, a: mask8x16<Self>) -> mask8x16<Self> {
[
i8::not(a.val.0[0usize]),
i8::not(a.val.0[1usize]),
i8::not(a.val.0[2usize]),
i8::not(a.val.0[3usize]),
i8::not(a.val.0[4usize]),
i8::not(a.val.0[5usize]),
i8::not(a.val.0[6usize]),
i8::not(a.val.0[7usize]),
i8::not(a.val.0[8usize]),
i8::not(a.val.0[9usize]),
i8::not(a.val.0[10usize]),
i8::not(a.val.0[11usize]),
i8::not(a.val.0[12usize]),
i8::not(a.val.0[13usize]),
i8::not(a.val.0[14usize]),
i8::not(a.val.0[15usize]),
]
.simd_into(self)
}
#[inline(always)]
fn select_mask8x16(
self,
a: mask8x16<Self>,
b: mask8x16<Self>,
c: mask8x16<Self>,
) -> mask8x16<Self> {
[
if a.val.0[0usize] != 0 {
b.val.0[0usize]
} else {
c.val.0[0usize]
},
if a.val.0[1usize] != 0 {
b.val.0[1usize]
} else {
c.val.0[1usize]
},
if a.val.0[2usize] != 0 {
b.val.0[2usize]
} else {
c.val.0[2usize]
},
if a.val.0[3usize] != 0 {
b.val.0[3usize]
} else {
c.val.0[3usize]
},
if a.val.0[4usize] != 0 {
b.val.0[4usize]
} else {
c.val.0[4usize]
},
if a.val.0[5usize] != 0 {
b.val.0[5usize]
} else {
c.val.0[5usize]
},
if a.val.0[6usize] != 0 {
b.val.0[6usize]
} else {
c.val.0[6usize]
},
if a.val.0[7usize] != 0 {
b.val.0[7usize]
} else {
c.val.0[7usize]
},
if a.val.0[8usize] != 0 {
b.val.0[8usize]
} else {
c.val.0[8usize]
},
if a.val.0[9usize] != 0 {
b.val.0[9usize]
} else {
c.val.0[9usize]
},
if a.val.0[10usize] != 0 {
b.val.0[10usize]
} else {
c.val.0[10usize]
},
if a.val.0[11usize] != 0 {
b.val.0[11usize]
} else {
c.val.0[11usize]
},
if a.val.0[12usize] != 0 {
b.val.0[12usize]
} else {
c.val.0[12usize]
},
if a.val.0[13usize] != 0 {
b.val.0[13usize]
} else {
c.val.0[13usize]
},
if a.val.0[14usize] != 0 {
b.val.0[14usize]
} else {
c.val.0[14usize]
},
if a.val.0[15usize] != 0 {
b.val.0[15usize]
} else {
c.val.0[15usize]
},
]
.simd_into(self)
}
#[inline(always)]
fn simd_eq_mask8x16(self, a: mask8x16<Self>, b: mask8x16<Self>) -> mask8x16<Self> {
[
-(i8::eq(&a.val.0[0usize], &b.val.0[0usize]) as i8),
-(i8::eq(&a.val.0[1usize], &b.val.0[1usize]) as i8),
-(i8::eq(&a.val.0[2usize], &b.val.0[2usize]) as i8),
-(i8::eq(&a.val.0[3usize], &b.val.0[3usize]) as i8),
-(i8::eq(&a.val.0[4usize], &b.val.0[4usize]) as i8),
-(i8::eq(&a.val.0[5usize], &b.val.0[5usize]) as i8),
-(i8::eq(&a.val.0[6usize], &b.val.0[6usize]) as i8),
-(i8::eq(&a.val.0[7usize], &b.val.0[7usize]) as i8),
-(i8::eq(&a.val.0[8usize], &b.val.0[8usize]) as i8),
-(i8::eq(&a.val.0[9usize], &b.val.0[9usize]) as i8),
-(i8::eq(&a.val.0[10usize], &b.val.0[10usize]) as i8),
-(i8::eq(&a.val.0[11usize], &b.val.0[11usize]) as i8),
-(i8::eq(&a.val.0[12usize], &b.val.0[12usize]) as i8),
-(i8::eq(&a.val.0[13usize], &b.val.0[13usize]) as i8),
-(i8::eq(&a.val.0[14usize], &b.val.0[14usize]) as i8),
-(i8::eq(&a.val.0[15usize], &b.val.0[15usize]) as i8),
]
.simd_into(self)
}
#[inline(always)]
fn any_true_mask8x16(self, a: mask8x16<Self>) -> bool {
a.val.0[0usize] != 0
|| a.val.0[1usize] != 0
|| a.val.0[2usize] != 0
|| a.val.0[3usize] != 0
|| a.val.0[4usize] != 0
|| a.val.0[5usize] != 0
|| a.val.0[6usize] != 0
|| a.val.0[7usize] != 0
|| a.val.0[8usize] != 0
|| a.val.0[9usize] != 0
|| a.val.0[10usize] != 0
|| a.val.0[11usize] != 0
|| a.val.0[12usize] != 0
|| a.val.0[13usize] != 0
|| a.val.0[14usize] != 0
|| a.val.0[15usize] != 0
}
#[inline(always)]
fn all_true_mask8x16(self, a: mask8x16<Self>) -> bool {
a.val.0[0usize] != 0
&& a.val.0[1usize] != 0
&& a.val.0[2usize] != 0
&& a.val.0[3usize] != 0
&& a.val.0[4usize] != 0
&& a.val.0[5usize] != 0
&& a.val.0[6usize] != 0
&& a.val.0[7usize] != 0
&& a.val.0[8usize] != 0
&& a.val.0[9usize] != 0
&& a.val.0[10usize] != 0
&& a.val.0[11usize] != 0
&& a.val.0[12usize] != 0
&& a.val.0[13usize] != 0
&& a.val.0[14usize] != 0
&& a.val.0[15usize] != 0
}
#[inline(always)]
fn any_false_mask8x16(self, a: mask8x16<Self>) -> bool {
a.val.0[0usize] == 0
|| a.val.0[1usize] == 0
|| a.val.0[2usize] == 0
|| a.val.0[3usize] == 0
|| a.val.0[4usize] == 0
|| a.val.0[5usize] == 0
|| a.val.0[6usize] == 0
|| a.val.0[7usize] == 0
|| a.val.0[8usize] == 0
|| a.val.0[9usize] == 0
|| a.val.0[10usize] == 0
|| a.val.0[11usize] == 0
|| a.val.0[12usize] == 0
|| a.val.0[13usize] == 0
|| a.val.0[14usize] == 0
|| a.val.0[15usize] == 0
}
#[inline(always)]
fn all_false_mask8x16(self, a: mask8x16<Self>) -> bool {
a.val.0[0usize] == 0
&& a.val.0[1usize] == 0
&& a.val.0[2usize] == 0
&& a.val.0[3usize] == 0
&& a.val.0[4usize] == 0
&& a.val.0[5usize] == 0
&& a.val.0[6usize] == 0
&& a.val.0[7usize] == 0
&& a.val.0[8usize] == 0
&& a.val.0[9usize] == 0
&& a.val.0[10usize] == 0
&& a.val.0[11usize] == 0
&& a.val.0[12usize] == 0
&& a.val.0[13usize] == 0
&& a.val.0[14usize] == 0
&& a.val.0[15usize] == 0
}
#[inline(always)]
fn combine_mask8x16(self, a: mask8x16<Self>, b: mask8x16<Self>) -> mask8x32<Self> {
let mut result = [0; 32usize];
result[0..16usize].copy_from_slice(&a.val.0);
result[16usize..32usize].copy_from_slice(&b.val.0);
result.simd_into(self)
}
#[inline(always)]
fn splat_i16x8(self, val: i16) -> i16x8<Self> {
[val; 8usize].simd_into(self)
}
#[inline(always)]
fn slide_i16x8<const SHIFT: usize>(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self> {
let mut dest = [Default::default(); 8usize];
dest[..8usize - SHIFT].copy_from_slice(&a.val.0[SHIFT..]);
dest[8usize - SHIFT..].copy_from_slice(&b.val.0[..SHIFT]);
dest.simd_into(self)
}
#[inline(always)]
fn add_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self> {
[
i16::wrapping_add(a[0usize], b[0usize]),
i16::wrapping_add(a[1usize], b[1usize]),
i16::wrapping_add(a[2usize], b[2usize]),
i16::wrapping_add(a[3usize], b[3usize]),
i16::wrapping_add(a[4usize], b[4usize]),
i16::wrapping_add(a[5usize], b[5usize]),
i16::wrapping_add(a[6usize], b[6usize]),
i16::wrapping_add(a[7usize], b[7usize]),
]
.simd_into(self)
}
#[inline(always)]
fn sub_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self> {
[
i16::wrapping_sub(a[0usize], b[0usize]),
i16::wrapping_sub(a[1usize], b[1usize]),
i16::wrapping_sub(a[2usize], b[2usize]),
i16::wrapping_sub(a[3usize], b[3usize]),
i16::wrapping_sub(a[4usize], b[4usize]),
i16::wrapping_sub(a[5usize], b[5usize]),
i16::wrapping_sub(a[6usize], b[6usize]),
i16::wrapping_sub(a[7usize], b[7usize]),
]
.simd_into(self)
}
#[inline(always)]
fn mul_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self> {
[
i16::wrapping_mul(a[0usize], b[0usize]),
i16::wrapping_mul(a[1usize], b[1usize]),
i16::wrapping_mul(a[2usize], b[2usize]),
i16::wrapping_mul(a[3usize], b[3usize]),
i16::wrapping_mul(a[4usize], b[4usize]),
i16::wrapping_mul(a[5usize], b[5usize]),
i16::wrapping_mul(a[6usize], b[6usize]),
i16::wrapping_mul(a[7usize], b[7usize]),
]
.simd_into(self)
}
#[inline(always)]
fn and_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self> {
[
i16::bitand(a[0usize], &b[0usize]),
i16::bitand(a[1usize], &b[1usize]),
i16::bitand(a[2usize], &b[2usize]),
i16::bitand(a[3usize], &b[3usize]),
i16::bitand(a[4usize], &b[4usize]),
i16::bitand(a[5usize], &b[5usize]),
i16::bitand(a[6usize], &b[6usize]),
i16::bitand(a[7usize], &b[7usize]),
]
.simd_into(self)
}
#[inline(always)]
fn or_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self> {
[
i16::bitor(a[0usize], &b[0usize]),
i16::bitor(a[1usize], &b[1usize]),
i16::bitor(a[2usize], &b[2usize]),
i16::bitor(a[3usize], &b[3usize]),
i16::bitor(a[4usize], &b[4usize]),
i16::bitor(a[5usize], &b[5usize]),
i16::bitor(a[6usize], &b[6usize]),
i16::bitor(a[7usize], &b[7usize]),
]
.simd_into(self)
}
#[inline(always)]
fn xor_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self> {
[
i16::bitxor(a[0usize], &b[0usize]),
i16::bitxor(a[1usize], &b[1usize]),
i16::bitxor(a[2usize], &b[2usize]),
i16::bitxor(a[3usize], &b[3usize]),
i16::bitxor(a[4usize], &b[4usize]),
i16::bitxor(a[5usize], &b[5usize]),
i16::bitxor(a[6usize], &b[6usize]),
i16::bitxor(a[7usize], &b[7usize]),
]
.simd_into(self)
}
#[inline(always)]
fn not_i16x8(self, a: i16x8<Self>) -> i16x8<Self> {
[
i16::not(a[0usize]),
i16::not(a[1usize]),
i16::not(a[2usize]),
i16::not(a[3usize]),
i16::not(a[4usize]),
i16::not(a[5usize]),
i16::not(a[6usize]),
i16::not(a[7usize]),
]
.simd_into(self)
}
#[inline(always)]
fn shl_i16x8(self, a: i16x8<Self>, shift: u32) -> i16x8<Self> {
[
i16::wrapping_shl(a[0usize], shift),
i16::wrapping_shl(a[1usize], shift),
i16::wrapping_shl(a[2usize], shift),
i16::wrapping_shl(a[3usize], shift),
i16::wrapping_shl(a[4usize], shift),
i16::wrapping_shl(a[5usize], shift),
i16::wrapping_shl(a[6usize], shift),
i16::wrapping_shl(a[7usize], shift),
]
.simd_into(self)
}
#[inline(always)]
fn shlv_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self> {
[
i16::wrapping_shl(a[0usize], b[0usize] as u32),
i16::wrapping_shl(a[1usize], b[1usize] as u32),
i16::wrapping_shl(a[2usize], b[2usize] as u32),
i16::wrapping_shl(a[3usize], b[3usize] as u32),
i16::wrapping_shl(a[4usize], b[4usize] as u32),
i16::wrapping_shl(a[5usize], b[5usize] as u32),
i16::wrapping_shl(a[6usize], b[6usize] as u32),
i16::wrapping_shl(a[7usize], b[7usize] as u32),
]
.simd_into(self)
}
#[inline(always)]
fn shr_i16x8(self, a: i16x8<Self>, shift: u32) -> i16x8<Self> {
[
i16::wrapping_shr(a[0usize], shift),
i16::wrapping_shr(a[1usize], shift),
i16::wrapping_shr(a[2usize], shift),
i16::wrapping_shr(a[3usize], shift),
i16::wrapping_shr(a[4usize], shift),
i16::wrapping_shr(a[5usize], shift),
i16::wrapping_shr(a[6usize], shift),
i16::wrapping_shr(a[7usize], shift),
]
.simd_into(self)
}
#[inline(always)]
fn shrv_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self> {
[
i16::wrapping_shr(a[0usize], b[0usize] as u32),
i16::wrapping_shr(a[1usize], b[1usize] as u32),
i16::wrapping_shr(a[2usize], b[2usize] as u32),
i16::wrapping_shr(a[3usize], b[3usize] as u32),
i16::wrapping_shr(a[4usize], b[4usize] as u32),
i16::wrapping_shr(a[5usize], b[5usize] as u32),
i16::wrapping_shr(a[6usize], b[6usize] as u32),
i16::wrapping_shr(a[7usize], b[7usize] as u32),
]
.simd_into(self)
}
#[inline(always)]
fn max_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self> {
[
i16::max(a[0usize], b[0usize]),
i16::max(a[1usize], b[1usize]),
i16::max(a[2usize], b[2usize]),
i16::max(a[3usize], b[3usize]),
i16::max(a[4usize], b[4usize]),
i16::max(a[5usize], b[5usize]),
i16::max(a[6usize], b[6usize]),
i16::max(a[7usize], b[7usize]),
]
.simd_into(self)
}
#[inline(always)]
fn min_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self> {
[
i16::min(a[0usize], b[0usize]),
i16::min(a[1usize], b[1usize]),
i16::min(a[2usize], b[2usize]),
i16::min(a[3usize], b[3usize]),
i16::min(a[4usize], b[4usize]),
i16::min(a[5usize], b[5usize]),
i16::min(a[6usize], b[6usize]),
i16::min(a[7usize], b[7usize]),
]
.simd_into(self)
}
#[inline(always)]
fn simd_eq_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> mask16x8<Self> {
[
-(i16::eq(&a[0usize], &b[0usize]) as i16),
-(i16::eq(&a[1usize], &b[1usize]) as i16),
-(i16::eq(&a[2usize], &b[2usize]) as i16),
-(i16::eq(&a[3usize], &b[3usize]) as i16),
-(i16::eq(&a[4usize], &b[4usize]) as i16),
-(i16::eq(&a[5usize], &b[5usize]) as i16),
-(i16::eq(&a[6usize], &b[6usize]) as i16),
-(i16::eq(&a[7usize], &b[7usize]) as i16),
]
.simd_into(self)
}
#[inline(always)]
fn simd_lt_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> mask16x8<Self> {
[
-(i16::lt(&a[0usize], &b[0usize]) as i16),
-(i16::lt(&a[1usize], &b[1usize]) as i16),
-(i16::lt(&a[2usize], &b[2usize]) as i16),
-(i16::lt(&a[3usize], &b[3usize]) as i16),
-(i16::lt(&a[4usize], &b[4usize]) as i16),
-(i16::lt(&a[5usize], &b[5usize]) as i16),
-(i16::lt(&a[6usize], &b[6usize]) as i16),
-(i16::lt(&a[7usize], &b[7usize]) as i16),
]
.simd_into(self)
}
#[inline(always)]
fn simd_le_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> mask16x8<Self> {
[
-(i16::le(&a[0usize], &b[0usize]) as i16),
-(i16::le(&a[1usize], &b[1usize]) as i16),
-(i16::le(&a[2usize], &b[2usize]) as i16),
-(i16::le(&a[3usize], &b[3usize]) as i16),
-(i16::le(&a[4usize], &b[4usize]) as i16),
-(i16::le(&a[5usize], &b[5usize]) as i16),
-(i16::le(&a[6usize], &b[6usize]) as i16),
-(i16::le(&a[7usize], &b[7usize]) as i16),
]
.simd_into(self)
}
#[inline(always)]
fn zip_low_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self> {
[
a[0usize], b[0usize], a[1usize], b[1usize], a[2usize], b[2usize], a[3usize], b[3usize],
]
.simd_into(self)
}
#[inline(always)]
fn zip_high_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self> {
[
a[4usize], b[4usize], a[5usize], b[5usize], a[6usize], b[6usize], a[7usize], b[7usize],
]
.simd_into(self)
}
#[inline(always)]
fn unzip_low_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self> {
[
a[0usize], a[2usize], a[4usize], a[6usize], b[0usize], b[2usize], b[4usize], b[6usize],
]
.simd_into(self)
}
#[inline(always)]
fn unzip_high_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x8<Self> {
[
a[1usize], a[3usize], a[5usize], a[7usize], b[1usize], b[3usize], b[5usize], b[7usize],
]
.simd_into(self)
}
#[inline(always)]
fn interleave_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> (i16x8<Self>, i16x8<Self>) {
(self.zip_low_i16x8(a, b), self.zip_high_i16x8(a, b))
}
#[inline(always)]
fn deinterleave_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> (i16x8<Self>, i16x8<Self>) {
(self.unzip_low_i16x8(a, b), self.unzip_high_i16x8(a, b))
}
#[inline(always)]
fn select_i16x8(self, a: mask16x8<Self>, b: i16x8<Self>, c: i16x8<Self>) -> i16x8<Self> {
[
if a.val.0[0usize] != 0 {
b[0usize]
} else {
c[0usize]
},
if a.val.0[1usize] != 0 {
b[1usize]
} else {
c[1usize]
},
if a.val.0[2usize] != 0 {
b[2usize]
} else {
c[2usize]
},
if a.val.0[3usize] != 0 {
b[3usize]
} else {
c[3usize]
},
if a.val.0[4usize] != 0 {
b[4usize]
} else {
c[4usize]
},
if a.val.0[5usize] != 0 {
b[5usize]
} else {
c[5usize]
},
if a.val.0[6usize] != 0 {
b[6usize]
} else {
c[6usize]
},
if a.val.0[7usize] != 0 {
b[7usize]
} else {
c[7usize]
},
]
.simd_into(self)
}
#[inline(always)]
fn combine_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i16x16<Self> {
let mut result = [0; 16usize];
result[0..8usize].copy_from_slice(&a.val.0);
result[8usize..16usize].copy_from_slice(&b.val.0);
result.simd_into(self)
}
#[inline(always)]
fn neg_i16x8(self, a: i16x8<Self>) -> i16x8<Self> {
[
i16::wrapping_neg(a[0usize]),
i16::wrapping_neg(a[1usize]),
i16::wrapping_neg(a[2usize]),
i16::wrapping_neg(a[3usize]),
i16::wrapping_neg(a[4usize]),
i16::wrapping_neg(a[5usize]),
i16::wrapping_neg(a[6usize]),
i16::wrapping_neg(a[7usize]),
]
.simd_into(self)
}
#[inline(always)]
fn load_four_interleaved_i16x8(self, src: &[i16; 32usize]) -> [i16x8<Self>; 4usize] {
[
[
src[0usize],
src[4usize],
src[8usize],
src[12usize],
src[16usize],
src[20usize],
src[24usize],
src[28usize],
]
.simd_into(self),
[
src[1usize],
src[5usize],
src[9usize],
src[13usize],
src[17usize],
src[21usize],
src[25usize],
src[29usize],
]
.simd_into(self),
[
src[2usize],
src[6usize],
src[10usize],
src[14usize],
src[18usize],
src[22usize],
src[26usize],
src[30usize],
]
.simd_into(self),
[
src[3usize],
src[7usize],
src[11usize],
src[15usize],
src[19usize],
src[23usize],
src[27usize],
src[31usize],
]
.simd_into(self),
]
}
#[inline(always)]
fn store_four_interleaved_i16x8(
self,
vectors: [i16x8<Self>; 4usize],
dest: &mut [i16; 32usize],
) -> () {
*dest = [
vectors[0usize][0usize],
vectors[1usize][0usize],
vectors[2usize][0usize],
vectors[3usize][0usize],
vectors[0usize][1usize],
vectors[1usize][1usize],
vectors[2usize][1usize],
vectors[3usize][1usize],
vectors[0usize][2usize],
vectors[1usize][2usize],
vectors[2usize][2usize],
vectors[3usize][2usize],
vectors[0usize][3usize],
vectors[1usize][3usize],
vectors[2usize][3usize],
vectors[3usize][3usize],
vectors[0usize][4usize],
vectors[1usize][4usize],
vectors[2usize][4usize],
vectors[3usize][4usize],
vectors[0usize][5usize],
vectors[1usize][5usize],
vectors[2usize][5usize],
vectors[3usize][5usize],
vectors[0usize][6usize],
vectors[1usize][6usize],
vectors[2usize][6usize],
vectors[3usize][6usize],
vectors[0usize][7usize],
vectors[1usize][7usize],
vectors[2usize][7usize],
vectors[3usize][7usize],
];
}
#[inline(always)]
fn widen_i16x8(self, a: i16x8<Self>) -> (i32x4<Self>, i32x4<Self>) {
(
[
a[0usize] as i32,
a[1usize] as i32,
a[2usize] as i32,
a[3usize] as i32,
]
.simd_into(self),
[
a[4usize] as i32,
a[5usize] as i32,
a[6usize] as i32,
a[7usize] as i32,
]
.simd_into(self),
)
}
#[inline(always)]
fn narrow_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i8x16<Self> {
[
a[0usize] as i8,
a[1usize] as i8,
a[2usize] as i8,
a[3usize] as i8,
a[4usize] as i8,
a[5usize] as i8,
a[6usize] as i8,
a[7usize] as i8,
b[0usize] as i8,
b[1usize] as i8,
b[2usize] as i8,
b[3usize] as i8,
b[4usize] as i8,
b[5usize] as i8,
b[6usize] as i8,
b[7usize] as i8,
]
.simd_into(self)
}
#[inline(always)]
fn saturating_narrow_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i8x16<Self> {
[
a[0usize].clamp(i8::MIN as i16, i8::MAX as i16) as i8,
a[1usize].clamp(i8::MIN as i16, i8::MAX as i16) as i8,
a[2usize].clamp(i8::MIN as i16, i8::MAX as i16) as i8,
a[3usize].clamp(i8::MIN as i16, i8::MAX as i16) as i8,
a[4usize].clamp(i8::MIN as i16, i8::MAX as i16) as i8,
a[5usize].clamp(i8::MIN as i16, i8::MAX as i16) as i8,
a[6usize].clamp(i8::MIN as i16, i8::MAX as i16) as i8,
a[7usize].clamp(i8::MIN as i16, i8::MAX as i16) as i8,
b[0usize].clamp(i8::MIN as i16, i8::MAX as i16) as i8,
b[1usize].clamp(i8::MIN as i16, i8::MAX as i16) as i8,
b[2usize].clamp(i8::MIN as i16, i8::MAX as i16) as i8,
b[3usize].clamp(i8::MIN as i16, i8::MAX as i16) as i8,
b[4usize].clamp(i8::MIN as i16, i8::MAX as i16) as i8,
b[5usize].clamp(i8::MIN as i16, i8::MAX as i16) as i8,
b[6usize].clamp(i8::MIN as i16, i8::MAX as i16) as i8,
b[7usize].clamp(i8::MIN as i16, i8::MAX as i16) as i8,
]
.simd_into(self)
}
#[inline(always)]
fn relaxed_narrow_i16x8(self, a: i16x8<Self>, b: i16x8<Self>) -> i8x16<Self> {
debug_assert!(
a.as_slice()
.iter()
.chain(b.as_slice())
.all(|&value| { value >= i8::MIN as i16 && value <= i8::MAX as i16 }),
"relaxed_narrow inputs must fit in the destination type",
);
self.narrow_i16x8(a, b)
}
#[inline(always)]
fn splat_u16x8(self, val: u16) -> u16x8<Self> {
[val; 8usize].simd_into(self)
}
#[inline(always)]
fn slide_u16x8<const SHIFT: usize>(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self> {
let mut dest = [Default::default(); 8usize];
dest[..8usize - SHIFT].copy_from_slice(&a.val.0[SHIFT..]);
dest[8usize - SHIFT..].copy_from_slice(&b.val.0[..SHIFT]);
dest.simd_into(self)
}
#[inline(always)]
fn add_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self> {
[
u16::wrapping_add(a[0usize], b[0usize]),
u16::wrapping_add(a[1usize], b[1usize]),
u16::wrapping_add(a[2usize], b[2usize]),
u16::wrapping_add(a[3usize], b[3usize]),
u16::wrapping_add(a[4usize], b[4usize]),
u16::wrapping_add(a[5usize], b[5usize]),
u16::wrapping_add(a[6usize], b[6usize]),
u16::wrapping_add(a[7usize], b[7usize]),
]
.simd_into(self)
}
#[inline(always)]
fn sub_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self> {
[
u16::wrapping_sub(a[0usize], b[0usize]),
u16::wrapping_sub(a[1usize], b[1usize]),
u16::wrapping_sub(a[2usize], b[2usize]),
u16::wrapping_sub(a[3usize], b[3usize]),
u16::wrapping_sub(a[4usize], b[4usize]),
u16::wrapping_sub(a[5usize], b[5usize]),
u16::wrapping_sub(a[6usize], b[6usize]),
u16::wrapping_sub(a[7usize], b[7usize]),
]
.simd_into(self)
}
#[inline(always)]
fn mul_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self> {
[
u16::wrapping_mul(a[0usize], b[0usize]),
u16::wrapping_mul(a[1usize], b[1usize]),
u16::wrapping_mul(a[2usize], b[2usize]),
u16::wrapping_mul(a[3usize], b[3usize]),
u16::wrapping_mul(a[4usize], b[4usize]),
u16::wrapping_mul(a[5usize], b[5usize]),
u16::wrapping_mul(a[6usize], b[6usize]),
u16::wrapping_mul(a[7usize], b[7usize]),
]
.simd_into(self)
}
#[inline(always)]
fn and_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self> {
[
u16::bitand(a[0usize], &b[0usize]),
u16::bitand(a[1usize], &b[1usize]),
u16::bitand(a[2usize], &b[2usize]),
u16::bitand(a[3usize], &b[3usize]),
u16::bitand(a[4usize], &b[4usize]),
u16::bitand(a[5usize], &b[5usize]),
u16::bitand(a[6usize], &b[6usize]),
u16::bitand(a[7usize], &b[7usize]),
]
.simd_into(self)
}
#[inline(always)]
fn or_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self> {
[
u16::bitor(a[0usize], &b[0usize]),
u16::bitor(a[1usize], &b[1usize]),
u16::bitor(a[2usize], &b[2usize]),
u16::bitor(a[3usize], &b[3usize]),
u16::bitor(a[4usize], &b[4usize]),
u16::bitor(a[5usize], &b[5usize]),
u16::bitor(a[6usize], &b[6usize]),
u16::bitor(a[7usize], &b[7usize]),
]
.simd_into(self)
}
#[inline(always)]
fn xor_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self> {
[
u16::bitxor(a[0usize], &b[0usize]),
u16::bitxor(a[1usize], &b[1usize]),
u16::bitxor(a[2usize], &b[2usize]),
u16::bitxor(a[3usize], &b[3usize]),
u16::bitxor(a[4usize], &b[4usize]),
u16::bitxor(a[5usize], &b[5usize]),
u16::bitxor(a[6usize], &b[6usize]),
u16::bitxor(a[7usize], &b[7usize]),
]
.simd_into(self)
}
#[inline(always)]
fn not_u16x8(self, a: u16x8<Self>) -> u16x8<Self> {
[
u16::not(a[0usize]),
u16::not(a[1usize]),
u16::not(a[2usize]),
u16::not(a[3usize]),
u16::not(a[4usize]),
u16::not(a[5usize]),
u16::not(a[6usize]),
u16::not(a[7usize]),
]
.simd_into(self)
}
#[inline(always)]
fn shl_u16x8(self, a: u16x8<Self>, shift: u32) -> u16x8<Self> {
[
u16::wrapping_shl(a[0usize], shift),
u16::wrapping_shl(a[1usize], shift),
u16::wrapping_shl(a[2usize], shift),
u16::wrapping_shl(a[3usize], shift),
u16::wrapping_shl(a[4usize], shift),
u16::wrapping_shl(a[5usize], shift),
u16::wrapping_shl(a[6usize], shift),
u16::wrapping_shl(a[7usize], shift),
]
.simd_into(self)
}
#[inline(always)]
fn shlv_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self> {
[
u16::wrapping_shl(a[0usize], b[0usize] as u32),
u16::wrapping_shl(a[1usize], b[1usize] as u32),
u16::wrapping_shl(a[2usize], b[2usize] as u32),
u16::wrapping_shl(a[3usize], b[3usize] as u32),
u16::wrapping_shl(a[4usize], b[4usize] as u32),
u16::wrapping_shl(a[5usize], b[5usize] as u32),
u16::wrapping_shl(a[6usize], b[6usize] as u32),
u16::wrapping_shl(a[7usize], b[7usize] as u32),
]
.simd_into(self)
}
#[inline(always)]
fn shr_u16x8(self, a: u16x8<Self>, shift: u32) -> u16x8<Self> {
[
u16::wrapping_shr(a[0usize], shift),
u16::wrapping_shr(a[1usize], shift),
u16::wrapping_shr(a[2usize], shift),
u16::wrapping_shr(a[3usize], shift),
u16::wrapping_shr(a[4usize], shift),
u16::wrapping_shr(a[5usize], shift),
u16::wrapping_shr(a[6usize], shift),
u16::wrapping_shr(a[7usize], shift),
]
.simd_into(self)
}
#[inline(always)]
fn shrv_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self> {
[
u16::wrapping_shr(a[0usize], b[0usize] as u32),
u16::wrapping_shr(a[1usize], b[1usize] as u32),
u16::wrapping_shr(a[2usize], b[2usize] as u32),
u16::wrapping_shr(a[3usize], b[3usize] as u32),
u16::wrapping_shr(a[4usize], b[4usize] as u32),
u16::wrapping_shr(a[5usize], b[5usize] as u32),
u16::wrapping_shr(a[6usize], b[6usize] as u32),
u16::wrapping_shr(a[7usize], b[7usize] as u32),
]
.simd_into(self)
}
#[inline(always)]
fn max_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self> {
[
u16::max(a[0usize], b[0usize]),
u16::max(a[1usize], b[1usize]),
u16::max(a[2usize], b[2usize]),
u16::max(a[3usize], b[3usize]),
u16::max(a[4usize], b[4usize]),
u16::max(a[5usize], b[5usize]),
u16::max(a[6usize], b[6usize]),
u16::max(a[7usize], b[7usize]),
]
.simd_into(self)
}
#[inline(always)]
fn min_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self> {
[
u16::min(a[0usize], b[0usize]),
u16::min(a[1usize], b[1usize]),
u16::min(a[2usize], b[2usize]),
u16::min(a[3usize], b[3usize]),
u16::min(a[4usize], b[4usize]),
u16::min(a[5usize], b[5usize]),
u16::min(a[6usize], b[6usize]),
u16::min(a[7usize], b[7usize]),
]
.simd_into(self)
}
#[inline(always)]
fn simd_eq_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> mask16x8<Self> {
[
-(u16::eq(&a[0usize], &b[0usize]) as i16),
-(u16::eq(&a[1usize], &b[1usize]) as i16),
-(u16::eq(&a[2usize], &b[2usize]) as i16),
-(u16::eq(&a[3usize], &b[3usize]) as i16),
-(u16::eq(&a[4usize], &b[4usize]) as i16),
-(u16::eq(&a[5usize], &b[5usize]) as i16),
-(u16::eq(&a[6usize], &b[6usize]) as i16),
-(u16::eq(&a[7usize], &b[7usize]) as i16),
]
.simd_into(self)
}
#[inline(always)]
fn simd_lt_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> mask16x8<Self> {
[
-(u16::lt(&a[0usize], &b[0usize]) as i16),
-(u16::lt(&a[1usize], &b[1usize]) as i16),
-(u16::lt(&a[2usize], &b[2usize]) as i16),
-(u16::lt(&a[3usize], &b[3usize]) as i16),
-(u16::lt(&a[4usize], &b[4usize]) as i16),
-(u16::lt(&a[5usize], &b[5usize]) as i16),
-(u16::lt(&a[6usize], &b[6usize]) as i16),
-(u16::lt(&a[7usize], &b[7usize]) as i16),
]
.simd_into(self)
}
#[inline(always)]
fn simd_le_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> mask16x8<Self> {
[
-(u16::le(&a[0usize], &b[0usize]) as i16),
-(u16::le(&a[1usize], &b[1usize]) as i16),
-(u16::le(&a[2usize], &b[2usize]) as i16),
-(u16::le(&a[3usize], &b[3usize]) as i16),
-(u16::le(&a[4usize], &b[4usize]) as i16),
-(u16::le(&a[5usize], &b[5usize]) as i16),
-(u16::le(&a[6usize], &b[6usize]) as i16),
-(u16::le(&a[7usize], &b[7usize]) as i16),
]
.simd_into(self)
}
#[inline(always)]
fn zip_low_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self> {
[
a[0usize], b[0usize], a[1usize], b[1usize], a[2usize], b[2usize], a[3usize], b[3usize],
]
.simd_into(self)
}
#[inline(always)]
fn zip_high_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self> {
[
a[4usize], b[4usize], a[5usize], b[5usize], a[6usize], b[6usize], a[7usize], b[7usize],
]
.simd_into(self)
}
#[inline(always)]
fn unzip_low_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self> {
[
a[0usize], a[2usize], a[4usize], a[6usize], b[0usize], b[2usize], b[4usize], b[6usize],
]
.simd_into(self)
}
#[inline(always)]
fn unzip_high_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x8<Self> {
[
a[1usize], a[3usize], a[5usize], a[7usize], b[1usize], b[3usize], b[5usize], b[7usize],
]
.simd_into(self)
}
#[inline(always)]
fn interleave_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> (u16x8<Self>, u16x8<Self>) {
(self.zip_low_u16x8(a, b), self.zip_high_u16x8(a, b))
}
#[inline(always)]
fn deinterleave_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> (u16x8<Self>, u16x8<Self>) {
(self.unzip_low_u16x8(a, b), self.unzip_high_u16x8(a, b))
}
#[inline(always)]
fn select_u16x8(self, a: mask16x8<Self>, b: u16x8<Self>, c: u16x8<Self>) -> u16x8<Self> {
[
if a.val.0[0usize] != 0 {
b[0usize]
} else {
c[0usize]
},
if a.val.0[1usize] != 0 {
b[1usize]
} else {
c[1usize]
},
if a.val.0[2usize] != 0 {
b[2usize]
} else {
c[2usize]
},
if a.val.0[3usize] != 0 {
b[3usize]
} else {
c[3usize]
},
if a.val.0[4usize] != 0 {
b[4usize]
} else {
c[4usize]
},
if a.val.0[5usize] != 0 {
b[5usize]
} else {
c[5usize]
},
if a.val.0[6usize] != 0 {
b[6usize]
} else {
c[6usize]
},
if a.val.0[7usize] != 0 {
b[7usize]
} else {
c[7usize]
},
]
.simd_into(self)
}
#[inline(always)]
fn combine_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u16x16<Self> {
let mut result = [0; 16usize];
result[0..8usize].copy_from_slice(&a.val.0);
result[8usize..16usize].copy_from_slice(&b.val.0);
result.simd_into(self)
}
#[inline(always)]
fn load_four_interleaved_u16x8(self, src: &[u16; 32usize]) -> [u16x8<Self>; 4usize] {
[
[
src[0usize],
src[4usize],
src[8usize],
src[12usize],
src[16usize],
src[20usize],
src[24usize],
src[28usize],
]
.simd_into(self),
[
src[1usize],
src[5usize],
src[9usize],
src[13usize],
src[17usize],
src[21usize],
src[25usize],
src[29usize],
]
.simd_into(self),
[
src[2usize],
src[6usize],
src[10usize],
src[14usize],
src[18usize],
src[22usize],
src[26usize],
src[30usize],
]
.simd_into(self),
[
src[3usize],
src[7usize],
src[11usize],
src[15usize],
src[19usize],
src[23usize],
src[27usize],
src[31usize],
]
.simd_into(self),
]
}
#[inline(always)]
fn store_four_interleaved_u16x8(
self,
vectors: [u16x8<Self>; 4usize],
dest: &mut [u16; 32usize],
) -> () {
*dest = [
vectors[0usize][0usize],
vectors[1usize][0usize],
vectors[2usize][0usize],
vectors[3usize][0usize],
vectors[0usize][1usize],
vectors[1usize][1usize],
vectors[2usize][1usize],
vectors[3usize][1usize],
vectors[0usize][2usize],
vectors[1usize][2usize],
vectors[2usize][2usize],
vectors[3usize][2usize],
vectors[0usize][3usize],
vectors[1usize][3usize],
vectors[2usize][3usize],
vectors[3usize][3usize],
vectors[0usize][4usize],
vectors[1usize][4usize],
vectors[2usize][4usize],
vectors[3usize][4usize],
vectors[0usize][5usize],
vectors[1usize][5usize],
vectors[2usize][5usize],
vectors[3usize][5usize],
vectors[0usize][6usize],
vectors[1usize][6usize],
vectors[2usize][6usize],
vectors[3usize][6usize],
vectors[0usize][7usize],
vectors[1usize][7usize],
vectors[2usize][7usize],
vectors[3usize][7usize],
];
}
#[inline(always)]
fn widen_u16x8(self, a: u16x8<Self>) -> (u32x4<Self>, u32x4<Self>) {
(
[
a[0usize] as u32,
a[1usize] as u32,
a[2usize] as u32,
a[3usize] as u32,
]
.simd_into(self),
[
a[4usize] as u32,
a[5usize] as u32,
a[6usize] as u32,
a[7usize] as u32,
]
.simd_into(self),
)
}
#[inline(always)]
fn narrow_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u8x16<Self> {
[
a[0usize] as u8,
a[1usize] as u8,
a[2usize] as u8,
a[3usize] as u8,
a[4usize] as u8,
a[5usize] as u8,
a[6usize] as u8,
a[7usize] as u8,
b[0usize] as u8,
b[1usize] as u8,
b[2usize] as u8,
b[3usize] as u8,
b[4usize] as u8,
b[5usize] as u8,
b[6usize] as u8,
b[7usize] as u8,
]
.simd_into(self)
}
#[inline(always)]
fn saturating_narrow_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u8x16<Self> {
[
a[0usize].clamp(u8::MIN as u16, u8::MAX as u16) as u8,
a[1usize].clamp(u8::MIN as u16, u8::MAX as u16) as u8,
a[2usize].clamp(u8::MIN as u16, u8::MAX as u16) as u8,
a[3usize].clamp(u8::MIN as u16, u8::MAX as u16) as u8,
a[4usize].clamp(u8::MIN as u16, u8::MAX as u16) as u8,
a[5usize].clamp(u8::MIN as u16, u8::MAX as u16) as u8,
a[6usize].clamp(u8::MIN as u16, u8::MAX as u16) as u8,
a[7usize].clamp(u8::MIN as u16, u8::MAX as u16) as u8,
b[0usize].clamp(u8::MIN as u16, u8::MAX as u16) as u8,
b[1usize].clamp(u8::MIN as u16, u8::MAX as u16) as u8,
b[2usize].clamp(u8::MIN as u16, u8::MAX as u16) as u8,
b[3usize].clamp(u8::MIN as u16, u8::MAX as u16) as u8,
b[4usize].clamp(u8::MIN as u16, u8::MAX as u16) as u8,
b[5usize].clamp(u8::MIN as u16, u8::MAX as u16) as u8,
b[6usize].clamp(u8::MIN as u16, u8::MAX as u16) as u8,
b[7usize].clamp(u8::MIN as u16, u8::MAX as u16) as u8,
]
.simd_into(self)
}
#[inline(always)]
fn relaxed_narrow_u16x8(self, a: u16x8<Self>, b: u16x8<Self>) -> u8x16<Self> {
debug_assert!(
a.as_slice()
.iter()
.chain(b.as_slice())
.all(|&value| { value >= u8::MIN as u16 && value <= u8::MAX as u16 }),
"relaxed_narrow inputs must fit in the destination type",
);
self.narrow_u16x8(a, b)
}
#[inline(always)]
fn splat_mask16x8(self, val: bool) -> mask16x8<Self> {
let val: i16 = if val { !0 } else { 0 };
[val; 8usize].simd_into(self)
}
#[inline(always)]
fn from_bitmask_mask16x8(self, bits: u64) -> mask16x8<Self> {
let lanes: [i16; 8usize] = [
if bits & 1 != 0 { !0 } else { 0 },
if (bits >> 1usize) & 1 != 0 { !0 } else { 0 },
if (bits >> 2usize) & 1 != 0 { !0 } else { 0 },
if (bits >> 3usize) & 1 != 0 { !0 } else { 0 },
if (bits >> 4usize) & 1 != 0 { !0 } else { 0 },
if (bits >> 5usize) & 1 != 0 { !0 } else { 0 },
if (bits >> 6usize) & 1 != 0 { !0 } else { 0 },
if (bits >> 7usize) & 1 != 0 { !0 } else { 0 },
];
lanes.simd_into(self)
}
#[inline(always)]
fn to_bitmask_mask16x8(self, a: mask16x8<Self>) -> u64 {
let lanes: [i16; 8usize] = a.into();
let mut bits = 0u64;
let mut i = 0;
while i < 8usize {
if lanes[i] != 0 {
bits |= 1u64 << i;
}
i += 1;
}
bits
}
#[inline(always)]
fn set_mask16x8(self, a: &mut mask16x8<Self>, index: usize, value: bool) -> () {
assert!(
index < 8usize,
"mask lane index {index} is out of bounds for {} lanes",
8usize
);
let mut lanes: [i16; 8usize] = (*a).into();
lanes[index] = if value { !0 } else { 0 };
*a = lanes.simd_into(self);
}
#[inline(always)]
fn and_mask16x8(self, a: mask16x8<Self>, b: mask16x8<Self>) -> mask16x8<Self> {
[
i16::bitand(a.val.0[0usize], &b.val.0[0usize]),
i16::bitand(a.val.0[1usize], &b.val.0[1usize]),
i16::bitand(a.val.0[2usize], &b.val.0[2usize]),
i16::bitand(a.val.0[3usize], &b.val.0[3usize]),
i16::bitand(a.val.0[4usize], &b.val.0[4usize]),
i16::bitand(a.val.0[5usize], &b.val.0[5usize]),
i16::bitand(a.val.0[6usize], &b.val.0[6usize]),
i16::bitand(a.val.0[7usize], &b.val.0[7usize]),
]
.simd_into(self)
}
#[inline(always)]
fn or_mask16x8(self, a: mask16x8<Self>, b: mask16x8<Self>) -> mask16x8<Self> {
[
i16::bitor(a.val.0[0usize], &b.val.0[0usize]),
i16::bitor(a.val.0[1usize], &b.val.0[1usize]),
i16::bitor(a.val.0[2usize], &b.val.0[2usize]),
i16::bitor(a.val.0[3usize], &b.val.0[3usize]),
i16::bitor(a.val.0[4usize], &b.val.0[4usize]),
i16::bitor(a.val.0[5usize], &b.val.0[5usize]),
i16::bitor(a.val.0[6usize], &b.val.0[6usize]),
i16::bitor(a.val.0[7usize], &b.val.0[7usize]),
]
.simd_into(self)
}
#[inline(always)]
fn xor_mask16x8(self, a: mask16x8<Self>, b: mask16x8<Self>) -> mask16x8<Self> {
[
i16::bitxor(a.val.0[0usize], &b.val.0[0usize]),
i16::bitxor(a.val.0[1usize], &b.val.0[1usize]),
i16::bitxor(a.val.0[2usize], &b.val.0[2usize]),
i16::bitxor(a.val.0[3usize], &b.val.0[3usize]),
i16::bitxor(a.val.0[4usize], &b.val.0[4usize]),
i16::bitxor(a.val.0[5usize], &b.val.0[5usize]),
i16::bitxor(a.val.0[6usize], &b.val.0[6usize]),
i16::bitxor(a.val.0[7usize], &b.val.0[7usize]),
]
.simd_into(self)
}
#[inline(always)]
fn not_mask16x8(self, a: mask16x8<Self>) -> mask16x8<Self> {
[
i16::not(a.val.0[0usize]),
i16::not(a.val.0[1usize]),
i16::not(a.val.0[2usize]),
i16::not(a.val.0[3usize]),
i16::not(a.val.0[4usize]),
i16::not(a.val.0[5usize]),
i16::not(a.val.0[6usize]),
i16::not(a.val.0[7usize]),
]
.simd_into(self)
}
#[inline(always)]
fn select_mask16x8(
self,
a: mask16x8<Self>,
b: mask16x8<Self>,
c: mask16x8<Self>,
) -> mask16x8<Self> {
[
if a.val.0[0usize] != 0 {
b.val.0[0usize]
} else {
c.val.0[0usize]
},
if a.val.0[1usize] != 0 {
b.val.0[1usize]
} else {
c.val.0[1usize]
},
if a.val.0[2usize] != 0 {
b.val.0[2usize]
} else {
c.val.0[2usize]
},
if a.val.0[3usize] != 0 {
b.val.0[3usize]
} else {
c.val.0[3usize]
},
if a.val.0[4usize] != 0 {
b.val.0[4usize]
} else {
c.val.0[4usize]
},
if a.val.0[5usize] != 0 {
b.val.0[5usize]
} else {
c.val.0[5usize]
},
if a.val.0[6usize] != 0 {
b.val.0[6usize]
} else {
c.val.0[6usize]
},
if a.val.0[7usize] != 0 {
b.val.0[7usize]
} else {
c.val.0[7usize]
},
]
.simd_into(self)
}
#[inline(always)]
fn simd_eq_mask16x8(self, a: mask16x8<Self>, b: mask16x8<Self>) -> mask16x8<Self> {
[
-(i16::eq(&a.val.0[0usize], &b.val.0[0usize]) as i16),
-(i16::eq(&a.val.0[1usize], &b.val.0[1usize]) as i16),
-(i16::eq(&a.val.0[2usize], &b.val.0[2usize]) as i16),
-(i16::eq(&a.val.0[3usize], &b.val.0[3usize]) as i16),
-(i16::eq(&a.val.0[4usize], &b.val.0[4usize]) as i16),
-(i16::eq(&a.val.0[5usize], &b.val.0[5usize]) as i16),
-(i16::eq(&a.val.0[6usize], &b.val.0[6usize]) as i16),
-(i16::eq(&a.val.0[7usize], &b.val.0[7usize]) as i16),
]
.simd_into(self)
}
#[inline(always)]
fn any_true_mask16x8(self, a: mask16x8<Self>) -> bool {
a.val.0[0usize] != 0
|| a.val.0[1usize] != 0
|| a.val.0[2usize] != 0
|| a.val.0[3usize] != 0
|| a.val.0[4usize] != 0
|| a.val.0[5usize] != 0
|| a.val.0[6usize] != 0
|| a.val.0[7usize] != 0
}
#[inline(always)]
fn all_true_mask16x8(self, a: mask16x8<Self>) -> bool {
a.val.0[0usize] != 0
&& a.val.0[1usize] != 0
&& a.val.0[2usize] != 0
&& a.val.0[3usize] != 0
&& a.val.0[4usize] != 0
&& a.val.0[5usize] != 0
&& a.val.0[6usize] != 0
&& a.val.0[7usize] != 0
}
#[inline(always)]
fn any_false_mask16x8(self, a: mask16x8<Self>) -> bool {
a.val.0[0usize] == 0
|| a.val.0[1usize] == 0
|| a.val.0[2usize] == 0
|| a.val.0[3usize] == 0
|| a.val.0[4usize] == 0
|| a.val.0[5usize] == 0
|| a.val.0[6usize] == 0
|| a.val.0[7usize] == 0
}
#[inline(always)]
fn all_false_mask16x8(self, a: mask16x8<Self>) -> bool {
a.val.0[0usize] == 0
&& a.val.0[1usize] == 0
&& a.val.0[2usize] == 0
&& a.val.0[3usize] == 0
&& a.val.0[4usize] == 0
&& a.val.0[5usize] == 0
&& a.val.0[6usize] == 0
&& a.val.0[7usize] == 0
}
#[inline(always)]
fn combine_mask16x8(self, a: mask16x8<Self>, b: mask16x8<Self>) -> mask16x16<Self> {
let mut result = [0; 16usize];
result[0..8usize].copy_from_slice(&a.val.0);
result[8usize..16usize].copy_from_slice(&b.val.0);
result.simd_into(self)
}
#[inline(always)]
fn splat_i32x4(self, val: i32) -> i32x4<Self> {
[val; 4usize].simd_into(self)
}
#[inline(always)]
fn slide_i32x4<const SHIFT: usize>(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self> {
let mut dest = [Default::default(); 4usize];
dest[..4usize - SHIFT].copy_from_slice(&a.val.0[SHIFT..]);
dest[4usize - SHIFT..].copy_from_slice(&b.val.0[..SHIFT]);
dest.simd_into(self)
}
#[inline(always)]
fn add_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self> {
[
i32::wrapping_add(a[0usize], b[0usize]),
i32::wrapping_add(a[1usize], b[1usize]),
i32::wrapping_add(a[2usize], b[2usize]),
i32::wrapping_add(a[3usize], b[3usize]),
]
.simd_into(self)
}
#[inline(always)]
fn sub_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self> {
[
i32::wrapping_sub(a[0usize], b[0usize]),
i32::wrapping_sub(a[1usize], b[1usize]),
i32::wrapping_sub(a[2usize], b[2usize]),
i32::wrapping_sub(a[3usize], b[3usize]),
]
.simd_into(self)
}
#[inline(always)]
fn mul_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self> {
[
i32::wrapping_mul(a[0usize], b[0usize]),
i32::wrapping_mul(a[1usize], b[1usize]),
i32::wrapping_mul(a[2usize], b[2usize]),
i32::wrapping_mul(a[3usize], b[3usize]),
]
.simd_into(self)
}
#[inline(always)]
fn and_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self> {
[
i32::bitand(a[0usize], &b[0usize]),
i32::bitand(a[1usize], &b[1usize]),
i32::bitand(a[2usize], &b[2usize]),
i32::bitand(a[3usize], &b[3usize]),
]
.simd_into(self)
}
#[inline(always)]
fn or_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self> {
[
i32::bitor(a[0usize], &b[0usize]),
i32::bitor(a[1usize], &b[1usize]),
i32::bitor(a[2usize], &b[2usize]),
i32::bitor(a[3usize], &b[3usize]),
]
.simd_into(self)
}
#[inline(always)]
fn xor_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self> {
[
i32::bitxor(a[0usize], &b[0usize]),
i32::bitxor(a[1usize], &b[1usize]),
i32::bitxor(a[2usize], &b[2usize]),
i32::bitxor(a[3usize], &b[3usize]),
]
.simd_into(self)
}
#[inline(always)]
fn not_i32x4(self, a: i32x4<Self>) -> i32x4<Self> {
[
i32::not(a[0usize]),
i32::not(a[1usize]),
i32::not(a[2usize]),
i32::not(a[3usize]),
]
.simd_into(self)
}
#[inline(always)]
fn shl_i32x4(self, a: i32x4<Self>, shift: u32) -> i32x4<Self> {
[
i32::wrapping_shl(a[0usize], shift),
i32::wrapping_shl(a[1usize], shift),
i32::wrapping_shl(a[2usize], shift),
i32::wrapping_shl(a[3usize], shift),
]
.simd_into(self)
}
#[inline(always)]
fn shlv_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self> {
[
i32::wrapping_shl(a[0usize], b[0usize] as u32),
i32::wrapping_shl(a[1usize], b[1usize] as u32),
i32::wrapping_shl(a[2usize], b[2usize] as u32),
i32::wrapping_shl(a[3usize], b[3usize] as u32),
]
.simd_into(self)
}
#[inline(always)]
fn shr_i32x4(self, a: i32x4<Self>, shift: u32) -> i32x4<Self> {
[
i32::wrapping_shr(a[0usize], shift),
i32::wrapping_shr(a[1usize], shift),
i32::wrapping_shr(a[2usize], shift),
i32::wrapping_shr(a[3usize], shift),
]
.simd_into(self)
}
#[inline(always)]
fn shrv_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self> {
[
i32::wrapping_shr(a[0usize], b[0usize] as u32),
i32::wrapping_shr(a[1usize], b[1usize] as u32),
i32::wrapping_shr(a[2usize], b[2usize] as u32),
i32::wrapping_shr(a[3usize], b[3usize] as u32),
]
.simd_into(self)
}
#[inline(always)]
fn max_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self> {
[
i32::max(a[0usize], b[0usize]),
i32::max(a[1usize], b[1usize]),
i32::max(a[2usize], b[2usize]),
i32::max(a[3usize], b[3usize]),
]
.simd_into(self)
}
#[inline(always)]
fn min_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self> {
[
i32::min(a[0usize], b[0usize]),
i32::min(a[1usize], b[1usize]),
i32::min(a[2usize], b[2usize]),
i32::min(a[3usize], b[3usize]),
]
.simd_into(self)
}
#[inline(always)]
fn simd_eq_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> mask32x4<Self> {
[
-(i32::eq(&a[0usize], &b[0usize]) as i32),
-(i32::eq(&a[1usize], &b[1usize]) as i32),
-(i32::eq(&a[2usize], &b[2usize]) as i32),
-(i32::eq(&a[3usize], &b[3usize]) as i32),
]
.simd_into(self)
}
#[inline(always)]
fn simd_lt_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> mask32x4<Self> {
[
-(i32::lt(&a[0usize], &b[0usize]) as i32),
-(i32::lt(&a[1usize], &b[1usize]) as i32),
-(i32::lt(&a[2usize], &b[2usize]) as i32),
-(i32::lt(&a[3usize], &b[3usize]) as i32),
]
.simd_into(self)
}
#[inline(always)]
fn simd_le_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> mask32x4<Self> {
[
-(i32::le(&a[0usize], &b[0usize]) as i32),
-(i32::le(&a[1usize], &b[1usize]) as i32),
-(i32::le(&a[2usize], &b[2usize]) as i32),
-(i32::le(&a[3usize], &b[3usize]) as i32),
]
.simd_into(self)
}
#[inline(always)]
fn zip_low_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self> {
[a[0usize], b[0usize], a[1usize], b[1usize]].simd_into(self)
}
#[inline(always)]
fn zip_high_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self> {
[a[2usize], b[2usize], a[3usize], b[3usize]].simd_into(self)
}
#[inline(always)]
fn unzip_low_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self> {
[a[0usize], a[2usize], b[0usize], b[2usize]].simd_into(self)
}
#[inline(always)]
fn unzip_high_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x4<Self> {
[a[1usize], a[3usize], b[1usize], b[3usize]].simd_into(self)
}
#[inline(always)]
fn interleave_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> (i32x4<Self>, i32x4<Self>) {
(self.zip_low_i32x4(a, b), self.zip_high_i32x4(a, b))
}
#[inline(always)]
fn deinterleave_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> (i32x4<Self>, i32x4<Self>) {
(self.unzip_low_i32x4(a, b), self.unzip_high_i32x4(a, b))
}
#[inline(always)]
fn select_i32x4(self, a: mask32x4<Self>, b: i32x4<Self>, c: i32x4<Self>) -> i32x4<Self> {
[
if a.val.0[0usize] != 0 {
b[0usize]
} else {
c[0usize]
},
if a.val.0[1usize] != 0 {
b[1usize]
} else {
c[1usize]
},
if a.val.0[2usize] != 0 {
b[2usize]
} else {
c[2usize]
},
if a.val.0[3usize] != 0 {
b[3usize]
} else {
c[3usize]
},
]
.simd_into(self)
}
#[inline(always)]
fn combine_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i32x8<Self> {
let mut result = [0; 8usize];
result[0..4usize].copy_from_slice(&a.val.0);
result[4usize..8usize].copy_from_slice(&b.val.0);
result.simd_into(self)
}
#[inline(always)]
fn neg_i32x4(self, a: i32x4<Self>) -> i32x4<Self> {
[
i32::wrapping_neg(a[0usize]),
i32::wrapping_neg(a[1usize]),
i32::wrapping_neg(a[2usize]),
i32::wrapping_neg(a[3usize]),
]
.simd_into(self)
}
#[inline(always)]
fn load_four_interleaved_i32x4(self, src: &[i32; 16usize]) -> [i32x4<Self>; 4usize] {
[
[src[0usize], src[4usize], src[8usize], src[12usize]].simd_into(self),
[src[1usize], src[5usize], src[9usize], src[13usize]].simd_into(self),
[src[2usize], src[6usize], src[10usize], src[14usize]].simd_into(self),
[src[3usize], src[7usize], src[11usize], src[15usize]].simd_into(self),
]
}
#[inline(always)]
fn store_four_interleaved_i32x4(
self,
vectors: [i32x4<Self>; 4usize],
dest: &mut [i32; 16usize],
) -> () {
*dest = [
vectors[0usize][0usize],
vectors[1usize][0usize],
vectors[2usize][0usize],
vectors[3usize][0usize],
vectors[0usize][1usize],
vectors[1usize][1usize],
vectors[2usize][1usize],
vectors[3usize][1usize],
vectors[0usize][2usize],
vectors[1usize][2usize],
vectors[2usize][2usize],
vectors[3usize][2usize],
vectors[0usize][3usize],
vectors[1usize][3usize],
vectors[2usize][3usize],
vectors[3usize][3usize],
];
}
#[inline(always)]
fn widen_i32x4(self, a: i32x4<Self>) -> (i64x2<Self>, i64x2<Self>) {
(
[a[0usize] as i64, a[1usize] as i64].simd_into(self),
[a[2usize] as i64, a[3usize] as i64].simd_into(self),
)
}
#[inline(always)]
fn narrow_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i16x8<Self> {
[
a[0usize] as i16,
a[1usize] as i16,
a[2usize] as i16,
a[3usize] as i16,
b[0usize] as i16,
b[1usize] as i16,
b[2usize] as i16,
b[3usize] as i16,
]
.simd_into(self)
}
#[inline(always)]
fn saturating_narrow_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i16x8<Self> {
[
a[0usize].clamp(i16::MIN as i32, i16::MAX as i32) as i16,
a[1usize].clamp(i16::MIN as i32, i16::MAX as i32) as i16,
a[2usize].clamp(i16::MIN as i32, i16::MAX as i32) as i16,
a[3usize].clamp(i16::MIN as i32, i16::MAX as i32) as i16,
b[0usize].clamp(i16::MIN as i32, i16::MAX as i32) as i16,
b[1usize].clamp(i16::MIN as i32, i16::MAX as i32) as i16,
b[2usize].clamp(i16::MIN as i32, i16::MAX as i32) as i16,
b[3usize].clamp(i16::MIN as i32, i16::MAX as i32) as i16,
]
.simd_into(self)
}
#[inline(always)]
fn relaxed_narrow_i32x4(self, a: i32x4<Self>, b: i32x4<Self>) -> i16x8<Self> {
debug_assert!(
a.as_slice()
.iter()
.chain(b.as_slice())
.all(|&value| { value >= i16::MIN as i32 && value <= i16::MAX as i32 }),
"relaxed_narrow inputs must fit in the destination type",
);
self.narrow_i32x4(a, b)
}
#[inline(always)]
fn cvt_f32_i32x4(self, a: i32x4<Self>) -> f32x4<Self> {
[
a[0usize] as f32,
a[1usize] as f32,
a[2usize] as f32,
a[3usize] as f32,
]
.simd_into(self)
}
#[inline(always)]
fn splat_u32x4(self, val: u32) -> u32x4<Self> {
[val; 4usize].simd_into(self)
}
#[inline(always)]
fn slide_u32x4<const SHIFT: usize>(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self> {
let mut dest = [Default::default(); 4usize];
dest[..4usize - SHIFT].copy_from_slice(&a.val.0[SHIFT..]);
dest[4usize - SHIFT..].copy_from_slice(&b.val.0[..SHIFT]);
dest.simd_into(self)
}
#[inline(always)]
fn add_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self> {
[
u32::wrapping_add(a[0usize], b[0usize]),
u32::wrapping_add(a[1usize], b[1usize]),
u32::wrapping_add(a[2usize], b[2usize]),
u32::wrapping_add(a[3usize], b[3usize]),
]
.simd_into(self)
}
#[inline(always)]
fn sub_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self> {
[
u32::wrapping_sub(a[0usize], b[0usize]),
u32::wrapping_sub(a[1usize], b[1usize]),
u32::wrapping_sub(a[2usize], b[2usize]),
u32::wrapping_sub(a[3usize], b[3usize]),
]
.simd_into(self)
}
#[inline(always)]
fn mul_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self> {
[
u32::wrapping_mul(a[0usize], b[0usize]),
u32::wrapping_mul(a[1usize], b[1usize]),
u32::wrapping_mul(a[2usize], b[2usize]),
u32::wrapping_mul(a[3usize], b[3usize]),
]
.simd_into(self)
}
#[inline(always)]
fn and_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self> {
[
u32::bitand(a[0usize], &b[0usize]),
u32::bitand(a[1usize], &b[1usize]),
u32::bitand(a[2usize], &b[2usize]),
u32::bitand(a[3usize], &b[3usize]),
]
.simd_into(self)
}
#[inline(always)]
fn or_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self> {
[
u32::bitor(a[0usize], &b[0usize]),
u32::bitor(a[1usize], &b[1usize]),
u32::bitor(a[2usize], &b[2usize]),
u32::bitor(a[3usize], &b[3usize]),
]
.simd_into(self)
}
#[inline(always)]
fn xor_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self> {
[
u32::bitxor(a[0usize], &b[0usize]),
u32::bitxor(a[1usize], &b[1usize]),
u32::bitxor(a[2usize], &b[2usize]),
u32::bitxor(a[3usize], &b[3usize]),
]
.simd_into(self)
}
#[inline(always)]
fn not_u32x4(self, a: u32x4<Self>) -> u32x4<Self> {
[
u32::not(a[0usize]),
u32::not(a[1usize]),
u32::not(a[2usize]),
u32::not(a[3usize]),
]
.simd_into(self)
}
#[inline(always)]
fn shl_u32x4(self, a: u32x4<Self>, shift: u32) -> u32x4<Self> {
[
u32::wrapping_shl(a[0usize], shift),
u32::wrapping_shl(a[1usize], shift),
u32::wrapping_shl(a[2usize], shift),
u32::wrapping_shl(a[3usize], shift),
]
.simd_into(self)
}
#[inline(always)]
fn shlv_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self> {
[
u32::wrapping_shl(a[0usize], b[0usize] as u32),
u32::wrapping_shl(a[1usize], b[1usize] as u32),
u32::wrapping_shl(a[2usize], b[2usize] as u32),
u32::wrapping_shl(a[3usize], b[3usize] as u32),
]
.simd_into(self)
}
#[inline(always)]
fn shr_u32x4(self, a: u32x4<Self>, shift: u32) -> u32x4<Self> {
[
u32::wrapping_shr(a[0usize], shift),
u32::wrapping_shr(a[1usize], shift),
u32::wrapping_shr(a[2usize], shift),
u32::wrapping_shr(a[3usize], shift),
]
.simd_into(self)
}
#[inline(always)]
fn shrv_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self> {
[
u32::wrapping_shr(a[0usize], b[0usize] as u32),
u32::wrapping_shr(a[1usize], b[1usize] as u32),
u32::wrapping_shr(a[2usize], b[2usize] as u32),
u32::wrapping_shr(a[3usize], b[3usize] as u32),
]
.simd_into(self)
}
#[inline(always)]
fn max_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self> {
[
u32::max(a[0usize], b[0usize]),
u32::max(a[1usize], b[1usize]),
u32::max(a[2usize], b[2usize]),
u32::max(a[3usize], b[3usize]),
]
.simd_into(self)
}
#[inline(always)]
fn min_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self> {
[
u32::min(a[0usize], b[0usize]),
u32::min(a[1usize], b[1usize]),
u32::min(a[2usize], b[2usize]),
u32::min(a[3usize], b[3usize]),
]
.simd_into(self)
}
#[inline(always)]
fn simd_eq_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> mask32x4<Self> {
[
-(u32::eq(&a[0usize], &b[0usize]) as i32),
-(u32::eq(&a[1usize], &b[1usize]) as i32),
-(u32::eq(&a[2usize], &b[2usize]) as i32),
-(u32::eq(&a[3usize], &b[3usize]) as i32),
]
.simd_into(self)
}
#[inline(always)]
fn simd_lt_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> mask32x4<Self> {
[
-(u32::lt(&a[0usize], &b[0usize]) as i32),
-(u32::lt(&a[1usize], &b[1usize]) as i32),
-(u32::lt(&a[2usize], &b[2usize]) as i32),
-(u32::lt(&a[3usize], &b[3usize]) as i32),
]
.simd_into(self)
}
#[inline(always)]
fn simd_le_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> mask32x4<Self> {
[
-(u32::le(&a[0usize], &b[0usize]) as i32),
-(u32::le(&a[1usize], &b[1usize]) as i32),
-(u32::le(&a[2usize], &b[2usize]) as i32),
-(u32::le(&a[3usize], &b[3usize]) as i32),
]
.simd_into(self)
}
#[inline(always)]
fn zip_low_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self> {
[a[0usize], b[0usize], a[1usize], b[1usize]].simd_into(self)
}
#[inline(always)]
fn zip_high_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self> {
[a[2usize], b[2usize], a[3usize], b[3usize]].simd_into(self)
}
#[inline(always)]
fn unzip_low_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self> {
[a[0usize], a[2usize], b[0usize], b[2usize]].simd_into(self)
}
#[inline(always)]
fn unzip_high_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x4<Self> {
[a[1usize], a[3usize], b[1usize], b[3usize]].simd_into(self)
}
#[inline(always)]
fn interleave_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> (u32x4<Self>, u32x4<Self>) {
(self.zip_low_u32x4(a, b), self.zip_high_u32x4(a, b))
}
#[inline(always)]
fn deinterleave_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> (u32x4<Self>, u32x4<Self>) {
(self.unzip_low_u32x4(a, b), self.unzip_high_u32x4(a, b))
}
#[inline(always)]
fn select_u32x4(self, a: mask32x4<Self>, b: u32x4<Self>, c: u32x4<Self>) -> u32x4<Self> {
[
if a.val.0[0usize] != 0 {
b[0usize]
} else {
c[0usize]
},
if a.val.0[1usize] != 0 {
b[1usize]
} else {
c[1usize]
},
if a.val.0[2usize] != 0 {
b[2usize]
} else {
c[2usize]
},
if a.val.0[3usize] != 0 {
b[3usize]
} else {
c[3usize]
},
]
.simd_into(self)
}
#[inline(always)]
fn combine_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u32x8<Self> {
let mut result = [0; 8usize];
result[0..4usize].copy_from_slice(&a.val.0);
result[4usize..8usize].copy_from_slice(&b.val.0);
result.simd_into(self)
}
#[inline(always)]
fn load_four_interleaved_u32x4(self, src: &[u32; 16usize]) -> [u32x4<Self>; 4usize] {
[
[src[0usize], src[4usize], src[8usize], src[12usize]].simd_into(self),
[src[1usize], src[5usize], src[9usize], src[13usize]].simd_into(self),
[src[2usize], src[6usize], src[10usize], src[14usize]].simd_into(self),
[src[3usize], src[7usize], src[11usize], src[15usize]].simd_into(self),
]
}
#[inline(always)]
fn store_four_interleaved_u32x4(
self,
vectors: [u32x4<Self>; 4usize],
dest: &mut [u32; 16usize],
) -> () {
*dest = [
vectors[0usize][0usize],
vectors[1usize][0usize],
vectors[2usize][0usize],
vectors[3usize][0usize],
vectors[0usize][1usize],
vectors[1usize][1usize],
vectors[2usize][1usize],
vectors[3usize][1usize],
vectors[0usize][2usize],
vectors[1usize][2usize],
vectors[2usize][2usize],
vectors[3usize][2usize],
vectors[0usize][3usize],
vectors[1usize][3usize],
vectors[2usize][3usize],
vectors[3usize][3usize],
];
}
#[inline(always)]
fn widen_u32x4(self, a: u32x4<Self>) -> (u64x2<Self>, u64x2<Self>) {
(
[a[0usize] as u64, a[1usize] as u64].simd_into(self),
[a[2usize] as u64, a[3usize] as u64].simd_into(self),
)
}
#[inline(always)]
fn narrow_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u16x8<Self> {
[
a[0usize] as u16,
a[1usize] as u16,
a[2usize] as u16,
a[3usize] as u16,
b[0usize] as u16,
b[1usize] as u16,
b[2usize] as u16,
b[3usize] as u16,
]
.simd_into(self)
}
#[inline(always)]
fn saturating_narrow_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u16x8<Self> {
[
a[0usize].clamp(u16::MIN as u32, u16::MAX as u32) as u16,
a[1usize].clamp(u16::MIN as u32, u16::MAX as u32) as u16,
a[2usize].clamp(u16::MIN as u32, u16::MAX as u32) as u16,
a[3usize].clamp(u16::MIN as u32, u16::MAX as u32) as u16,
b[0usize].clamp(u16::MIN as u32, u16::MAX as u32) as u16,
b[1usize].clamp(u16::MIN as u32, u16::MAX as u32) as u16,
b[2usize].clamp(u16::MIN as u32, u16::MAX as u32) as u16,
b[3usize].clamp(u16::MIN as u32, u16::MAX as u32) as u16,
]
.simd_into(self)
}
#[inline(always)]
fn relaxed_narrow_u32x4(self, a: u32x4<Self>, b: u32x4<Self>) -> u16x8<Self> {
debug_assert!(
a.as_slice()
.iter()
.chain(b.as_slice())
.all(|&value| { value >= u16::MIN as u32 && value <= u16::MAX as u32 }),
"relaxed_narrow inputs must fit in the destination type",
);
self.narrow_u32x4(a, b)
}
#[inline(always)]
fn cvt_f32_u32x4(self, a: u32x4<Self>) -> f32x4<Self> {
[
a[0usize] as f32,
a[1usize] as f32,
a[2usize] as f32,
a[3usize] as f32,
]
.simd_into(self)
}
#[inline(always)]
fn splat_mask32x4(self, val: bool) -> mask32x4<Self> {
let val: i32 = if val { !0 } else { 0 };
[val; 4usize].simd_into(self)
}
#[inline(always)]
fn from_bitmask_mask32x4(self, bits: u64) -> mask32x4<Self> {
let lanes: [i32; 4usize] = [
if bits & 1 != 0 { !0 } else { 0 },
if (bits >> 1usize) & 1 != 0 { !0 } else { 0 },
if (bits >> 2usize) & 1 != 0 { !0 } else { 0 },
if (bits >> 3usize) & 1 != 0 { !0 } else { 0 },
];
lanes.simd_into(self)
}
#[inline(always)]
fn to_bitmask_mask32x4(self, a: mask32x4<Self>) -> u64 {
let lanes: [i32; 4usize] = a.into();
let mut bits = 0u64;
let mut i = 0;
while i < 4usize {
if lanes[i] != 0 {
bits |= 1u64 << i;
}
i += 1;
}
bits
}
#[inline(always)]
fn set_mask32x4(self, a: &mut mask32x4<Self>, index: usize, value: bool) -> () {
assert!(
index < 4usize,
"mask lane index {index} is out of bounds for {} lanes",
4usize
);
let mut lanes: [i32; 4usize] = (*a).into();
lanes[index] = if value { !0 } else { 0 };
*a = lanes.simd_into(self);
}
#[inline(always)]
fn and_mask32x4(self, a: mask32x4<Self>, b: mask32x4<Self>) -> mask32x4<Self> {
[
i32::bitand(a.val.0[0usize], &b.val.0[0usize]),
i32::bitand(a.val.0[1usize], &b.val.0[1usize]),
i32::bitand(a.val.0[2usize], &b.val.0[2usize]),
i32::bitand(a.val.0[3usize], &b.val.0[3usize]),
]
.simd_into(self)
}
#[inline(always)]
fn or_mask32x4(self, a: mask32x4<Self>, b: mask32x4<Self>) -> mask32x4<Self> {
[
i32::bitor(a.val.0[0usize], &b.val.0[0usize]),
i32::bitor(a.val.0[1usize], &b.val.0[1usize]),
i32::bitor(a.val.0[2usize], &b.val.0[2usize]),
i32::bitor(a.val.0[3usize], &b.val.0[3usize]),
]
.simd_into(self)
}
#[inline(always)]
fn xor_mask32x4(self, a: mask32x4<Self>, b: mask32x4<Self>) -> mask32x4<Self> {
[
i32::bitxor(a.val.0[0usize], &b.val.0[0usize]),
i32::bitxor(a.val.0[1usize], &b.val.0[1usize]),
i32::bitxor(a.val.0[2usize], &b.val.0[2usize]),
i32::bitxor(a.val.0[3usize], &b.val.0[3usize]),
]
.simd_into(self)
}
#[inline(always)]
fn not_mask32x4(self, a: mask32x4<Self>) -> mask32x4<Self> {
[
i32::not(a.val.0[0usize]),
i32::not(a.val.0[1usize]),
i32::not(a.val.0[2usize]),
i32::not(a.val.0[3usize]),
]
.simd_into(self)
}
#[inline(always)]
fn select_mask32x4(
self,
a: mask32x4<Self>,
b: mask32x4<Self>,
c: mask32x4<Self>,
) -> mask32x4<Self> {
[
if a.val.0[0usize] != 0 {
b.val.0[0usize]
} else {
c.val.0[0usize]
},
if a.val.0[1usize] != 0 {
b.val.0[1usize]
} else {
c.val.0[1usize]
},
if a.val.0[2usize] != 0 {
b.val.0[2usize]
} else {
c.val.0[2usize]
},
if a.val.0[3usize] != 0 {
b.val.0[3usize]
} else {
c.val.0[3usize]
},
]
.simd_into(self)
}
#[inline(always)]
fn simd_eq_mask32x4(self, a: mask32x4<Self>, b: mask32x4<Self>) -> mask32x4<Self> {
[
-(i32::eq(&a.val.0[0usize], &b.val.0[0usize]) as i32),
-(i32::eq(&a.val.0[1usize], &b.val.0[1usize]) as i32),
-(i32::eq(&a.val.0[2usize], &b.val.0[2usize]) as i32),
-(i32::eq(&a.val.0[3usize], &b.val.0[3usize]) as i32),
]
.simd_into(self)
}
#[inline(always)]
fn any_true_mask32x4(self, a: mask32x4<Self>) -> bool {
a.val.0[0usize] != 0 || a.val.0[1usize] != 0 || a.val.0[2usize] != 0 || a.val.0[3usize] != 0
}
#[inline(always)]
fn all_true_mask32x4(self, a: mask32x4<Self>) -> bool {
a.val.0[0usize] != 0 && a.val.0[1usize] != 0 && a.val.0[2usize] != 0 && a.val.0[3usize] != 0
}
#[inline(always)]
fn any_false_mask32x4(self, a: mask32x4<Self>) -> bool {
a.val.0[0usize] == 0 || a.val.0[1usize] == 0 || a.val.0[2usize] == 0 || a.val.0[3usize] == 0
}
#[inline(always)]
fn all_false_mask32x4(self, a: mask32x4<Self>) -> bool {
a.val.0[0usize] == 0 && a.val.0[1usize] == 0 && a.val.0[2usize] == 0 && a.val.0[3usize] == 0
}
#[inline(always)]
fn combine_mask32x4(self, a: mask32x4<Self>, b: mask32x4<Self>) -> mask32x8<Self> {
let mut result = [0; 8usize];
result[0..4usize].copy_from_slice(&a.val.0);
result[4usize..8usize].copy_from_slice(&b.val.0);
result.simd_into(self)
}
#[inline(always)]
fn splat_f64x2(self, val: f64) -> f64x2<Self> {
[val; 2usize].simd_into(self)
}
#[inline(always)]
fn slide_f64x2<const SHIFT: usize>(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self> {
let mut dest = [Default::default(); 2usize];
dest[..2usize - SHIFT].copy_from_slice(&a.val.0[SHIFT..]);
dest[2usize - SHIFT..].copy_from_slice(&b.val.0[..SHIFT]);
dest.simd_into(self)
}
#[inline(always)]
fn abs_f64x2(self, a: f64x2<Self>) -> f64x2<Self> {
[f64::abs(a[0usize]), f64::abs(a[1usize])].simd_into(self)
}
#[inline(always)]
fn neg_f64x2(self, a: f64x2<Self>) -> f64x2<Self> {
[f64::neg(a[0usize]), f64::neg(a[1usize])].simd_into(self)
}
#[inline(always)]
fn sqrt_f64x2(self, a: f64x2<Self>) -> f64x2<Self> {
[f64::sqrt(a[0usize]), f64::sqrt(a[1usize])].simd_into(self)
}
#[inline(always)]
fn approximate_recip_f64x2(self, a: f64x2<Self>) -> f64x2<Self> {
1.0 / a
}
#[inline(always)]
fn add_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self> {
[
f64::add(a[0usize], &b[0usize]),
f64::add(a[1usize], &b[1usize]),
]
.simd_into(self)
}
#[inline(always)]
fn sub_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self> {
[
f64::sub(a[0usize], &b[0usize]),
f64::sub(a[1usize], &b[1usize]),
]
.simd_into(self)
}
#[inline(always)]
fn mul_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self> {
[
f64::mul(a[0usize], &b[0usize]),
f64::mul(a[1usize], &b[1usize]),
]
.simd_into(self)
}
#[inline(always)]
fn div_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self> {
[
f64::div(a[0usize], &b[0usize]),
f64::div(a[1usize], &b[1usize]),
]
.simd_into(self)
}
#[inline(always)]
fn copysign_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self> {
[
f64::copysign(a[0usize], b[0usize]),
f64::copysign(a[1usize], b[1usize]),
]
.simd_into(self)
}
#[inline(always)]
fn max_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self> {
[
f64::max(a[0usize], b[0usize]),
f64::max(a[1usize], b[1usize]),
]
.simd_into(self)
}
#[inline(always)]
fn min_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self> {
[
f64::min(a[0usize], b[0usize]),
f64::min(a[1usize], b[1usize]),
]
.simd_into(self)
}
#[inline(always)]
fn max_precise_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self> {
[
f64::max(a[0usize], b[0usize]),
f64::max(a[1usize], b[1usize]),
]
.simd_into(self)
}
#[inline(always)]
fn min_precise_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self> {
[
f64::min(a[0usize], b[0usize]),
f64::min(a[1usize], b[1usize]),
]
.simd_into(self)
}
#[inline(always)]
fn simd_eq_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> mask64x2<Self> {
[
-(f64::eq(&a[0usize], &b[0usize]) as i64),
-(f64::eq(&a[1usize], &b[1usize]) as i64),
]
.simd_into(self)
}
#[inline(always)]
fn simd_lt_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> mask64x2<Self> {
[
-(f64::lt(&a[0usize], &b[0usize]) as i64),
-(f64::lt(&a[1usize], &b[1usize]) as i64),
]
.simd_into(self)
}
#[inline(always)]
fn simd_le_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> mask64x2<Self> {
[
-(f64::le(&a[0usize], &b[0usize]) as i64),
-(f64::le(&a[1usize], &b[1usize]) as i64),
]
.simd_into(self)
}
#[inline(always)]
fn zip_low_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self> {
[a[0usize], b[0usize]].simd_into(self)
}
#[inline(always)]
fn zip_high_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self> {
[a[1usize], b[1usize]].simd_into(self)
}
#[inline(always)]
fn unzip_low_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self> {
[a[0usize], b[0usize]].simd_into(self)
}
#[inline(always)]
fn unzip_high_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x2<Self> {
[a[1usize], b[1usize]].simd_into(self)
}
#[inline(always)]
fn interleave_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> (f64x2<Self>, f64x2<Self>) {
(self.zip_low_f64x2(a, b), self.zip_high_f64x2(a, b))
}
#[inline(always)]
fn deinterleave_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> (f64x2<Self>, f64x2<Self>) {
(self.unzip_low_f64x2(a, b), self.unzip_high_f64x2(a, b))
}
#[inline(always)]
fn mul_add_f64x2(self, a: f64x2<Self>, b: f64x2<Self>, c: f64x2<Self>) -> f64x2<Self> {
a.mul(b).add(c)
}
#[inline(always)]
fn mul_sub_f64x2(self, a: f64x2<Self>, b: f64x2<Self>, c: f64x2<Self>) -> f64x2<Self> {
a.mul(b).sub(c)
}
#[inline(always)]
fn floor_f64x2(self, a: f64x2<Self>) -> f64x2<Self> {
[f64::floor(a[0usize]), f64::floor(a[1usize])].simd_into(self)
}
#[inline(always)]
fn ceil_f64x2(self, a: f64x2<Self>) -> f64x2<Self> {
[f64::ceil(a[0usize]), f64::ceil(a[1usize])].simd_into(self)
}
#[inline(always)]
fn round_ties_even_f64x2(self, a: f64x2<Self>) -> f64x2<Self> {
[
f64::round_ties_even(a[0usize]),
f64::round_ties_even(a[1usize]),
]
.simd_into(self)
}
#[inline(always)]
fn fract_f64x2(self, a: f64x2<Self>) -> f64x2<Self> {
[f64::fract(a[0usize]), f64::fract(a[1usize])].simd_into(self)
}
#[inline(always)]
fn trunc_f64x2(self, a: f64x2<Self>) -> f64x2<Self> {
[f64::trunc(a[0usize]), f64::trunc(a[1usize])].simd_into(self)
}
#[inline(always)]
fn select_f64x2(self, a: mask64x2<Self>, b: f64x2<Self>, c: f64x2<Self>) -> f64x2<Self> {
[
if a.val.0[0usize] != 0 {
b[0usize]
} else {
c[0usize]
},
if a.val.0[1usize] != 0 {
b[1usize]
} else {
c[1usize]
},
]
.simd_into(self)
}
#[inline(always)]
fn combine_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f64x4<Self> {
let mut result = [0.0; 4usize];
result[0..2usize].copy_from_slice(&a.val.0);
result[2usize..4usize].copy_from_slice(&b.val.0);
result.simd_into(self)
}
#[inline(always)]
fn load_four_interleaved_f64x2(self, src: &[f64; 8usize]) -> [f64x2<Self>; 4usize] {
[
[src[0usize], src[4usize]].simd_into(self),
[src[1usize], src[5usize]].simd_into(self),
[src[2usize], src[6usize]].simd_into(self),
[src[3usize], src[7usize]].simd_into(self),
]
}
#[inline(always)]
fn store_four_interleaved_f64x2(
self,
vectors: [f64x2<Self>; 4usize],
dest: &mut [f64; 8usize],
) -> () {
*dest = [
vectors[0usize][0usize],
vectors[1usize][0usize],
vectors[2usize][0usize],
vectors[3usize][0usize],
vectors[0usize][1usize],
vectors[1usize][1usize],
vectors[2usize][1usize],
vectors[3usize][1usize],
];
}
#[inline(always)]
fn narrow_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f32x4<Self> {
[
a[0usize] as f32,
a[1usize] as f32,
b[0usize] as f32,
b[1usize] as f32,
]
.simd_into(self)
}
#[inline(always)]
fn saturating_narrow_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f32x4<Self> {
[
a[0usize] as f32,
a[1usize] as f32,
b[0usize] as f32,
b[1usize] as f32,
]
.simd_into(self)
}
#[inline(always)]
fn relaxed_narrow_f64x2(self, a: f64x2<Self>, b: f64x2<Self>) -> f32x4<Self> {
self.narrow_f64x2(a, b)
}
#[inline(always)]
fn cvt_u64_f64x2(self, a: f64x2<Self>) -> u64x2<Self> {
[a[0usize] as u64, a[1usize] as u64].simd_into(self)
}
#[inline(always)]
fn cvt_u64_precise_f64x2(self, a: f64x2<Self>) -> u64x2<Self> {
[a[0usize] as u64, a[1usize] as u64].simd_into(self)
}
#[inline(always)]
fn cvt_i64_f64x2(self, a: f64x2<Self>) -> i64x2<Self> {
[a[0usize] as i64, a[1usize] as i64].simd_into(self)
}
#[inline(always)]
fn cvt_i64_precise_f64x2(self, a: f64x2<Self>) -> i64x2<Self> {
[a[0usize] as i64, a[1usize] as i64].simd_into(self)
}
#[inline(always)]
fn splat_i64x2(self, val: i64) -> i64x2<Self> {
[val; 2usize].simd_into(self)
}
#[inline(always)]
fn slide_i64x2<const SHIFT: usize>(self, a: i64x2<Self>, b: i64x2<Self>) -> i64x2<Self> {
let mut dest = [Default::default(); 2usize];
dest[..2usize - SHIFT].copy_from_slice(&a.val.0[SHIFT..]);
dest[2usize - SHIFT..].copy_from_slice(&b.val.0[..SHIFT]);
dest.simd_into(self)
}
#[inline(always)]
fn add_i64x2(self, a: i64x2<Self>, b: i64x2<Self>) -> i64x2<Self> {
[
i64::wrapping_add(a[0usize], b[0usize]),
i64::wrapping_add(a[1usize], b[1usize]),
]
.simd_into(self)
}
#[inline(always)]
fn sub_i64x2(self, a: i64x2<Self>, b: i64x2<Self>) -> i64x2<Self> {
[
i64::wrapping_sub(a[0usize], b[0usize]),
i64::wrapping_sub(a[1usize], b[1usize]),
]
.simd_into(self)
}
#[inline(always)]
fn mul_i64x2(self, a: i64x2<Self>, b: i64x2<Self>) -> i64x2<Self> {
[
i64::wrapping_mul(a[0usize], b[0usize]),
i64::wrapping_mul(a[1usize], b[1usize]),
]
.simd_into(self)
}
#[inline(always)]
fn and_i64x2(self, a: i64x2<Self>, b: i64x2<Self>) -> i64x2<Self> {
[
i64::bitand(a[0usize], &b[0usize]),
i64::bitand(a[1usize], &b[1usize]),
]
.simd_into(self)
}
#[inline(always)]
fn or_i64x2(self, a: i64x2<Self>, b: i64x2<Self>) -> i64x2<Self> {
[
i64::bitor(a[0usize], &b[0usize]),
i64::bitor(a[1usize], &b[1usize]),
]
.simd_into(self)
}
#[inline(always)]
fn xor_i64x2(self, a: i64x2<Self>, b: i64x2<Self>) -> i64x2<Self> {
[
i64::bitxor(a[0usize], &b[0usize]),
i64::bitxor(a[1usize], &b[1usize]),
]
.simd_into(self)
}
#[inline(always)]
fn not_i64x2(self, a: i64x2<Self>) -> i64x2<Self> {
[i64::not(a[0usize]), i64::not(a[1usize])].simd_into(self)
}
#[inline(always)]
fn shl_i64x2(self, a: i64x2<Self>, shift: u32) -> i64x2<Self> {
[
i64::wrapping_shl(a[0usize], shift),
i64::wrapping_shl(a[1usize], shift),
]
.simd_into(self)
}
#[inline(always)]
fn shlv_i64x2(self, a: i64x2<Self>, b: i64x2<Self>) -> i64x2<Self> {
[
i64::wrapping_shl(a[0usize], b[0usize] as u32),
i64::wrapping_shl(a[1usize], b[1usize] as u32),
]
.simd_into(self)
}
#[inline(always)]
fn shr_i64x2(self, a: i64x2<Self>, shift: u32) -> i64x2<Self> {
[
i64::wrapping_shr(a[0usize], shift),
i64::wrapping_shr(a[1usize], shift),
]
.simd_into(self)
}
#[inline(always)]
fn shrv_i64x2(self, a: i64x2<Self>, b: i64x2<Self>) -> i64x2<Self> {
[
i64::wrapping_shr(a[0usize], b[0usize] as u32),
i64::wrapping_shr(a[1usize], b[1usize] as u32),
]
.simd_into(self)
}
#[inline(always)]
fn max_i64x2(self, a: i64x2<Self>, b: i64x2<Self>) -> i64x2<Self> {
[
i64::max(a[0usize], b[0usize]),
i64::max(a[1usize], b[1usize]),
]
.simd_into(self)
}
#[inline(always)]
fn min_i64x2(self, a: i64x2<Self>, b: i64x2<Self>) -> i64x2<Self> {
[
i64::min(a[0usize], b[0usize]),
i64::min(a[1usize], b[1usize]),
]
.simd_into(self)
}
#[inline(always)]
fn simd_eq_i64x2(self, a: i64x2<Self>, b: i64x2<Self>) -> mask64x2<Self> {
[
-(i64::eq(&a[0usize], &b[0usize]) as i64),
-(i64::eq(&a[1usize], &b[1usize]) as i64),
]
.simd_into(self)
}
#[inline(always)]
fn simd_lt_i64x2(self, a: i64x2<Self>, b: i64x2<Self>) -> mask64x2<Self> {
[
-(i64::lt(&a[0usize], &b[0usize]) as i64),
-(i64::lt(&a[1usize], &b[1usize]) as i64),
]
.simd_into(self)
}
#[inline(always)]
fn simd_le_i64x2(self, a: i64x2<Self>, b: i64x2<Self>) -> mask64x2<Self> {
[
-(i64::le(&a[0usize], &b[0usize]) as i64),
-(i64::le(&a[1usize], &b[1usize]) as i64),
]
.simd_into(self)
}
#[inline(always)]
fn zip_low_i64x2(self, a: i64x2<Self>, b: i64x2<Self>) -> i64x2<Self> {
[a[0usize], b[0usize]].simd_into(self)
}
#[inline(always)]
fn zip_high_i64x2(self, a: i64x2<Self>, b: i64x2<Self>) -> i64x2<Self> {
[a[1usize], b[1usize]].simd_into(self)
}
#[inline(always)]
fn unzip_low_i64x2(self, a: i64x2<Self>, b: i64x2<Self>) -> i64x2<Self> {
[a[0usize], b[0usize]].simd_into(self)
}
#[inline(always)]
fn unzip_high_i64x2(self, a: i64x2<Self>, b: i64x2<Self>) -> i64x2<Self> {
[a[1usize], b[1usize]].simd_into(self)
}
#[inline(always)]
fn interleave_i64x2(self, a: i64x2<Self>, b: i64x2<Self>) -> (i64x2<Self>, i64x2<Self>) {
(self.zip_low_i64x2(a, b), self.zip_high_i64x2(a, b))
}
#[inline(always)]
fn deinterleave_i64x2(self, a: i64x2<Self>, b: i64x2<Self>) -> (i64x2<Self>, i64x2<Self>) {
(self.unzip_low_i64x2(a, b), self.unzip_high_i64x2(a, b))
}
#[inline(always)]
fn select_i64x2(self, a: mask64x2<Self>, b: i64x2<Self>, c: i64x2<Self>) -> i64x2<Self> {
[
if a.val.0[0usize] != 0 {
b[0usize]
} else {
c[0usize]
},
if a.val.0[1usize] != 0 {
b[1usize]
} else {
c[1usize]
},
]
.simd_into(self)
}
#[inline(always)]
fn combine_i64x2(self, a: i64x2<Self>, b: i64x2<Self>) -> i64x4<Self> {
let mut result = [0; 4usize];
result[0..2usize].copy_from_slice(&a.val.0);
result[2usize..4usize].copy_from_slice(&b.val.0);
result.simd_into(self)
}
#[inline(always)]
fn neg_i64x2(self, a: i64x2<Self>) -> i64x2<Self> {
[i64::wrapping_neg(a[0usize]), i64::wrapping_neg(a[1usize])].simd_into(self)
}
#[inline(always)]
fn load_four_interleaved_i64x2(self, src: &[i64; 8usize]) -> [i64x2<Self>; 4usize] {
[
[src[0usize], src[4usize]].simd_into(self),
[src[1usize], src[5usize]].simd_into(self),
[src[2usize], src[6usize]].simd_into(self),
[src[3usize], src[7usize]].simd_into(self),
]
}
#[inline(always)]
fn store_four_interleaved_i64x2(
self,
vectors: [i64x2<Self>; 4usize],
dest: &mut [i64; 8usize],
) -> () {
*dest = [
vectors[0usize][0usize],
vectors[1usize][0usize],
vectors[2usize][0usize],
vectors[3usize][0usize],
vectors[0usize][1usize],
vectors[1usize][1usize],
vectors[2usize][1usize],
vectors[3usize][1usize],
];
}
#[inline(always)]
fn narrow_i64x2(self, a: i64x2<Self>, b: i64x2<Self>) -> i32x4<Self> {
[
a[0usize] as i32,
a[1usize] as i32,
b[0usize] as i32,
b[1usize] as i32,
]
.simd_into(self)
}
#[inline(always)]
fn saturating_narrow_i64x2(self, a: i64x2<Self>, b: i64x2<Self>) -> i32x4<Self> {
[
a[0usize].clamp(i32::MIN as i64, i32::MAX as i64) as i32,
a[1usize].clamp(i32::MIN as i64, i32::MAX as i64) as i32,
b[0usize].clamp(i32::MIN as i64, i32::MAX as i64) as i32,
b[1usize].clamp(i32::MIN as i64, i32::MAX as i64) as i32,
]
.simd_into(self)
}
#[inline(always)]
fn relaxed_narrow_i64x2(self, a: i64x2<Self>, b: i64x2<Self>) -> i32x4<Self> {
debug_assert!(
a.as_slice()
.iter()
.chain(b.as_slice())
.all(|&value| { value >= i32::MIN as i64 && value <= i32::MAX as i64 }),
"relaxed_narrow inputs must fit in the destination type",
);
self.narrow_i64x2(a, b)
}
#[inline(always)]
fn cvt_f64_i64x2(self, a: i64x2<Self>) -> f64x2<Self> {
[a[0usize] as f64, a[1usize] as f64].simd_into(self)
}
#[inline(always)]
fn splat_u64x2(self, val: u64) -> u64x2<Self> {
[val; 2usize].simd_into(self)
}
#[inline(always)]
fn slide_u64x2<const SHIFT: usize>(self, a: u64x2<Self>, b: u64x2<Self>) -> u64x2<Self> {
let mut dest = [Default::default(); 2usize];
dest[..2usize - SHIFT].copy_from_slice(&a.val.0[SHIFT..]);
dest[2usize - SHIFT..].copy_from_slice(&b.val.0[..SHIFT]);
dest.simd_into(self)
}
#[inline(always)]
fn add_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> u64x2<Self> {
[
u64::wrapping_add(a[0usize], b[0usize]),
u64::wrapping_add(a[1usize], b[1usize]),
]
.simd_into(self)
}
#[inline(always)]
fn sub_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> u64x2<Self> {
[
u64::wrapping_sub(a[0usize], b[0usize]),
u64::wrapping_sub(a[1usize], b[1usize]),
]
.simd_into(self)
}
#[inline(always)]
fn mul_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> u64x2<Self> {
[
u64::wrapping_mul(a[0usize], b[0usize]),
u64::wrapping_mul(a[1usize], b[1usize]),
]
.simd_into(self)
}
#[inline(always)]
fn and_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> u64x2<Self> {
[
u64::bitand(a[0usize], &b[0usize]),
u64::bitand(a[1usize], &b[1usize]),
]
.simd_into(self)
}
#[inline(always)]
fn or_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> u64x2<Self> {
[
u64::bitor(a[0usize], &b[0usize]),
u64::bitor(a[1usize], &b[1usize]),
]
.simd_into(self)
}
#[inline(always)]
fn xor_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> u64x2<Self> {
[
u64::bitxor(a[0usize], &b[0usize]),
u64::bitxor(a[1usize], &b[1usize]),
]
.simd_into(self)
}
#[inline(always)]
fn not_u64x2(self, a: u64x2<Self>) -> u64x2<Self> {
[u64::not(a[0usize]), u64::not(a[1usize])].simd_into(self)
}
#[inline(always)]
fn shl_u64x2(self, a: u64x2<Self>, shift: u32) -> u64x2<Self> {
[
u64::wrapping_shl(a[0usize], shift),
u64::wrapping_shl(a[1usize], shift),
]
.simd_into(self)
}
#[inline(always)]
fn shlv_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> u64x2<Self> {
[
u64::wrapping_shl(a[0usize], b[0usize] as u32),
u64::wrapping_shl(a[1usize], b[1usize] as u32),
]
.simd_into(self)
}
#[inline(always)]
fn shr_u64x2(self, a: u64x2<Self>, shift: u32) -> u64x2<Self> {
[
u64::wrapping_shr(a[0usize], shift),
u64::wrapping_shr(a[1usize], shift),
]
.simd_into(self)
}
#[inline(always)]
fn shrv_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> u64x2<Self> {
[
u64::wrapping_shr(a[0usize], b[0usize] as u32),
u64::wrapping_shr(a[1usize], b[1usize] as u32),
]
.simd_into(self)
}
#[inline(always)]
fn max_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> u64x2<Self> {
[
u64::max(a[0usize], b[0usize]),
u64::max(a[1usize], b[1usize]),
]
.simd_into(self)
}
#[inline(always)]
fn min_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> u64x2<Self> {
[
u64::min(a[0usize], b[0usize]),
u64::min(a[1usize], b[1usize]),
]
.simd_into(self)
}
#[inline(always)]
fn simd_eq_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> mask64x2<Self> {
[
-(u64::eq(&a[0usize], &b[0usize]) as i64),
-(u64::eq(&a[1usize], &b[1usize]) as i64),
]
.simd_into(self)
}
#[inline(always)]
fn simd_lt_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> mask64x2<Self> {
[
-(u64::lt(&a[0usize], &b[0usize]) as i64),
-(u64::lt(&a[1usize], &b[1usize]) as i64),
]
.simd_into(self)
}
#[inline(always)]
fn simd_le_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> mask64x2<Self> {
[
-(u64::le(&a[0usize], &b[0usize]) as i64),
-(u64::le(&a[1usize], &b[1usize]) as i64),
]
.simd_into(self)
}
#[inline(always)]
fn zip_low_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> u64x2<Self> {
[a[0usize], b[0usize]].simd_into(self)
}
#[inline(always)]
fn zip_high_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> u64x2<Self> {
[a[1usize], b[1usize]].simd_into(self)
}
#[inline(always)]
fn unzip_low_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> u64x2<Self> {
[a[0usize], b[0usize]].simd_into(self)
}
#[inline(always)]
fn unzip_high_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> u64x2<Self> {
[a[1usize], b[1usize]].simd_into(self)
}
#[inline(always)]
fn interleave_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> (u64x2<Self>, u64x2<Self>) {
(self.zip_low_u64x2(a, b), self.zip_high_u64x2(a, b))
}
#[inline(always)]
fn deinterleave_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> (u64x2<Self>, u64x2<Self>) {
(self.unzip_low_u64x2(a, b), self.unzip_high_u64x2(a, b))
}
#[inline(always)]
fn select_u64x2(self, a: mask64x2<Self>, b: u64x2<Self>, c: u64x2<Self>) -> u64x2<Self> {
[
if a.val.0[0usize] != 0 {
b[0usize]
} else {
c[0usize]
},
if a.val.0[1usize] != 0 {
b[1usize]
} else {
c[1usize]
},
]
.simd_into(self)
}
#[inline(always)]
fn combine_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> u64x4<Self> {
let mut result = [0; 4usize];
result[0..2usize].copy_from_slice(&a.val.0);
result[2usize..4usize].copy_from_slice(&b.val.0);
result.simd_into(self)
}
#[inline(always)]
fn load_four_interleaved_u64x2(self, src: &[u64; 8usize]) -> [u64x2<Self>; 4usize] {
[
[src[0usize], src[4usize]].simd_into(self),
[src[1usize], src[5usize]].simd_into(self),
[src[2usize], src[6usize]].simd_into(self),
[src[3usize], src[7usize]].simd_into(self),
]
}
#[inline(always)]
fn store_four_interleaved_u64x2(
self,
vectors: [u64x2<Self>; 4usize],
dest: &mut [u64; 8usize],
) -> () {
*dest = [
vectors[0usize][0usize],
vectors[1usize][0usize],
vectors[2usize][0usize],
vectors[3usize][0usize],
vectors[0usize][1usize],
vectors[1usize][1usize],
vectors[2usize][1usize],
vectors[3usize][1usize],
];
}
#[inline(always)]
fn narrow_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> u32x4<Self> {
[
a[0usize] as u32,
a[1usize] as u32,
b[0usize] as u32,
b[1usize] as u32,
]
.simd_into(self)
}
#[inline(always)]
fn saturating_narrow_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> u32x4<Self> {
[
a[0usize].clamp(u32::MIN as u64, u32::MAX as u64) as u32,
a[1usize].clamp(u32::MIN as u64, u32::MAX as u64) as u32,
b[0usize].clamp(u32::MIN as u64, u32::MAX as u64) as u32,
b[1usize].clamp(u32::MIN as u64, u32::MAX as u64) as u32,
]
.simd_into(self)
}
#[inline(always)]
fn relaxed_narrow_u64x2(self, a: u64x2<Self>, b: u64x2<Self>) -> u32x4<Self> {
debug_assert!(
a.as_slice()
.iter()
.chain(b.as_slice())
.all(|&value| { value >= u32::MIN as u64 && value <= u32::MAX as u64 }),
"relaxed_narrow inputs must fit in the destination type",
);
self.narrow_u64x2(a, b)
}
#[inline(always)]
fn cvt_f64_u64x2(self, a: u64x2<Self>) -> f64x2<Self> {
[a[0usize] as f64, a[1usize] as f64].simd_into(self)
}
#[inline(always)]
fn splat_mask64x2(self, val: bool) -> mask64x2<Self> {
let val: i64 = if val { !0 } else { 0 };
[val; 2usize].simd_into(self)
}
#[inline(always)]
fn from_bitmask_mask64x2(self, bits: u64) -> mask64x2<Self> {
let lanes: [i64; 2usize] = [
if bits & 1 != 0 { !0 } else { 0 },
if (bits >> 1usize) & 1 != 0 { !0 } else { 0 },
];
lanes.simd_into(self)
}
#[inline(always)]
fn to_bitmask_mask64x2(self, a: mask64x2<Self>) -> u64 {
let lanes: [i64; 2usize] = a.into();
let mut bits = 0u64;
let mut i = 0;
while i < 2usize {
if lanes[i] != 0 {
bits |= 1u64 << i;
}
i += 1;
}
bits
}
#[inline(always)]
fn set_mask64x2(self, a: &mut mask64x2<Self>, index: usize, value: bool) -> () {
assert!(
index < 2usize,
"mask lane index {index} is out of bounds for {} lanes",
2usize
);
let mut lanes: [i64; 2usize] = (*a).into();
lanes[index] = if value { !0 } else { 0 };
*a = lanes.simd_into(self);
}
#[inline(always)]
fn and_mask64x2(self, a: mask64x2<Self>, b: mask64x2<Self>) -> mask64x2<Self> {
[
i64::bitand(a.val.0[0usize], &b.val.0[0usize]),
i64::bitand(a.val.0[1usize], &b.val.0[1usize]),
]
.simd_into(self)
}
#[inline(always)]
fn or_mask64x2(self, a: mask64x2<Self>, b: mask64x2<Self>) -> mask64x2<Self> {
[
i64::bitor(a.val.0[0usize], &b.val.0[0usize]),
i64::bitor(a.val.0[1usize], &b.val.0[1usize]),
]
.simd_into(self)
}
#[inline(always)]
fn xor_mask64x2(self, a: mask64x2<Self>, b: mask64x2<Self>) -> mask64x2<Self> {
[
i64::bitxor(a.val.0[0usize], &b.val.0[0usize]),
i64::bitxor(a.val.0[1usize], &b.val.0[1usize]),
]
.simd_into(self)
}
#[inline(always)]
fn not_mask64x2(self, a: mask64x2<Self>) -> mask64x2<Self> {
[i64::not(a.val.0[0usize]), i64::not(a.val.0[1usize])].simd_into(self)
}
#[inline(always)]
fn select_mask64x2(
self,
a: mask64x2<Self>,
b: mask64x2<Self>,
c: mask64x2<Self>,
) -> mask64x2<Self> {
[
if a.val.0[0usize] != 0 {
b.val.0[0usize]
} else {
c.val.0[0usize]
},
if a.val.0[1usize] != 0 {
b.val.0[1usize]
} else {
c.val.0[1usize]
},
]
.simd_into(self)
}
#[inline(always)]
fn simd_eq_mask64x2(self, a: mask64x2<Self>, b: mask64x2<Self>) -> mask64x2<Self> {
[
-(i64::eq(&a.val.0[0usize], &b.val.0[0usize]) as i64),
-(i64::eq(&a.val.0[1usize], &b.val.0[1usize]) as i64),
]
.simd_into(self)
}
#[inline(always)]
fn any_true_mask64x2(self, a: mask64x2<Self>) -> bool {
a.val.0[0usize] != 0 || a.val.0[1usize] != 0
}
#[inline(always)]
fn all_true_mask64x2(self, a: mask64x2<Self>) -> bool {
a.val.0[0usize] != 0 && a.val.0[1usize] != 0
}
#[inline(always)]
fn any_false_mask64x2(self, a: mask64x2<Self>) -> bool {
a.val.0[0usize] == 0 || a.val.0[1usize] == 0
}
#[inline(always)]
fn all_false_mask64x2(self, a: mask64x2<Self>) -> bool {
a.val.0[0usize] == 0 && a.val.0[1usize] == 0
}
#[inline(always)]
fn combine_mask64x2(self, a: mask64x2<Self>, b: mask64x2<Self>) -> mask64x4<Self> {
let mut result = [0; 4usize];
result[0..2usize].copy_from_slice(&a.val.0);
result[2usize..4usize].copy_from_slice(&b.val.0);
result.simd_into(self)
}
#[inline(always)]
fn slide_f32x8<const SHIFT: usize>(self, a: f32x8<Self>, b: f32x8<Self>) -> f32x8<Self> {
let mut dest = [Default::default(); 8usize];
dest[..8usize - SHIFT].copy_from_slice(&a.val.0[SHIFT..]);
dest[8usize - SHIFT..].copy_from_slice(&b.val.0[..SHIFT]);
dest.simd_into(self)
}
#[inline(always)]
fn combine_f32x8(self, a: f32x8<Self>, b: f32x8<Self>) -> f32x16<Self> {
let mut result = [0.0; 16usize];
result[0..8usize].copy_from_slice(&a.val.0);
result[8usize..16usize].copy_from_slice(&b.val.0);
result.simd_into(self)
}
#[inline(always)]
fn split_f32x8(self, a: f32x8<Self>) -> (f32x4<Self>, f32x4<Self>) {
let mut b0 = [0.0; 4usize];
let mut b1 = [0.0; 4usize];
b0.copy_from_slice(&a.val.0[0..4usize]);
b1.copy_from_slice(&a.val.0[4usize..8usize]);
(b0.simd_into(self), b1.simd_into(self))
}
#[inline(always)]
fn slide_i8x32<const SHIFT: usize>(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x32<Self> {
let mut dest = [Default::default(); 32usize];
dest[..32usize - SHIFT].copy_from_slice(&a.val.0[SHIFT..]);
dest[32usize - SHIFT..].copy_from_slice(&b.val.0[..SHIFT]);
dest.simd_into(self)
}
#[inline(always)]
fn combine_i8x32(self, a: i8x32<Self>, b: i8x32<Self>) -> i8x64<Self> {
let mut result = [0; 64usize];
result[0..32usize].copy_from_slice(&a.val.0);
result[32usize..64usize].copy_from_slice(&b.val.0);
result.simd_into(self)
}
#[inline(always)]
fn split_i8x32(self, a: i8x32<Self>) -> (i8x16<Self>, i8x16<Self>) {
let mut b0 = [0; 16usize];
let mut b1 = [0; 16usize];
b0.copy_from_slice(&a.val.0[0..16usize]);
b1.copy_from_slice(&a.val.0[16usize..32usize]);
(b0.simd_into(self), b1.simd_into(self))
}
#[inline(always)]
fn slide_u8x32<const SHIFT: usize>(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x32<Self> {
let mut dest = [Default::default(); 32usize];
dest[..32usize - SHIFT].copy_from_slice(&a.val.0[SHIFT..]);
dest[32usize - SHIFT..].copy_from_slice(&b.val.0[..SHIFT]);
dest.simd_into(self)
}
#[inline(always)]
fn swizzle_dyn_u8x32(self, a: u8x32<Self>, indices: u8x32<Self>) -> u8x32<Self> {
let bytes = Bytes::to_bytes(a);
let mut output = [0u8; 32usize];
for lane in 0..32usize {
let index = indices[lane] as usize;
output[lane] = bytes[index % 32usize];
}
let result: u8x32<Self> = output.simd_into(self);
Bytes::from_bytes(result)
}
#[inline(always)]
fn swizzle_dyn_precise_u8x32(self, a: u8x32<Self>, indices: u8x32<Self>) -> u8x32<Self> {
let bytes = Bytes::to_bytes(a);
let mut output = [0u8; 32usize];
for lane in 0..32usize {
let index = indices[lane] as usize;
let value = bytes[index % 32usize];
output[lane] = if index < 32usize { value } else { 0 };
}
let result: u8x32<Self> = output.simd_into(self);
Bytes::from_bytes(result)
}
#[inline(always)]
fn combine_u8x32(self, a: u8x32<Self>, b: u8x32<Self>) -> u8x64<Self> {
let mut result = [0; 64usize];
result[0..32usize].copy_from_slice(&a.val.0);
result[32usize..64usize].copy_from_slice(&b.val.0);
result.simd_into(self)
}
#[inline(always)]
fn split_u8x32(self, a: u8x32<Self>) -> (u8x16<Self>, u8x16<Self>) {
let mut b0 = [0; 16usize];
let mut b1 = [0; 16usize];
b0.copy_from_slice(&a.val.0[0..16usize]);
b1.copy_from_slice(&a.val.0[16usize..32usize]);
(b0.simd_into(self), b1.simd_into(self))
}
#[inline(always)]
fn set_mask8x32(self, a: &mut mask8x32<Self>, index: usize, value: bool) -> () {
assert!(
index < 32usize,
"mask lane index {index} is out of bounds for {} lanes",
32usize
);
let mut lanes: [i8; 32usize] = (*a).into();
lanes[index] = if value { !0 } else { 0 };
*a = lanes.simd_into(self);
}
#[inline(always)]
fn combine_mask8x32(self, a: mask8x32<Self>, b: mask8x32<Self>) -> mask8x64<Self> {
let mut result = [0; 64usize];
result[0..32usize].copy_from_slice(&a.val.0);
result[32usize..64usize].copy_from_slice(&b.val.0);
result.simd_into(self)
}
#[inline(always)]
fn split_mask8x32(self, a: mask8x32<Self>) -> (mask8x16<Self>, mask8x16<Self>) {
let mut b0 = [0; 16usize];
let mut b1 = [0; 16usize];
b0.copy_from_slice(&a.val.0[0..16usize]);
b1.copy_from_slice(&a.val.0[16usize..32usize]);
(b0.simd_into(self), b1.simd_into(self))
}
#[inline(always)]
fn slide_i16x16<const SHIFT: usize>(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x16<Self> {
let mut dest = [Default::default(); 16usize];
dest[..16usize - SHIFT].copy_from_slice(&a.val.0[SHIFT..]);
dest[16usize - SHIFT..].copy_from_slice(&b.val.0[..SHIFT]);
dest.simd_into(self)
}
#[inline(always)]
fn combine_i16x16(self, a: i16x16<Self>, b: i16x16<Self>) -> i16x32<Self> {
let mut result = [0; 32usize];
result[0..16usize].copy_from_slice(&a.val.0);
result[16usize..32usize].copy_from_slice(&b.val.0);
result.simd_into(self)
}
#[inline(always)]
fn split_i16x16(self, a: i16x16<Self>) -> (i16x8<Self>, i16x8<Self>) {
let mut b0 = [0; 8usize];
let mut b1 = [0; 8usize];
b0.copy_from_slice(&a.val.0[0..8usize]);
b1.copy_from_slice(&a.val.0[8usize..16usize]);
(b0.simd_into(self), b1.simd_into(self))
}
#[inline(always)]
fn slide_u16x16<const SHIFT: usize>(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x16<Self> {
let mut dest = [Default::default(); 16usize];
dest[..16usize - SHIFT].copy_from_slice(&a.val.0[SHIFT..]);
dest[16usize - SHIFT..].copy_from_slice(&b.val.0[..SHIFT]);
dest.simd_into(self)
}
#[inline(always)]
fn combine_u16x16(self, a: u16x16<Self>, b: u16x16<Self>) -> u16x32<Self> {
let mut result = [0; 32usize];
result[0..16usize].copy_from_slice(&a.val.0);
result[16usize..32usize].copy_from_slice(&b.val.0);
result.simd_into(self)
}
#[inline(always)]
fn split_u16x16(self, a: u16x16<Self>) -> (u16x8<Self>, u16x8<Self>) {
let mut b0 = [0; 8usize];
let mut b1 = [0; 8usize];
b0.copy_from_slice(&a.val.0[0..8usize]);
b1.copy_from_slice(&a.val.0[8usize..16usize]);
(b0.simd_into(self), b1.simd_into(self))
}
#[inline(always)]
fn set_mask16x16(self, a: &mut mask16x16<Self>, index: usize, value: bool) -> () {
assert!(
index < 16usize,
"mask lane index {index} is out of bounds for {} lanes",
16usize
);
let mut lanes: [i16; 16usize] = (*a).into();
lanes[index] = if value { !0 } else { 0 };
*a = lanes.simd_into(self);
}
#[inline(always)]
fn combine_mask16x16(self, a: mask16x16<Self>, b: mask16x16<Self>) -> mask16x32<Self> {
let mut result = [0; 32usize];
result[0..16usize].copy_from_slice(&a.val.0);
result[16usize..32usize].copy_from_slice(&b.val.0);
result.simd_into(self)
}
#[inline(always)]
fn split_mask16x16(self, a: mask16x16<Self>) -> (mask16x8<Self>, mask16x8<Self>) {
let mut b0 = [0; 8usize];
let mut b1 = [0; 8usize];
b0.copy_from_slice(&a.val.0[0..8usize]);
b1.copy_from_slice(&a.val.0[8usize..16usize]);
(b0.simd_into(self), b1.simd_into(self))
}
#[inline(always)]
fn slide_i32x8<const SHIFT: usize>(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x8<Self> {
let mut dest = [Default::default(); 8usize];
dest[..8usize - SHIFT].copy_from_slice(&a.val.0[SHIFT..]);
dest[8usize - SHIFT..].copy_from_slice(&b.val.0[..SHIFT]);
dest.simd_into(self)
}
#[inline(always)]
fn combine_i32x8(self, a: i32x8<Self>, b: i32x8<Self>) -> i32x16<Self> {
let mut result = [0; 16usize];
result[0..8usize].copy_from_slice(&a.val.0);
result[8usize..16usize].copy_from_slice(&b.val.0);
result.simd_into(self)
}
#[inline(always)]
fn split_i32x8(self, a: i32x8<Self>) -> (i32x4<Self>, i32x4<Self>) {
let mut b0 = [0; 4usize];
let mut b1 = [0; 4usize];
b0.copy_from_slice(&a.val.0[0..4usize]);
b1.copy_from_slice(&a.val.0[4usize..8usize]);
(b0.simd_into(self), b1.simd_into(self))
}
#[inline(always)]
fn slide_u32x8<const SHIFT: usize>(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x8<Self> {
let mut dest = [Default::default(); 8usize];
dest[..8usize - SHIFT].copy_from_slice(&a.val.0[SHIFT..]);
dest[8usize - SHIFT..].copy_from_slice(&b.val.0[..SHIFT]);
dest.simd_into(self)
}
#[inline(always)]
fn combine_u32x8(self, a: u32x8<Self>, b: u32x8<Self>) -> u32x16<Self> {
let mut result = [0; 16usize];
result[0..8usize].copy_from_slice(&a.val.0);
result[8usize..16usize].copy_from_slice(&b.val.0);
result.simd_into(self)
}
#[inline(always)]
fn split_u32x8(self, a: u32x8<Self>) -> (u32x4<Self>, u32x4<Self>) {
let mut b0 = [0; 4usize];
let mut b1 = [0; 4usize];
b0.copy_from_slice(&a.val.0[0..4usize]);
b1.copy_from_slice(&a.val.0[4usize..8usize]);
(b0.simd_into(self), b1.simd_into(self))
}
#[inline(always)]
fn set_mask32x8(self, a: &mut mask32x8<Self>, index: usize, value: bool) -> () {
assert!(
index < 8usize,
"mask lane index {index} is out of bounds for {} lanes",
8usize
);
let mut lanes: [i32; 8usize] = (*a).into();
lanes[index] = if value { !0 } else { 0 };
*a = lanes.simd_into(self);
}
#[inline(always)]
fn combine_mask32x8(self, a: mask32x8<Self>, b: mask32x8<Self>) -> mask32x16<Self> {
let mut result = [0; 16usize];
result[0..8usize].copy_from_slice(&a.val.0);
result[8usize..16usize].copy_from_slice(&b.val.0);
result.simd_into(self)
}
#[inline(always)]
fn split_mask32x8(self, a: mask32x8<Self>) -> (mask32x4<Self>, mask32x4<Self>) {
let mut b0 = [0; 4usize];
let mut b1 = [0; 4usize];
b0.copy_from_slice(&a.val.0[0..4usize]);
b1.copy_from_slice(&a.val.0[4usize..8usize]);
(b0.simd_into(self), b1.simd_into(self))
}
#[inline(always)]
fn slide_f64x4<const SHIFT: usize>(self, a: f64x4<Self>, b: f64x4<Self>) -> f64x4<Self> {
let mut dest = [Default::default(); 4usize];
dest[..4usize - SHIFT].copy_from_slice(&a.val.0[SHIFT..]);
dest[4usize - SHIFT..].copy_from_slice(&b.val.0[..SHIFT]);
dest.simd_into(self)
}
#[inline(always)]
fn combine_f64x4(self, a: f64x4<Self>, b: f64x4<Self>) -> f64x8<Self> {
let mut result = [0.0; 8usize];
result[0..4usize].copy_from_slice(&a.val.0);
result[4usize..8usize].copy_from_slice(&b.val.0);
result.simd_into(self)
}
#[inline(always)]
fn split_f64x4(self, a: f64x4<Self>) -> (f64x2<Self>, f64x2<Self>) {
let mut b0 = [0.0; 2usize];
let mut b1 = [0.0; 2usize];
b0.copy_from_slice(&a.val.0[0..2usize]);
b1.copy_from_slice(&a.val.0[2usize..4usize]);
(b0.simd_into(self), b1.simd_into(self))
}
#[inline(always)]
fn slide_i64x4<const SHIFT: usize>(self, a: i64x4<Self>, b: i64x4<Self>) -> i64x4<Self> {
let mut dest = [Default::default(); 4usize];
dest[..4usize - SHIFT].copy_from_slice(&a.val.0[SHIFT..]);
dest[4usize - SHIFT..].copy_from_slice(&b.val.0[..SHIFT]);
dest.simd_into(self)
}
#[inline(always)]
fn combine_i64x4(self, a: i64x4<Self>, b: i64x4<Self>) -> i64x8<Self> {
let mut result = [0; 8usize];
result[0..4usize].copy_from_slice(&a.val.0);
result[4usize..8usize].copy_from_slice(&b.val.0);
result.simd_into(self)
}
#[inline(always)]
fn split_i64x4(self, a: i64x4<Self>) -> (i64x2<Self>, i64x2<Self>) {
let mut b0 = [0; 2usize];
let mut b1 = [0; 2usize];
b0.copy_from_slice(&a.val.0[0..2usize]);
b1.copy_from_slice(&a.val.0[2usize..4usize]);
(b0.simd_into(self), b1.simd_into(self))
}
#[inline(always)]
fn slide_u64x4<const SHIFT: usize>(self, a: u64x4<Self>, b: u64x4<Self>) -> u64x4<Self> {
let mut dest = [Default::default(); 4usize];
dest[..4usize - SHIFT].copy_from_slice(&a.val.0[SHIFT..]);
dest[4usize - SHIFT..].copy_from_slice(&b.val.0[..SHIFT]);
dest.simd_into(self)
}
#[inline(always)]
fn combine_u64x4(self, a: u64x4<Self>, b: u64x4<Self>) -> u64x8<Self> {
let mut result = [0; 8usize];
result[0..4usize].copy_from_slice(&a.val.0);
result[4usize..8usize].copy_from_slice(&b.val.0);
result.simd_into(self)
}
#[inline(always)]
fn split_u64x4(self, a: u64x4<Self>) -> (u64x2<Self>, u64x2<Self>) {
let mut b0 = [0; 2usize];
let mut b1 = [0; 2usize];
b0.copy_from_slice(&a.val.0[0..2usize]);
b1.copy_from_slice(&a.val.0[2usize..4usize]);
(b0.simd_into(self), b1.simd_into(self))
}
#[inline(always)]
fn set_mask64x4(self, a: &mut mask64x4<Self>, index: usize, value: bool) -> () {
assert!(
index < 4usize,
"mask lane index {index} is out of bounds for {} lanes",
4usize
);
let mut lanes: [i64; 4usize] = (*a).into();
lanes[index] = if value { !0 } else { 0 };
*a = lanes.simd_into(self);
}
#[inline(always)]
fn combine_mask64x4(self, a: mask64x4<Self>, b: mask64x4<Self>) -> mask64x8<Self> {
let mut result = [0; 8usize];
result[0..4usize].copy_from_slice(&a.val.0);
result[4usize..8usize].copy_from_slice(&b.val.0);
result.simd_into(self)
}
#[inline(always)]
fn split_mask64x4(self, a: mask64x4<Self>) -> (mask64x2<Self>, mask64x2<Self>) {
let mut b0 = [0; 2usize];
let mut b1 = [0; 2usize];
b0.copy_from_slice(&a.val.0[0..2usize]);
b1.copy_from_slice(&a.val.0[2usize..4usize]);
(b0.simd_into(self), b1.simd_into(self))
}
#[inline(always)]
fn slide_f32x16<const SHIFT: usize>(self, a: f32x16<Self>, b: f32x16<Self>) -> f32x16<Self> {
let mut dest = [Default::default(); 16usize];
dest[..16usize - SHIFT].copy_from_slice(&a.val.0[SHIFT..]);
dest[16usize - SHIFT..].copy_from_slice(&b.val.0[..SHIFT]);
dest.simd_into(self)
}
#[inline(always)]
fn split_f32x16(self, a: f32x16<Self>) -> (f32x8<Self>, f32x8<Self>) {
let mut b0 = [0.0; 8usize];
let mut b1 = [0.0; 8usize];
b0.copy_from_slice(&a.val.0[0..8usize]);
b1.copy_from_slice(&a.val.0[8usize..16usize]);
(b0.simd_into(self), b1.simd_into(self))
}
#[inline(always)]
fn slide_i8x64<const SHIFT: usize>(self, a: i8x64<Self>, b: i8x64<Self>) -> i8x64<Self> {
let mut dest = [Default::default(); 64usize];
dest[..64usize - SHIFT].copy_from_slice(&a.val.0[SHIFT..]);
dest[64usize - SHIFT..].copy_from_slice(&b.val.0[..SHIFT]);
dest.simd_into(self)
}
#[inline(always)]
fn split_i8x64(self, a: i8x64<Self>) -> (i8x32<Self>, i8x32<Self>) {
let mut b0 = [0; 32usize];
let mut b1 = [0; 32usize];
b0.copy_from_slice(&a.val.0[0..32usize]);
b1.copy_from_slice(&a.val.0[32usize..64usize]);
(b0.simd_into(self), b1.simd_into(self))
}
#[inline(always)]
fn slide_u8x64<const SHIFT: usize>(self, a: u8x64<Self>, b: u8x64<Self>) -> u8x64<Self> {
let mut dest = [Default::default(); 64usize];
dest[..64usize - SHIFT].copy_from_slice(&a.val.0[SHIFT..]);
dest[64usize - SHIFT..].copy_from_slice(&b.val.0[..SHIFT]);
dest.simd_into(self)
}
#[inline(always)]
fn swizzle_dyn_u8x64(self, a: u8x64<Self>, indices: u8x64<Self>) -> u8x64<Self> {
let bytes = Bytes::to_bytes(a);
let mut output = [0u8; 64usize];
for lane in 0..64usize {
let index = indices[lane] as usize;
output[lane] = bytes[index % 64usize];
}
let result: u8x64<Self> = output.simd_into(self);
Bytes::from_bytes(result)
}
#[inline(always)]
fn swizzle_dyn_precise_u8x64(self, a: u8x64<Self>, indices: u8x64<Self>) -> u8x64<Self> {
let bytes = Bytes::to_bytes(a);
let mut output = [0u8; 64usize];
for lane in 0..64usize {
let index = indices[lane] as usize;
let value = bytes[index % 64usize];
output[lane] = if index < 64usize { value } else { 0 };
}
let result: u8x64<Self> = output.simd_into(self);
Bytes::from_bytes(result)
}
#[inline(always)]
fn split_u8x64(self, a: u8x64<Self>) -> (u8x32<Self>, u8x32<Self>) {
let mut b0 = [0; 32usize];
let mut b1 = [0; 32usize];
b0.copy_from_slice(&a.val.0[0..32usize]);
b1.copy_from_slice(&a.val.0[32usize..64usize]);
(b0.simd_into(self), b1.simd_into(self))
}
#[inline(always)]
fn set_mask8x64(self, a: &mut mask8x64<Self>, index: usize, value: bool) -> () {
assert!(
index < 64usize,
"mask lane index {index} is out of bounds for {} lanes",
64usize
);
let mut lanes: [i8; 64usize] = (*a).into();
lanes[index] = if value { !0 } else { 0 };
*a = lanes.simd_into(self);
}
#[inline(always)]
fn split_mask8x64(self, a: mask8x64<Self>) -> (mask8x32<Self>, mask8x32<Self>) {
let mut b0 = [0; 32usize];
let mut b1 = [0; 32usize];
b0.copy_from_slice(&a.val.0[0..32usize]);
b1.copy_from_slice(&a.val.0[32usize..64usize]);
(b0.simd_into(self), b1.simd_into(self))
}
#[inline(always)]
fn slide_i16x32<const SHIFT: usize>(self, a: i16x32<Self>, b: i16x32<Self>) -> i16x32<Self> {
let mut dest = [Default::default(); 32usize];
dest[..32usize - SHIFT].copy_from_slice(&a.val.0[SHIFT..]);
dest[32usize - SHIFT..].copy_from_slice(&b.val.0[..SHIFT]);
dest.simd_into(self)
}
#[inline(always)]
fn split_i16x32(self, a: i16x32<Self>) -> (i16x16<Self>, i16x16<Self>) {
let mut b0 = [0; 16usize];
let mut b1 = [0; 16usize];
b0.copy_from_slice(&a.val.0[0..16usize]);
b1.copy_from_slice(&a.val.0[16usize..32usize]);
(b0.simd_into(self), b1.simd_into(self))
}
#[inline(always)]
fn slide_u16x32<const SHIFT: usize>(self, a: u16x32<Self>, b: u16x32<Self>) -> u16x32<Self> {
let mut dest = [Default::default(); 32usize];
dest[..32usize - SHIFT].copy_from_slice(&a.val.0[SHIFT..]);
dest[32usize - SHIFT..].copy_from_slice(&b.val.0[..SHIFT]);
dest.simd_into(self)
}
#[inline(always)]
fn split_u16x32(self, a: u16x32<Self>) -> (u16x16<Self>, u16x16<Self>) {
let mut b0 = [0; 16usize];
let mut b1 = [0; 16usize];
b0.copy_from_slice(&a.val.0[0..16usize]);
b1.copy_from_slice(&a.val.0[16usize..32usize]);
(b0.simd_into(self), b1.simd_into(self))
}
#[inline(always)]
fn set_mask16x32(self, a: &mut mask16x32<Self>, index: usize, value: bool) -> () {
assert!(
index < 32usize,
"mask lane index {index} is out of bounds for {} lanes",
32usize
);
let mut lanes: [i16; 32usize] = (*a).into();
lanes[index] = if value { !0 } else { 0 };
*a = lanes.simd_into(self);
}
#[inline(always)]
fn split_mask16x32(self, a: mask16x32<Self>) -> (mask16x16<Self>, mask16x16<Self>) {
let mut b0 = [0; 16usize];
let mut b1 = [0; 16usize];
b0.copy_from_slice(&a.val.0[0..16usize]);
b1.copy_from_slice(&a.val.0[16usize..32usize]);
(b0.simd_into(self), b1.simd_into(self))
}
#[inline(always)]
fn slide_i32x16<const SHIFT: usize>(self, a: i32x16<Self>, b: i32x16<Self>) -> i32x16<Self> {
let mut dest = [Default::default(); 16usize];
dest[..16usize - SHIFT].copy_from_slice(&a.val.0[SHIFT..]);
dest[16usize - SHIFT..].copy_from_slice(&b.val.0[..SHIFT]);
dest.simd_into(self)
}
#[inline(always)]
fn split_i32x16(self, a: i32x16<Self>) -> (i32x8<Self>, i32x8<Self>) {
let mut b0 = [0; 8usize];
let mut b1 = [0; 8usize];
b0.copy_from_slice(&a.val.0[0..8usize]);
b1.copy_from_slice(&a.val.0[8usize..16usize]);
(b0.simd_into(self), b1.simd_into(self))
}
#[inline(always)]
fn slide_u32x16<const SHIFT: usize>(self, a: u32x16<Self>, b: u32x16<Self>) -> u32x16<Self> {
let mut dest = [Default::default(); 16usize];
dest[..16usize - SHIFT].copy_from_slice(&a.val.0[SHIFT..]);
dest[16usize - SHIFT..].copy_from_slice(&b.val.0[..SHIFT]);
dest.simd_into(self)
}
#[inline(always)]
fn split_u32x16(self, a: u32x16<Self>) -> (u32x8<Self>, u32x8<Self>) {
let mut b0 = [0; 8usize];
let mut b1 = [0; 8usize];
b0.copy_from_slice(&a.val.0[0..8usize]);
b1.copy_from_slice(&a.val.0[8usize..16usize]);
(b0.simd_into(self), b1.simd_into(self))
}
#[inline(always)]
fn set_mask32x16(self, a: &mut mask32x16<Self>, index: usize, value: bool) -> () {
assert!(
index < 16usize,
"mask lane index {index} is out of bounds for {} lanes",
16usize
);
let mut lanes: [i32; 16usize] = (*a).into();
lanes[index] = if value { !0 } else { 0 };
*a = lanes.simd_into(self);
}
#[inline(always)]
fn split_mask32x16(self, a: mask32x16<Self>) -> (mask32x8<Self>, mask32x8<Self>) {
let mut b0 = [0; 8usize];
let mut b1 = [0; 8usize];
b0.copy_from_slice(&a.val.0[0..8usize]);
b1.copy_from_slice(&a.val.0[8usize..16usize]);
(b0.simd_into(self), b1.simd_into(self))
}
#[inline(always)]
fn slide_f64x8<const SHIFT: usize>(self, a: f64x8<Self>, b: f64x8<Self>) -> f64x8<Self> {
let mut dest = [Default::default(); 8usize];
dest[..8usize - SHIFT].copy_from_slice(&a.val.0[SHIFT..]);
dest[8usize - SHIFT..].copy_from_slice(&b.val.0[..SHIFT]);
dest.simd_into(self)
}
#[inline(always)]
fn split_f64x8(self, a: f64x8<Self>) -> (f64x4<Self>, f64x4<Self>) {
let mut b0 = [0.0; 4usize];
let mut b1 = [0.0; 4usize];
b0.copy_from_slice(&a.val.0[0..4usize]);
b1.copy_from_slice(&a.val.0[4usize..8usize]);
(b0.simd_into(self), b1.simd_into(self))
}
#[inline(always)]
fn slide_i64x8<const SHIFT: usize>(self, a: i64x8<Self>, b: i64x8<Self>) -> i64x8<Self> {
let mut dest = [Default::default(); 8usize];
dest[..8usize - SHIFT].copy_from_slice(&a.val.0[SHIFT..]);
dest[8usize - SHIFT..].copy_from_slice(&b.val.0[..SHIFT]);
dest.simd_into(self)
}
#[inline(always)]
fn split_i64x8(self, a: i64x8<Self>) -> (i64x4<Self>, i64x4<Self>) {
let mut b0 = [0; 4usize];
let mut b1 = [0; 4usize];
b0.copy_from_slice(&a.val.0[0..4usize]);
b1.copy_from_slice(&a.val.0[4usize..8usize]);
(b0.simd_into(self), b1.simd_into(self))
}
#[inline(always)]
fn slide_u64x8<const SHIFT: usize>(self, a: u64x8<Self>, b: u64x8<Self>) -> u64x8<Self> {
let mut dest = [Default::default(); 8usize];
dest[..8usize - SHIFT].copy_from_slice(&a.val.0[SHIFT..]);
dest[8usize - SHIFT..].copy_from_slice(&b.val.0[..SHIFT]);
dest.simd_into(self)
}
#[inline(always)]
fn split_u64x8(self, a: u64x8<Self>) -> (u64x4<Self>, u64x4<Self>) {
let mut b0 = [0; 4usize];
let mut b1 = [0; 4usize];
b0.copy_from_slice(&a.val.0[0..4usize]);
b1.copy_from_slice(&a.val.0[4usize..8usize]);
(b0.simd_into(self), b1.simd_into(self))
}
#[inline(always)]
fn set_mask64x8(self, a: &mut mask64x8<Self>, index: usize, value: bool) -> () {
assert!(
index < 8usize,
"mask lane index {index} is out of bounds for {} lanes",
8usize
);
let mut lanes: [i64; 8usize] = (*a).into();
lanes[index] = if value { !0 } else { 0 };
*a = lanes.simd_into(self);
}
#[inline(always)]
fn split_mask64x8(self, a: mask64x8<Self>) -> (mask64x4<Self>, mask64x4<Self>) {
let mut b0 = [0; 4usize];
let mut b1 = [0; 4usize];
b0.copy_from_slice(&a.val.0[0..4usize]);
b1.copy_from_slice(&a.val.0[4usize..8usize]);
(b0.simd_into(self), b1.simd_into(self))
}
}