| //! Utility macros |
| #![allow(unused)] |
| |
| macro_rules! impl_unary_ { |
| // implementation mapping 1:1 |
| (vec | $trait_id:ident, $trait_method:ident, $vec_id:ident, |
| $fun:ident) => { |
| impl $trait_id for $vec_id { |
| #[inline] |
| fn $trait_method(self) -> Self { |
| unsafe { |
| use crate::mem::transmute; |
| transmute($fun(transmute(self))) |
| } |
| } |
| } |
| }; |
| // implementation mapping 1:1 for when `$fun` is a generic function |
| // like some of the fp math rustc intrinsics (e.g. `fn fun<T>(x: T) -> T`). |
| (gen | $trait_id:ident, $trait_method:ident, $vec_id:ident, |
| $fun:ident) => { |
| impl $trait_id for $vec_id { |
| #[inline] |
| fn $trait_method(self) -> Self { |
| unsafe { |
| use crate::mem::transmute; |
| transmute($fun(self.0)) |
| } |
| } |
| } |
| }; |
| (scalar | $trait_id:ident, $trait_method:ident, |
| $vec_id:ident, [$sid:ident; $scount:expr], $fun:ident) => { |
| impl $trait_id for $vec_id { |
| #[inline] |
| fn $trait_method(self) -> Self { |
| unsafe { |
| union U { |
| vec: $vec_id, |
| scalars: [$sid; $scount], |
| } |
| let mut scalars = U { vec: self }.scalars; |
| for i in &mut scalars { |
| *i = $fun(*i); |
| } |
| U { scalars }.vec |
| } |
| } |
| } |
| }; |
| // implementation calling fun twice on each of the vector halves: |
| (halves | $trait_id:ident, $trait_method:ident, $vec_id:ident, |
| $vech_id:ident, $fun:ident) => { |
| impl $trait_id for $vec_id { |
| #[inline] |
| fn $trait_method(self) -> Self { |
| unsafe { |
| use crate::mem::transmute; |
| union U { |
| vec: $vec_id, |
| halves: [$vech_id; 2], |
| } |
| |
| let mut halves = U { vec: self }.halves; |
| |
| *halves.get_unchecked_mut(0) = transmute($fun(transmute(*halves.get_unchecked(0)))); |
| *halves.get_unchecked_mut(1) = transmute($fun(transmute(*halves.get_unchecked(1)))); |
| |
| U { halves }.vec |
| } |
| } |
| } |
| }; |
| // implementation calling fun four times on each of the vector quarters: |
| (quarter | $trait_id:ident, $trait_method:ident, $vec_id:ident, |
| $vecq_id:ident, $fun:ident) => { |
| impl $trait_id for $vec_id { |
| #[inline] |
| fn $trait_method(self) -> Self { |
| unsafe { |
| use crate::mem::transmute; |
| union U { |
| vec: $vec_id, |
| quarters: [$vecq_id; 4], |
| } |
| |
| let mut quarters = U { vec: self }.quarters; |
| |
| *quarters.get_unchecked_mut(0) = transmute($fun(transmute(*quarters.get_unchecked(0)))); |
| *quarters.get_unchecked_mut(1) = transmute($fun(transmute(*quarters.get_unchecked(1)))); |
| *quarters.get_unchecked_mut(2) = transmute($fun(transmute(*quarters.get_unchecked(2)))); |
| *quarters.get_unchecked_mut(3) = transmute($fun(transmute(*quarters.get_unchecked(3)))); |
| |
| U { quarters }.vec |
| } |
| } |
| } |
| }; |
| // implementation calling fun once on a vector twice as large: |
| (twice | $trait_id:ident, $trait_method:ident, $vec_id:ident, |
| $vect_id:ident, $fun:ident) => { |
| impl $trait_id for $vec_id { |
| #[inline] |
| fn $trait_method(self) -> Self { |
| unsafe { |
| use crate::mem::{transmute, uninitialized}; |
| |
| union U { |
| vec: [$vec_id; 2], |
| twice: $vect_id, |
| } |
| |
| let twice = U { vec: [self, uninitialized()] }.twice; |
| let twice = transmute($fun(transmute(twice))); |
| |
| *(U { twice }.vec.get_unchecked(0)) |
| } |
| } |
| } |
| }; |
| } |
| |
| macro_rules! gen_unary_impl_table { |
| ($trait_id:ident, $trait_method:ident) => { |
| macro_rules! impl_unary { |
| ($vid:ident: $fun:ident) => { |
| impl_unary_!(vec | $trait_id, $trait_method, $vid, $fun); |
| }; |
| ($vid:ident[g]: $fun:ident) => { |
| impl_unary_!(gen | $trait_id, $trait_method, $vid, $fun); |
| }; |
| ($vid:ident[$sid:ident; $sc:expr]: $fun:ident) => { |
| impl_unary_!(scalar | $trait_id, $trait_method, $vid, [$sid; $sc], $fun); |
| }; |
| ($vid:ident[s]: $fun:ident) => { |
| impl_unary_!(scalar | $trait_id, $trait_method, $vid, $fun); |
| }; |
| ($vid:ident[h => $vid_h:ident]: $fun:ident) => { |
| impl_unary_!(halves | $trait_id, $trait_method, $vid, $vid_h, $fun); |
| }; |
| ($vid:ident[q => $vid_q:ident]: $fun:ident) => { |
| impl_unary_!(quarter | $trait_id, $trait_method, $vid, $vid_q, $fun); |
| }; |
| ($vid:ident[t => $vid_t:ident]: $fun:ident) => { |
| impl_unary_!(twice | $trait_id, $trait_method, $vid, $vid_t, $fun); |
| }; |
| } |
| }; |
| } |
| |
| macro_rules! impl_tertiary_ { |
| // implementation mapping 1:1 |
| (vec | $trait_id:ident, $trait_method:ident, $vec_id:ident, |
| $fun:ident) => { |
| impl $trait_id for $vec_id { |
| #[inline] |
| fn $trait_method(self, y: Self, z: Self) -> Self { |
| unsafe { |
| use crate::mem::transmute; |
| transmute($fun(transmute(self), transmute(y), transmute(z))) |
| } |
| } |
| } |
| }; |
| (scalar | $trait_id:ident, $trait_method:ident, |
| $vec_id:ident, [$sid:ident; $scount:expr], $fun:ident) => { |
| impl $trait_id for $vec_id { |
| #[inline] |
| fn $trait_method(self, y: Self, z: Self) -> Self { |
| unsafe { |
| union U { |
| vec: $vec_id, |
| scalars: [$sid; $scount], |
| } |
| let mut x = U { vec: self }.scalars; |
| let y = U { vec: y }.scalars; |
| let z = U { vec: z }.scalars; |
| for (x, (y, z)) in (&mut scalars).zip(&y).zip(&z) { |
| *i = $fun(*i, *y, *z); |
| } |
| U { vec: x }.vec |
| } |
| } |
| } |
| }; |
| // implementation calling fun twice on each of the vector halves: |
| (halves | $trait_id:ident, $trait_method:ident, $vec_id:ident, |
| $vech_id:ident, $fun:ident) => { |
| impl $trait_id for $vec_id { |
| #[inline] |
| fn $trait_method(self, y: Self, z: Self) -> Self { |
| unsafe { |
| use crate::mem::transmute; |
| union U { |
| vec: $vec_id, |
| halves: [$vech_id; 2], |
| } |
| |
| let mut x_halves = U { vec: self }.halves; |
| let y_halves = U { vec: y }.halves; |
| let z_halves = U { vec: z }.halves; |
| |
| *x_halves.get_unchecked_mut(0) = transmute($fun( |
| transmute(*x_halves.get_unchecked(0)), |
| transmute(*y_halves.get_unchecked(0)), |
| transmute(*z_halves.get_unchecked(0)), |
| )); |
| *x_halves.get_unchecked_mut(1) = transmute($fun( |
| transmute(*x_halves.get_unchecked(1)), |
| transmute(*y_halves.get_unchecked(1)), |
| transmute(*z_halves.get_unchecked(1)), |
| )); |
| |
| U { halves: x_halves }.vec |
| } |
| } |
| } |
| }; |
| // implementation calling fun four times on each of the vector quarters: |
| (quarter | $trait_id:ident, $trait_method:ident, $vec_id:ident, |
| $vecq_id:ident, $fun:ident) => { |
| impl $trait_id for $vec_id { |
| #[inline] |
| fn $trait_method(self, y: Self, z: Self) -> Self { |
| unsafe { |
| use crate::mem::transmute; |
| union U { |
| vec: $vec_id, |
| quarters: [$vecq_id; 4], |
| } |
| |
| let mut x_quarters = U { vec: self }.quarters; |
| let y_quarters = U { vec: y }.quarters; |
| let z_quarters = U { vec: z }.quarters; |
| |
| *x_quarters.get_unchecked_mut(0) = transmute($fun( |
| transmute(*x_quarters.get_unchecked(0)), |
| transmute(*y_quarters.get_unchecked(0)), |
| transmute(*z_quarters.get_unchecked(0)), |
| )); |
| |
| *x_quarters.get_unchecked_mut(1) = transmute($fun( |
| transmute(*x_quarters.get_unchecked(1)), |
| transmute(*y_quarters.get_unchecked(1)), |
| transmute(*z_quarters.get_unchecked(1)), |
| )); |
| |
| *x_quarters.get_unchecked_mut(2) = transmute($fun( |
| transmute(*x_quarters.get_unchecked(2)), |
| transmute(*y_quarters.get_unchecked(2)), |
| transmute(*z_quarters.get_unchecked(2)), |
| )); |
| |
| *x_quarters.get_unchecked_mut(3) = transmute($fun( |
| transmute(*x_quarters.get_unchecked(3)), |
| transmute(*y_quarters.get_unchecked(3)), |
| transmute(*z_quarters.get_unchecked(3)), |
| )); |
| |
| U { quarters: x_quarters }.vec |
| } |
| } |
| } |
| }; |
| // implementation calling fun once on a vector twice as large: |
| (twice | $trait_id:ident, $trait_method:ident, $vec_id:ident, |
| $vect_id:ident, $fun:ident) => { |
| impl $trait_id for $vec_id { |
| #[inline] |
| fn $trait_method(self, y: Self, z: Self) -> Self { |
| unsafe { |
| use crate::mem::{transmute, uninitialized}; |
| |
| union U { |
| vec: [$vec_id; 2], |
| twice: $vect_id, |
| } |
| |
| let x_twice = U { vec: [self, uninitialized()] }.twice; |
| let y_twice = U { vec: [y, uninitialized()] }.twice; |
| let z_twice = U { vec: [z, uninitialized()] }.twice; |
| let twice: $vect_id = |
| transmute($fun(transmute(x_twice), transmute(y_twice), transmute(z_twice))); |
| |
| *(U { twice }.vec.get_unchecked(0)) |
| } |
| } |
| } |
| }; |
| } |
| |
| macro_rules! gen_tertiary_impl_table { |
| ($trait_id:ident, $trait_method:ident) => { |
| macro_rules! impl_tertiary { |
| ($vid:ident: $fun:ident) => { |
| impl_tertiary_!(vec | $trait_id, $trait_method, $vid, $fun); |
| }; |
| ($vid:ident[$sid:ident; $sc:expr]: $fun:ident) => { |
| impl_tertiary_!(scalar | $trait_id, $trait_method, $vid, [$sid; $sc], $fun); |
| }; |
| ($vid:ident[s]: $fun:ident) => { |
| impl_tertiary_!(scalar | $trait_id, $trait_method, $vid, $fun); |
| }; |
| ($vid:ident[h => $vid_h:ident]: $fun:ident) => { |
| impl_tertiary_!(halves | $trait_id, $trait_method, $vid, $vid_h, $fun); |
| }; |
| ($vid:ident[q => $vid_q:ident]: $fun:ident) => { |
| impl_tertiary_!(quarter | $trait_id, $trait_method, $vid, $vid_q, $fun); |
| }; |
| ($vid:ident[t => $vid_t:ident]: $fun:ident) => { |
| impl_tertiary_!(twice | $trait_id, $trait_method, $vid, $vid_t, $fun); |
| }; |
| } |
| }; |
| } |
| |
| macro_rules! impl_binary_ { |
| // implementation mapping 1:1 |
| (vec | $trait_id:ident, $trait_method:ident, $vec_id:ident, |
| $fun:ident) => { |
| impl $trait_id for $vec_id { |
| #[inline] |
| fn $trait_method(self, y: Self) -> Self { |
| unsafe { |
| use crate::mem::transmute; |
| transmute($fun(transmute(self), transmute(y))) |
| } |
| } |
| } |
| }; |
| (scalar | $trait_id:ident, $trait_method:ident, |
| $vec_id:ident, [$sid:ident; $scount:expr], $fun:ident) => { |
| impl $trait_id for $vec_id { |
| #[inline] |
| fn $trait_method(self, y: Self) -> Self { |
| unsafe { |
| union U { |
| vec: $vec_id, |
| scalars: [$sid; $scount], |
| } |
| let mut x = U { vec: self }.scalars; |
| let y = U { vec: y }.scalars; |
| for (x, y) in x.iter_mut().zip(&y) { |
| *x = $fun(*x, *y); |
| } |
| U { scalars: x }.vec |
| } |
| } |
| } |
| }; |
| // implementation calling fun twice on each of the vector halves: |
| (halves | $trait_id:ident, $trait_method:ident, $vec_id:ident, |
| $vech_id:ident, $fun:ident) => { |
| impl $trait_id for $vec_id { |
| #[inline] |
| fn $trait_method(self, y: Self) -> Self { |
| unsafe { |
| use crate::mem::transmute; |
| union U { |
| vec: $vec_id, |
| halves: [$vech_id; 2], |
| } |
| |
| let mut x_halves = U { vec: self }.halves; |
| let y_halves = U { vec: y }.halves; |
| |
| *x_halves.get_unchecked_mut(0) = transmute($fun( |
| transmute(*x_halves.get_unchecked(0)), |
| transmute(*y_halves.get_unchecked(0)), |
| )); |
| *x_halves.get_unchecked_mut(1) = transmute($fun( |
| transmute(*x_halves.get_unchecked(1)), |
| transmute(*y_halves.get_unchecked(1)), |
| )); |
| |
| U { halves: x_halves }.vec |
| } |
| } |
| } |
| }; |
| // implementation calling fun four times on each of the vector quarters: |
| (quarter | $trait_id:ident, $trait_method:ident, $vec_id:ident, |
| $vecq_id:ident, $fun:ident) => { |
| impl $trait_id for $vec_id { |
| #[inline] |
| fn $trait_method(self, y: Self) -> Self { |
| unsafe { |
| use crate::mem::transmute; |
| union U { |
| vec: $vec_id, |
| quarters: [$vecq_id; 4], |
| } |
| |
| let mut x_quarters = U { vec: self }.quarters; |
| let y_quarters = U { vec: y }.quarters; |
| |
| *x_quarters.get_unchecked_mut(0) = transmute($fun( |
| transmute(*x_quarters.get_unchecked(0)), |
| transmute(*y_quarters.get_unchecked(0)), |
| )); |
| |
| *x_quarters.get_unchecked_mut(1) = transmute($fun( |
| transmute(*x_quarters.get_unchecked(1)), |
| transmute(*y_quarters.get_unchecked(1)), |
| )); |
| |
| *x_quarters.get_unchecked_mut(2) = transmute($fun( |
| transmute(*x_quarters.get_unchecked(2)), |
| transmute(*y_quarters.get_unchecked(2)), |
| )); |
| |
| *x_quarters.get_unchecked_mut(3) = transmute($fun( |
| transmute(*x_quarters.get_unchecked(3)), |
| transmute(*y_quarters.get_unchecked(3)), |
| )); |
| |
| U { quarters: x_quarters }.vec |
| } |
| } |
| } |
| }; |
| // implementation calling fun once on a vector twice as large: |
| (twice | $trait_id:ident, $trait_method:ident, $vec_id:ident, |
| $vect_id:ident, $fun:ident) => { |
| impl $trait_id for $vec_id { |
| #[inline] |
| fn $trait_method(self, y: Self) -> Self { |
| unsafe { |
| use crate::mem::{transmute, uninitialized}; |
| |
| union U { |
| vec: [$vec_id; 2], |
| twice: $vect_id, |
| } |
| |
| let x_twice = U { vec: [self, uninitialized()] }.twice; |
| let y_twice = U { vec: [y, uninitialized()] }.twice; |
| let twice: $vect_id = transmute($fun(transmute(x_twice), transmute(y_twice))); |
| |
| *(U { twice }.vec.get_unchecked(0)) |
| } |
| } |
| } |
| }; |
| } |
| |
| macro_rules! gen_binary_impl_table { |
| ($trait_id:ident, $trait_method:ident) => { |
| macro_rules! impl_binary { |
| ($vid:ident: $fun:ident) => { |
| impl_binary_!(vec | $trait_id, $trait_method, $vid, $fun); |
| }; |
| ($vid:ident[$sid:ident; $sc:expr]: $fun:ident) => { |
| impl_binary_!(scalar | $trait_id, $trait_method, $vid, [$sid; $sc], $fun); |
| }; |
| ($vid:ident[s]: $fun:ident) => { |
| impl_binary_!(scalar | $trait_id, $trait_method, $vid, $fun); |
| }; |
| ($vid:ident[h => $vid_h:ident]: $fun:ident) => { |
| impl_binary_!(halves | $trait_id, $trait_method, $vid, $vid_h, $fun); |
| }; |
| ($vid:ident[q => $vid_q:ident]: $fun:ident) => { |
| impl_binary_!(quarter | $trait_id, $trait_method, $vid, $vid_q, $fun); |
| }; |
| ($vid:ident[t => $vid_t:ident]: $fun:ident) => { |
| impl_binary_!(twice | $trait_id, $trait_method, $vid, $vid_t, $fun); |
| }; |
| } |
| }; |
| } |
