Struct Emulated 

pub struct Emulated<T, const N: usize, A = Scalar>(/* private fields */);

An emulated SIMD vector.

The emulated implementation behaves just like an intrinsic, but the APIs are implemented using loops over arrays rather than dispatching to platform specific instructions.

The idea behind this type is that it can be used on architecture where explicit backend support has not been added, or when an architecture does not support a given type/length pair well.

Furthermore, it can be used when developing new back-ends to provide fallback implementations. This allows new back-ends to be developed one piece at a time instead of all at once.

NOTE: The alignment requirements of an emulated vector will be different than the alignment requirements of an actual intrinsic.

Higher level code must not rely on alignments being compatible across architectures!

Implementations

impl<T, const N: usize, A> Emulated<T, N, A>

pub fn from_arch_fn<F>(arch: A, f: F) -> Self

where F: FnMut(usize) -> T,

Trait Implementations

impl<T, const N: usize, A> Add for Emulated<T, N, A>

where T: ReferenceScalarOps + Copy + Debug + Default, Const<N>: ArrayType<T>,

Binary Ops

type Output = Emulated<T, N, A>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self

Performs the + operation.

impl AsSIMD<f16x16> for Emulated<f16, 16>

fn as_simd(self, arch: V3) -> f16x16

impl AsSIMD<f16x16> for Emulated<f16, 16>

fn as_simd(self, arch: V4) -> f16x16

impl AsSIMD<f16x8> for Emulated<f16, 8>

fn as_simd(self, arch: V3) -> f16x8

impl AsSIMD<f16x8> for Emulated<f16, 8>

fn as_simd(self, arch: V4) -> f16x8

impl AsSIMD<f32x16> for Emulated<f32, 16>

fn as_simd(self, arch: V4) -> f32x16

impl AsSIMD<f32x4> for Emulated<f32, 4>

fn as_simd(self, arch: V3) -> f32x4

impl AsSIMD<f32x4> for Emulated<f32, 4>

fn as_simd(self, arch: V4) -> f32x4

impl AsSIMD<f32x8> for Emulated<f32, 8>

fn as_simd(self, arch: V3) -> f32x8

impl AsSIMD<f32x8> for Emulated<f32, 8>

fn as_simd(self, arch: V4) -> f32x8

impl AsSIMD<i16x16> for Emulated<i16, 16>

fn as_simd(self, arch: V3) -> i16x16

impl AsSIMD<i16x16> for Emulated<i16, 16>

fn as_simd(self, arch: V4) -> i16x16

impl AsSIMD<i16x32> for Emulated<i16, 32>

fn as_simd(self, arch: V4) -> i16x32

impl AsSIMD<i16x8> for Emulated<i16, 8>

fn as_simd(self, arch: V3) -> i16x8

impl AsSIMD<i16x8> for Emulated<i16, 8>

fn as_simd(self, arch: V4) -> i16x8

impl AsSIMD<i32x16> for Emulated<i32, 16>

fn as_simd(self, arch: V4) -> i32x16

impl AsSIMD<i32x4> for Emulated<i32, 4>

fn as_simd(self, arch: V3) -> i32x4

impl AsSIMD<i32x4> for Emulated<i32, 4>

fn as_simd(self, arch: V4) -> i32x4

impl AsSIMD<i32x8> for Emulated<i32, 8>

fn as_simd(self, arch: V3) -> i32x8

impl AsSIMD<i32x8> for Emulated<i32, 8>

fn as_simd(self, arch: V4) -> i32x8

impl AsSIMD<i8x16> for Emulated<i8, 16>

fn as_simd(self, arch: V3) -> i8x16

impl AsSIMD<i8x16> for Emulated<i8, 16>

fn as_simd(self, arch: V4) -> i8x16

impl AsSIMD<i8x32> for Emulated<i8, 32>

fn as_simd(self, arch: V3) -> i8x32

impl AsSIMD<i8x32> for Emulated<i8, 32>

fn as_simd(self, arch: V4) -> i8x32

impl AsSIMD<i8x64> for Emulated<i8, 64>

fn as_simd(self, arch: V4) -> i8x64

impl AsSIMD<u32x16> for Emulated<u32, 16>

fn as_simd(self, arch: V4) -> u32x16

impl AsSIMD<u32x4> for Emulated<u32, 4>

fn as_simd(self, arch: V3) -> u32x4

impl AsSIMD<u32x4> for Emulated<u32, 4>

fn as_simd(self, arch: V4) -> u32x4

impl AsSIMD<u32x8> for Emulated<u32, 8>

fn as_simd(self, arch: V3) -> u32x8

impl AsSIMD<u32x8> for Emulated<u32, 8>

fn as_simd(self, arch: V4) -> u32x8

impl AsSIMD<u64x2> for Emulated<u64, 2>

fn as_simd(self, arch: V3) -> u64x2

impl AsSIMD<u64x2> for Emulated<u64, 2>

fn as_simd(self, arch: V4) -> u64x2

impl AsSIMD<u64x4> for Emulated<u64, 4>

fn as_simd(self, arch: V3) -> u64x4

impl AsSIMD<u64x4> for Emulated<u64, 4>

fn as_simd(self, arch: V4) -> u64x4

impl AsSIMD<u8x16> for Emulated<u8, 16>

fn as_simd(self, arch: V3) -> u8x16

impl AsSIMD<u8x16> for Emulated<u8, 16>

fn as_simd(self, arch: V4) -> u8x16

impl AsSIMD<u8x32> for Emulated<u8, 32>

fn as_simd(self, arch: V3) -> u8x32

impl AsSIMD<u8x32> for Emulated<u8, 32>

fn as_simd(self, arch: V4) -> u8x32

impl AsSIMD<u8x64> for Emulated<u8, 64>

fn as_simd(self, arch: V4) -> u8x64

impl<T, const N: usize, A> BitAnd for Emulated<T, N, A>

where T: BitAnd<Output = T> + Copy,

type Output = Emulated<T, N, A>

The resulting type after applying the & operator.

fn bitand(self, other: Self) -> Self::Output

Performs the & operation.

impl<T, const N: usize, A> BitOr for Emulated<T, N, A>

where T: BitOr<Output = T> + Copy,

type Output = Emulated<T, N, A>

The resulting type after applying the | operator.

fn bitor(self, other: Self) -> Self::Output

Performs the | operation.

impl<T, const N: usize, A> BitXor for Emulated<T, N, A>

where T: BitXor<Output = T> + Copy,

type Output = Emulated<T, N, A>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Self) -> Self::Output

Performs the ^ operation.

impl<T: Clone, const N: usize, A: Clone> Clone for Emulated<T, N, A>

fn clone(&self) -> Emulated<T, N, A>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug, const N: usize, A: Debug> Debug for Emulated<T, N, A>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<A> From<Emulated<f16, 1, A>> for Emulated<f32, 1, A>

fn from(value: Emulated<f16, 1, A>) -> Self

Converts to this type from the input type.

impl<A> From<Emulated<f16, 16, A>> for Emulated<f32, 16, A>

fn from(value: Emulated<f16, 16, A>) -> Self

Converts to this type from the input type.

impl<A> From<Emulated<f16, 2, A>> for Emulated<f32, 2, A>

fn from(value: Emulated<f16, 2, A>) -> Self

Converts to this type from the input type.

impl<A> From<Emulated<f16, 4, A>> for Emulated<f32, 4, A>

fn from(value: Emulated<f16, 4, A>) -> Self

Converts to this type from the input type.

impl<A> From<Emulated<f16, 8, A>> for Emulated<f32, 8, A>

fn from(value: Emulated<f16, 8, A>) -> Self

Converts to this type from the input type.

impl<A> From<Emulated<i8, 1, A>> for Emulated<i32, 1, A>

fn from(value: Emulated<i8, 1, A>) -> Self

Converts to this type from the input type.

impl<A> From<Emulated<i8, 16, A>> for Emulated<i16, 16, A>

fn from(value: Emulated<i8, 16, A>) -> Self

Converts to this type from the input type.

impl<A> From<Emulated<i8, 32, A>> for Emulated<i16, 32, A>

fn from(value: Emulated<i8, 32, A>) -> Self

Converts to this type from the input type.

impl<A> From<Emulated<i8, 4, A>> for Emulated<i32, 4, A>

fn from(value: Emulated<i8, 4, A>) -> Self

Converts to this type from the input type.

impl<A> From<Emulated<u8, 1, A>> for Emulated<i32, 1, A>

fn from(value: Emulated<u8, 1, A>) -> Self

Converts to this type from the input type.

impl<A> From<Emulated<u8, 16, A>> for Emulated<i16, 16, A>

fn from(value: Emulated<u8, 16, A>) -> Self

Converts to this type from the input type.

impl<A> From<Emulated<u8, 32, A>> for Emulated<i16, 32, A>

fn from(value: Emulated<u8, 32, A>) -> Self

Converts to this type from the input type.

impl<A> From<Emulated<u8, 4, A>> for Emulated<i32, 4, A>

fn from(value: Emulated<u8, 4, A>) -> Self

Converts to this type from the input type.

impl<T, const N: usize, A> Mul for Emulated<T, N, A>

where T: ReferenceScalarOps,

type Output = Emulated<T, N, A>

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self

Performs the * operation.

impl<T, const N: usize, A> Not for Emulated<T, N, A>

where T: Not<Output = T> + Copy,

type Output = Emulated<T, N, A>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<T, const N: usize, A> SIMDAbs for Emulated<T, N, A>

where T: ReferenceAbs,

Abs

fn abs_simd(self) -> Self

impl<A> SIMDCast<f16> for Emulated<f32, 16, A>

where A: Sealed,

type Cast = Emulated<f16, 16, A>

The SIMDVector type of the result.

fn simd_cast(self) -> Self::Cast

Perform the cast.

impl<A> SIMDCast<f16> for Emulated<f32, 8, A>

where A: Sealed,

type Cast = Emulated<f16, 8, A>

The SIMDVector type of the result.

fn simd_cast(self) -> Self::Cast

Perform the cast.

impl<A> SIMDCast<f32> for Emulated<f16, 16, A>

where A: Sealed,

type Cast = Emulated<f32, 16, A>

The SIMDVector type of the result.

fn simd_cast(self) -> Self::Cast

Perform the cast.

impl<A> SIMDCast<f32> for Emulated<f16, 8, A>

where A: Sealed,

type Cast = Emulated<f32, 8, A>

The SIMDVector type of the result.

fn simd_cast(self) -> Self::Cast

Perform the cast.

impl<A> SIMDCast<f32> for Emulated<i32, 8, A>

where A: Sealed,

type Cast = Emulated<f32, 8, A>

The SIMDVector type of the result.

fn simd_cast(self) -> Self::Cast

Perform the cast.

impl<A> SIMDDotProduct<Emulated<i16, 16, A>> for Emulated<i32, 8, A>

where A: Sealed,

Promote intermediate values to i32 and then perform accumulation.

fn dot_simd( self, left: Emulated<i16, 16, A>, right: Emulated<i16, 16, A>, ) -> Self

Element wise multiply each component of left and right, promoting the intermediate results to a higher precision.

impl<A> SIMDDotProduct<Emulated<i16, 32, A>> for Emulated<i32, 16, A>

where A: Sealed,

Promote intermediate values to i32 and then perform accumulation.

fn dot_simd( self, left: Emulated<i16, 32, A>, right: Emulated<i16, 32, A>, ) -> Self

Element wise multiply each component of left and right, promoting the intermediate results to a higher precision.

impl<A> SIMDDotProduct<Emulated<i16, 8, A>> for Emulated<i32, 4, A>

where A: Sealed,

Promote intermediate values to i32 and then perform accumulation.

fn dot_simd(self, left: Emulated<i16, 8, A>, right: Emulated<i16, 8, A>) -> Self

Element wise multiply each component of left and right, promoting the intermediate results to a higher precision.

impl<A> SIMDDotProduct<Emulated<i8, 16, A>> for Emulated<i32, 4, A>

where A: Sealed,

fn dot_simd(self, left: Emulated<i8, 16, A>, right: Emulated<i8, 16, A>) -> Self

Element wise multiply each component of left and right, promoting the intermediate results to a higher precision.

impl<A> SIMDDotProduct<Emulated<i8, 16, A>, Emulated<u8, 16, A>> for Emulated<i32, 4, A>

where A: Sealed,

fn dot_simd(self, left: Emulated<i8, 16, A>, right: Emulated<u8, 16, A>) -> Self

Element wise multiply each component of left and right, promoting the intermediate results to a higher precision.

impl<A> SIMDDotProduct<Emulated<i8, 32, A>> for Emulated<i32, 8, A>

where A: Sealed,

fn dot_simd(self, left: Emulated<i8, 32, A>, right: Emulated<i8, 32, A>) -> Self

Element wise multiply each component of left and right, promoting the intermediate results to a higher precision.

impl<A> SIMDDotProduct<Emulated<i8, 32, A>, Emulated<u8, 32, A>> for Emulated<i32, 8, A>

where A: Sealed,

fn dot_simd(self, left: Emulated<i8, 32, A>, right: Emulated<u8, 32, A>) -> Self

Element wise multiply each component of left and right, promoting the intermediate results to a higher precision.

impl<A> SIMDDotProduct<Emulated<i8, 64, A>> for Emulated<i32, 16, A>

where A: Sealed,

fn dot_simd(self, left: Emulated<i8, 64, A>, right: Emulated<i8, 64, A>) -> Self

Element wise multiply each component of left and right, promoting the intermediate results to a higher precision.

impl<A> SIMDDotProduct<Emulated<i8, 64, A>, Emulated<u8, 64, A>> for Emulated<i32, 16, A>

where A: Sealed,

fn dot_simd(self, left: Emulated<i8, 64, A>, right: Emulated<u8, 64, A>) -> Self

Element wise multiply each component of left and right, promoting the intermediate results to a higher precision.

impl<A> SIMDDotProduct<Emulated<u8, 16, A>> for Emulated<u32, 4, A>

where A: Sealed,

fn dot_simd(self, left: Emulated<u8, 16, A>, right: Emulated<u8, 16, A>) -> Self

Element wise multiply each component of left and right, promoting the intermediate results to a higher precision.

impl<A> SIMDDotProduct<Emulated<u8, 16, A>, Emulated<i8, 16, A>> for Emulated<i32, 4, A>

where A: Sealed,

Promote intermediate values to i32 and then perform accumulation.

fn dot_simd(self, left: Emulated<u8, 16, A>, right: Emulated<i8, 16, A>) -> Self

Element wise multiply each component of left and right, promoting the intermediate results to a higher precision.

impl<A> SIMDDotProduct<Emulated<u8, 32, A>> for Emulated<u32, 8, A>

where A: Sealed,

fn dot_simd(self, left: Emulated<u8, 32, A>, right: Emulated<u8, 32, A>) -> Self

Element wise multiply each component of left and right, promoting the intermediate results to a higher precision.

impl<A> SIMDDotProduct<Emulated<u8, 32, A>, Emulated<i8, 32, A>> for Emulated<i32, 8, A>

where A: Sealed,

Promote intermediate values to i32 and then perform accumulation.

fn dot_simd(self, left: Emulated<u8, 32, A>, right: Emulated<i8, 32, A>) -> Self

Element wise multiply each component of left and right, promoting the intermediate results to a higher precision.

impl<A> SIMDDotProduct<Emulated<u8, 64, A>> for Emulated<u32, 16, A>

where A: Sealed,

fn dot_simd(self, left: Emulated<u8, 64, A>, right: Emulated<u8, 64, A>) -> Self

Element wise multiply each component of left and right, promoting the intermediate results to a higher precision.

impl<A> SIMDDotProduct<Emulated<u8, 64, A>, Emulated<i8, 64, A>> for Emulated<i32, 16, A>

where A: Sealed,

Promote intermediate values to i32 and then perform accumulation.

fn dot_simd(self, left: Emulated<u8, 64, A>, right: Emulated<i8, 64, A>) -> Self

Element wise multiply each component of left and right, promoting the intermediate results to a higher precision.

impl<T, const N: usize, A> SIMDMinMax for Emulated<T, N, A>

where T: ReferenceScalarOps,

MinMax

fn min_simd(self, rhs: Self) -> Self

Return the pairwise minimum of self and rhs, subject to looser NaN handling.

fn max_simd(self, rhs: Self) -> Self

Return the pairwise maximum of self and rhs, subject to looser NaN handling.

fn min_simd_standard(self, rhs: Self) -> Self

Return the pairwise minimum of self and rhs as if by applying the standard library’s min method for the scalar type.

fn max_simd_standard(self, rhs: Self) -> Self

Return the pairwise maximum of self and rhs as if by applying the standard library’s max method for the scalar type.

impl<T, const N: usize, A> SIMDMulAdd for Emulated<T, N, A>

where T: ReferenceScalarOps,

MulAdd

fn mul_add_simd(self, rhs: Self, accumulator: Self) -> Self

impl<T, const N: usize, A> SIMDPartialEq for Emulated<T, N, A>

where T: PartialEq, Self: SIMDVector,

SIMDPartialEq

fn eq_simd(self, other: Self) -> Self::Mask

SIMD equivalent of std::cmp::PartialEq::eq, applying the latter trait to each lane-wise pair of elements in self and other.

fn ne_simd(self, other: Self) -> Self::Mask

SIMD equivalent of std::cmp::PartialEq::neq, applying the latter trait to each lane-wise pair of elements in self and other.

impl<T, const N: usize, A> SIMDPartialOrd for Emulated<T, N, A>

where T: PartialOrd, Self: SIMDVector,

SIMDPartialOrd

fn lt_simd(self, other: Self) -> Self::Mask

SIMD equivalent of std::cmp::PartialOrd::lt.

fn le_simd(self, other: Self) -> Self::Mask

SIMD equivalent of std::cmp::PartialOrd::le.

fn gt_simd(self, other: Self) -> Self::Mask

SIMD equivalent of std::cmp::PartialOrd::gt.

fn ge_simd(self, other: Self) -> Self::Mask

SIMD equivalent of std::cmp::PartialOrd::ge.

impl<A> SIMDReinterpret<Emulated<i16, 16, A>> for Emulated<u32, 8, A>

where A: Sealed,

Available on little-endian only.

fn reinterpret_simd(self) -> Emulated<i16, 16, A>

impl<A> SIMDReinterpret<Emulated<i16, 8, A>> for Emulated<u8, 16, A>

where A: Sealed,

Available on little-endian only.

fn reinterpret_simd(self) -> Emulated<i16, 8, A>

impl<A> SIMDReinterpret<Emulated<i8, 64, A>> for Emulated<u32, 16, A>

where A: Sealed,

Available on little-endian only.

fn reinterpret_simd(self) -> Emulated<i8, 64, A>

impl<A> SIMDReinterpret<Emulated<u32, 16, A>> for Emulated<i8, 64, A>

where A: Sealed,

Available on little-endian only.

fn reinterpret_simd(self) -> Emulated<u32, 16, A>

impl<A> SIMDReinterpret<Emulated<u32, 16, A>> for Emulated<u8, 64, A>

where A: Sealed,

Available on little-endian only.

fn reinterpret_simd(self) -> Emulated<u32, 16, A>

impl<A> SIMDReinterpret<Emulated<u8, 16, A>> for Emulated<i16, 8, A>

where A: Sealed,

Available on little-endian only.

fn reinterpret_simd(self) -> Emulated<u8, 16, A>

impl<A> SIMDReinterpret<Emulated<u8, 64, A>> for Emulated<u32, 16, A>

where A: Sealed,

Available on little-endian only.

fn reinterpret_simd(self) -> Emulated<u8, 64, A>

impl<T, const N: usize, A> SIMDSelect<Emulated<T, N, A>> for BitMask<N, A>

where T: Copy, A: Sealed, Const<N>: SupportedLaneCount, BitMask<N, A>: SIMDMask<Arch = A>, Emulated<T, N, A>: SIMDVector<Mask = BitMask<N, A>>,

fn select(self, x: Emulated<T, N, A>, y: Emulated<T, N, A>) -> Emulated<T, N, A>

impl<A> SIMDSumTree for Emulated<f32, 1, A>

where A: Sealed,

fn sum_tree(self) -> f32

impl<A> SIMDSumTree for Emulated<f32, 16, A>

where A: Sealed,

fn sum_tree(self) -> f32

impl<A> SIMDSumTree for Emulated<f32, 2, A>

where A: Sealed,

fn sum_tree(self) -> f32

impl<A> SIMDSumTree for Emulated<f32, 4, A>

where A: Sealed,

fn sum_tree(self) -> f32

impl<A> SIMDSumTree for Emulated<f32, 8, A>

where A: Sealed,

fn sum_tree(self) -> f32

impl<A> SIMDSumTree for Emulated<i32, 16, A>

where A: Sealed,

fn sum_tree(self) -> i32

impl<A> SIMDSumTree for Emulated<i32, 4, A>

where A: Sealed,

fn sum_tree(self) -> i32

impl<A> SIMDSumTree for Emulated<i32, 8, A>

where A: Sealed,

fn sum_tree(self) -> i32

impl<A> SIMDSumTree for Emulated<u32, 16, A>

where A: Sealed,

fn sum_tree(self) -> u32

impl<A> SIMDSumTree for Emulated<u32, 4, A>

where A: Sealed,

fn sum_tree(self) -> u32

impl<A> SIMDSumTree for Emulated<u32, 8, A>

where A: Sealed,

fn sum_tree(self) -> u32

impl<T, const N: usize, A> SIMDVector for Emulated<T, N, A>

where T: Copy + Debug + Default, Const<N>: ArrayType<T, Type = [T; N]>, BitMask<N, A>: SIMDMask<Arch = A>, A: Sealed,

const EMULATED: bool = true

The underlying behavior is emulated using loops and is not accelerated by back-end intrinsics.

fn arch(self) -> A

Return the Scalar architecture.

fn to_underlying(self) -> Self::Underlying

Return the underlying array.

fn from_underlying(arch: A, repr: [T; N]) -> Self

Construct from the underlying array.

fn to_array(self) -> [T; N]

Return the underlying array.

fn from_array(arch: A, x: [T; N]) -> Self

Construct from the underlying array.

fn splat(arch: A, value: Self::Scalar) -> Self

Broadcast the provided scalar across all lanes.

unsafe fn load_simd(arch: A, ptr: *const T) -> Self

Load all the things.

unsafe fn load_simd_masked_logical( arch: A, ptr: *const T, mask: Self::Mask, ) -> Self

Only load values when the corresponding mask lane is set.

unsafe fn load_simd_first(arch: A, ptr: *const T, first: usize) -> Self

Only load the first first items. Set the rest to zero.

unsafe fn store_simd(self, ptr: *mut T)

Store all the things.

unsafe fn store_simd_masked_logical(self, ptr: *mut T, mask: Self::Mask)

Only store values when the corresponding mask lane is set.

unsafe fn store_simd_first(self, ptr: *mut T, first: usize)

Only store the first first items. Set the rest to zero.

const LANES: usize = N

The number of lanes in the vector.

type Arch = A

The architecture this vector belongs to.

type Scalar = T

The type of each element in the vector.

type Underlying = [T; N]

The underlying representation.

type ConstLanes = Const<N>

The value of LANES but in the type domain so we can use it to constrain other aspects of this trait.

type Mask = BitMask<N, A>

The expanded logical mask representation. This may-or-may-not actually be a bitmask, but should be easily convertible to and from a bitmask.

fn default(arch: A) -> Self

Return the default value for the type. This is always the numeric 0 for the associated scalar type.

fn num_lanes() -> usize

Return the number of lanes in this vector.

unsafe fn load_simd_masked( arch: Self::Arch, ptr: *const <Self as SIMDVector>::Scalar, mask: <<Self as SIMDVector>::ConstLanes as BitMaskType<Self::Arch>>::Type, ) -> Self

The same as load_simd_masked_logical but taking a BitMask instead.

unsafe fn store_simd_masked( self, ptr: *mut <Self as SIMDVector>::Scalar, mask: <<Self as SIMDVector>::ConstLanes as BitMaskType<Self::Arch>>::Type, )

The same as store_simd_masked_logical but taking a BitMask instead.

fn cast<T>(self) -> <Self as SIMDCast<T>>::Cast

where Self: SIMDCast<T>,

Perform a numeric cast on each element, returning a new SIMD vector.

impl<T, const N: usize, A> Shl<T> for Emulated<T, N, A>

where T: ReferenceShifts,

type Output = Emulated<T, N, A>

The resulting type after applying the << operator.

fn shl(self, rhs: T) -> Self::Output

Performs the << operation.

impl<T, const N: usize, A> Shl for Emulated<T, N, A>

where T: ReferenceShifts,

type Output = Emulated<T, N, A>

The resulting type after applying the << operator.

fn shl(self, rhs: Self) -> Self::Output

Performs the << operation.

impl<T, const N: usize, A> Shr<T> for Emulated<T, N, A>

where T: ReferenceShifts,

type Output = Emulated<T, N, A>

The resulting type after applying the >> operator.

fn shr(self, rhs: T) -> Self::Output

Performs the >> operation.

impl<T, const N: usize, A> Shr for Emulated<T, N, A>

where T: ReferenceShifts,

type Output = Emulated<T, N, A>

The resulting type after applying the >> operator.

fn shr(self, rhs: Self) -> Self::Output

Performs the >> operation.

impl<A> SplitJoin for Emulated<f16, 16, A>

where A: Copy,

type Halved = Emulated<f16, 8, A>

The type of the halved element.

fn split(self) -> LoHi<Self::Halved>

Split self into two equal halves.

fn join(lohi: LoHi<Self::Halved>) -> Self

Create self by joining the two halves.

impl<A> SplitJoin for Emulated<f32, 16, A>

where A: Copy,

type Halved = Emulated<f32, 8, A>

The type of the halved element.

fn split(self) -> LoHi<Self::Halved>

Split self into two equal halves.

fn join(lohi: LoHi<Self::Halved>) -> Self

Create self by joining the two halves.

impl<A> SplitJoin for Emulated<f32, 8, A>

where A: Copy,

type Halved = Emulated<f32, 4, A>

The type of the halved element.

fn split(self) -> LoHi<Self::Halved>

Split self into two equal halves.

fn join(lohi: LoHi<Self::Halved>) -> Self

Create self by joining the two halves.

impl<A> SplitJoin for Emulated<i16, 16, A>

where A: Copy,

type Halved = Emulated<i16, 8, A>

The type of the halved element.

fn split(self) -> LoHi<Self::Halved>

Split self into two equal halves.

fn join(lohi: LoHi<Self::Halved>) -> Self

Create self by joining the two halves.

impl<A> SplitJoin for Emulated<i16, 32, A>

where A: Copy,

type Halved = Emulated<i16, 16, A>

The type of the halved element.

fn split(self) -> LoHi<Self::Halved>

Split self into two equal halves.

fn join(lohi: LoHi<Self::Halved>) -> Self

Create self by joining the two halves.

impl<A> SplitJoin for Emulated<i32, 16, A>

where A: Copy,

type Halved = Emulated<i32, 8, A>

The type of the halved element.

fn split(self) -> LoHi<Self::Halved>

Split self into two equal halves.

fn join(lohi: LoHi<Self::Halved>) -> Self

Create self by joining the two halves.

impl<A> SplitJoin for Emulated<i32, 8, A>

where A: Copy,

type Halved = Emulated<i32, 4, A>

The type of the halved element.

fn split(self) -> LoHi<Self::Halved>

Split self into two equal halves.

fn join(lohi: LoHi<Self::Halved>) -> Self

Create self by joining the two halves.

impl<A> SplitJoin for Emulated<i8, 32, A>

where A: Copy,

type Halved = Emulated<i8, 16, A>

The type of the halved element.

fn split(self) -> LoHi<Self::Halved>

Split self into two equal halves.

fn join(lohi: LoHi<Self::Halved>) -> Self

Create self by joining the two halves.

impl<A> SplitJoin for Emulated<i8, 64, A>

where A: Copy,

type Halved = Emulated<i8, 32, A>

The type of the halved element.

fn split(self) -> LoHi<Self::Halved>

Split self into two equal halves.

fn join(lohi: LoHi<Self::Halved>) -> Self

Create self by joining the two halves.

impl<A> SplitJoin for Emulated<u32, 16, A>

where A: Copy,

type Halved = Emulated<u32, 8, A>

The type of the halved element.

fn split(self) -> LoHi<Self::Halved>

Split self into two equal halves.

fn join(lohi: LoHi<Self::Halved>) -> Self

Create self by joining the two halves.

impl<A> SplitJoin for Emulated<u32, 8, A>

where A: Copy,

type Halved = Emulated<u32, 4, A>

The type of the halved element.

fn split(self) -> LoHi<Self::Halved>

Split self into two equal halves.

fn join(lohi: LoHi<Self::Halved>) -> Self

Create self by joining the two halves.

impl<A> SplitJoin for Emulated<u64, 4, A>

where A: Copy,

type Halved = Emulated<u64, 2, A>

The type of the halved element.

fn split(self) -> LoHi<Self::Halved>

Split self into two equal halves.

fn join(lohi: LoHi<Self::Halved>) -> Self

Create self by joining the two halves.

impl<A> SplitJoin for Emulated<u8, 32, A>

where A: Copy,

type Halved = Emulated<u8, 16, A>

The type of the halved element.

fn split(self) -> LoHi<Self::Halved>

Split self into two equal halves.

fn join(lohi: LoHi<Self::Halved>) -> Self

Create self by joining the two halves.

impl<A> SplitJoin for Emulated<u8, 64, A>

where A: Copy,

type Halved = Emulated<u8, 32, A>

The type of the halved element.

fn split(self) -> LoHi<Self::Halved>

Split self into two equal halves.

fn join(lohi: LoHi<Self::Halved>) -> Self

Create self by joining the two halves.

impl<T, const N: usize, A> Sub for Emulated<T, N, A>

where T: ReferenceScalarOps,

type Output = Emulated<T, N, A>

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self

Performs the - operation.

impl<A> ZipUnzip for Emulated<f16, 16, A>

where A: Copy,

fn zip(halves: LoHi<Self::Halved>) -> Self

Interleave elements from halves.lo and halves.hi into Self.

fn unzip(self) -> LoHi<Self::Halved>

Separate even-indexed elements into lo and odd-indexed into hi.

fn zip_flat(self) -> Self

Interleave in-place: the low half of self supplies the even-indexed positions and the high half supplies the odd-indexed positions.

fn unzip_flat(self) -> Self

Deinterleave in-place: even-indexed elements are collected into the low half of the result and odd-indexed elements into the high half.

impl<A> ZipUnzip for Emulated<i16, 16, A>

where A: Copy,

fn zip(halves: LoHi<Self::Halved>) -> Self

Interleave elements from halves.lo and halves.hi into Self.

fn unzip(self) -> LoHi<Self::Halved>

Separate even-indexed elements into lo and odd-indexed into hi.

fn zip_flat(self) -> Self

Interleave in-place: the low half of self supplies the even-indexed positions and the high half supplies the odd-indexed positions.

fn unzip_flat(self) -> Self

Deinterleave in-place: even-indexed elements are collected into the low half of the result and odd-indexed elements into the high half.

impl<A> ZipUnzip for Emulated<i32, 8, A>

where A: Copy,

fn zip(halves: LoHi<Self::Halved>) -> Self

Interleave elements from halves.lo and halves.hi into Self.

fn unzip(self) -> LoHi<Self::Halved>

Separate even-indexed elements into lo and odd-indexed into hi.

fn zip_flat(self) -> Self

Interleave in-place: the low half of self supplies the even-indexed positions and the high half supplies the odd-indexed positions.

fn unzip_flat(self) -> Self

Deinterleave in-place: even-indexed elements are collected into the low half of the result and odd-indexed elements into the high half.

impl<A> ZipUnzip for Emulated<i8, 32, A>

where A: Copy,

fn zip(halves: LoHi<Self::Halved>) -> Self

Interleave elements from halves.lo and halves.hi into Self.

fn unzip(self) -> LoHi<Self::Halved>

Separate even-indexed elements into lo and odd-indexed into hi.

fn zip_flat(self) -> Self

Interleave in-place: the low half of self supplies the even-indexed positions and the high half supplies the odd-indexed positions.

fn unzip_flat(self) -> Self

Deinterleave in-place: even-indexed elements are collected into the low half of the result and odd-indexed elements into the high half.

impl<A> ZipUnzip for Emulated<u32, 8, A>

where A: Copy,

fn zip(halves: LoHi<Self::Halved>) -> Self

Interleave elements from halves.lo and halves.hi into Self.

fn unzip(self) -> LoHi<Self::Halved>

Separate even-indexed elements into lo and odd-indexed into hi.

fn zip_flat(self) -> Self

Interleave in-place: the low half of self supplies the even-indexed positions and the high half supplies the odd-indexed positions.

fn unzip_flat(self) -> Self

Deinterleave in-place: even-indexed elements are collected into the low half of the result and odd-indexed elements into the high half.

impl<A> ZipUnzip for Emulated<u8, 32, A>

where A: Copy,

fn zip(halves: LoHi<Self::Halved>) -> Self

Interleave elements from halves.lo and halves.hi into Self.

fn unzip(self) -> LoHi<Self::Halved>

Separate even-indexed elements into lo and odd-indexed into hi.

fn zip_flat(self) -> Self

Interleave in-place: the low half of self supplies the even-indexed positions and the high half supplies the odd-indexed positions.

fn unzip_flat(self) -> Self

Deinterleave in-place: even-indexed elements are collected into the low half of the result and odd-indexed elements into the high half.

impl<T: Copy, const N: usize, A: Copy> Copy for Emulated<T, N, A>