use super::*;
pick! {
if #[cfg(target_feature="sse2")] {
#[derive(Default, Clone, Copy, PartialEq, Eq)]
#[repr(C, align(16))]
pub struct u32x4 { sse: m128i }
} else {
#[derive(Default, Clone, Copy, PartialEq, Eq)]
#[repr(C, align(16))]
pub struct u32x4 { arr: [u32;4] }
}
}
unsafe impl Zeroable for u32x4 {}
unsafe impl Pod for u32x4 {}
impl Add for u32x4 {
type Output = Self;
#[inline]
#[must_use]
fn add(self, rhs: Self) -> Self::Output {
pick! {
if #[cfg(target_feature="sse2")] {
Self { sse: add_i32_m128i(self.sse, rhs.sse) }
} else {
Self { arr: [
self.arr[0].wrapping_add(rhs.arr[0]),
self.arr[1].wrapping_add(rhs.arr[1]),
self.arr[2].wrapping_add(rhs.arr[2]),
self.arr[3].wrapping_add(rhs.arr[3]),
]}
}
}
}
}
impl Sub for u32x4 {
type Output = Self;
#[inline]
#[must_use]
fn sub(self, rhs: Self) -> Self::Output {
pick! {
if #[cfg(target_feature="sse2")] {
Self { sse: sub_i32_m128i(self.sse, rhs.sse) }
} else {
Self { arr: [
self.arr[0].wrapping_sub(rhs.arr[0]),
self.arr[1].wrapping_sub(rhs.arr[1]),
self.arr[2].wrapping_sub(rhs.arr[2]),
self.arr[3].wrapping_sub(rhs.arr[3]),
]}
}
}
}
}
impl BitAnd for u32x4 {
type Output = Self;
#[inline]
#[must_use]
fn bitand(self, rhs: Self) -> Self::Output {
pick! {
if #[cfg(target_feature="sse2")] {
Self { sse: bitand_m128i(self.sse, rhs.sse) }
} else {
Self { arr: [
self.arr[0].bitand(rhs.arr[0]),
self.arr[1].bitand(rhs.arr[1]),
self.arr[2].bitand(rhs.arr[2]),
self.arr[3].bitand(rhs.arr[3]),
]}
}
}
}
}
impl BitOr for u32x4 {
type Output = Self;
#[inline]
#[must_use]
fn bitor(self, rhs: Self) -> Self::Output {
pick! {
if #[cfg(target_feature="sse2")] {
Self { sse: bitor_m128i(self.sse, rhs.sse) }
} else {
Self { arr: [
self.arr[0].bitor(rhs.arr[0]),
self.arr[1].bitor(rhs.arr[1]),
self.arr[2].bitor(rhs.arr[2]),
self.arr[3].bitor(rhs.arr[3]),
]}
}
}
}
}
impl BitXor for u32x4 {
type Output = Self;
#[inline]
#[must_use]
fn bitxor(self, rhs: Self) -> Self::Output {
pick! {
if #[cfg(target_feature="sse2")] {
Self { sse: bitxor_m128i(self.sse, rhs.sse) }
} else {
Self { arr: [
self.arr[0].bitxor(rhs.arr[0]),
self.arr[1].bitxor(rhs.arr[1]),
self.arr[2].bitxor(rhs.arr[2]),
self.arr[3].bitxor(rhs.arr[3]),
]}
}
}
}
}
macro_rules! impl_shl_t_for_u32x4 {
($($shift_type:ty),+ $(,)?) => {
$(impl Shl<$shift_type> for u32x4 {
type Output = Self;
#[inline]
#[must_use]
fn shl(self, rhs: $shift_type) -> Self::Output {
let u = rhs as u64;
pick! {
if #[cfg(target_feature="sse2")] {
let shift = cast([u, 0]);
Self { sse: shl_all_u32_m128i(self.sse, shift) }
} else {
Self { arr: [
self.arr[0] << u,
self.arr[1] << u,
self.arr[2] << u,
self.arr[3] << u,
]}
}
}
}
})+
};
}
impl_shl_t_for_u32x4!(i8, u8, i16, u16, i32, u32, i64, u64, i128, u128);
macro_rules! impl_shr_t_for_u32x4 {
($($shift_type:ty),+ $(,)?) => {
$(impl Shr<$shift_type> for u32x4 {
type Output = Self;
#[inline]
#[must_use]
fn shr(self, rhs: $shift_type) -> Self::Output {
let u = rhs as u64;
pick! {
if #[cfg(target_feature="sse2")] {
let shift = cast([u, 0]);
Self { sse: shr_all_u32_m128i(self.sse, shift) }
} else {
Self { arr: [
self.arr[0] >> u,
self.arr[1] >> u,
self.arr[2] >> u,
self.arr[3] >> u,
]}
}
}
}
})+
};
}
impl_shr_t_for_u32x4!(i8, u8, i16, u16, i32, u32, i64, u64, i128, u128);
impl u32x4 {
#[inline]
#[must_use]
pub fn cmp_eq(self, rhs: Self) -> Self {
pick! {
if #[cfg(target_feature="sse2")] {
Self { sse: cmp_eq_mask_i32_m128i(self.sse, rhs.sse) }
} else {
Self { arr: [
if self.arr[0] == rhs.arr[0] { u32::MAX } else { 0 },
if self.arr[1] == rhs.arr[1] { u32::MAX } else { 0 },
if self.arr[2] == rhs.arr[2] { u32::MAX } else { 0 },
if self.arr[3] == rhs.arr[3] { u32::MAX } else { 0 },
]}
}
}
}
#[inline]
#[must_use]
pub fn blend(self, t: Self, f: Self) -> Self {
pick! {
if #[cfg(target_feature="sse4.1")] {
Self { sse: blend_varying_i8_m128i(f.sse, t.sse, self.sse) }
} else {
generic_bit_blend(self, t, f)
}
}
}
#[inline]
#[must_use]
pub fn max(self, rhs: Self) -> Self {
pick! {
if #[cfg(target_feature="sse4.1")] {
Self { sse: max_u32_m128i(self.sse, rhs.sse) }
} else {
let arr: [u32; 4] = cast(self);
let rhs: [u32; 4] = cast(rhs);
cast([
arr[0].max(rhs[0]),
arr[1].max(rhs[1]),
arr[2].max(rhs[2]),
arr[3].max(rhs[3]),
])
}
}
}
#[inline]
#[must_use]
pub fn min(self, rhs: Self) -> Self {
pick! {
if #[cfg(target_feature="sse4.1")] {
Self { sse: min_u32_m128i(self.sse, rhs.sse) }
} else {
let arr: [u32; 4] = cast(self);
let rhs: [u32; 4] = cast(rhs);
cast([
arr[0].min(rhs[0]),
arr[1].min(rhs[1]),
arr[2].min(rhs[2]),
arr[3].min(rhs[3]),
])
}
}
}
}