Struct generic_simd::shim::Shim2

#[repr(transparent)]pub struct Shim2<Underlying, Scalar>(_, _);

Shim that doubles the width of a vector.

Trait Implementations

impl<Underlying, Scalar> Add<Scalar> for Shim2<Underlying, Scalar> where
    Underlying: Copy + Add<Scalar, Output = Underlying>,
    Scalar: Copy, 

type Output = Self

The resulting type after applying the + operator.

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

Performs the + operation.

impl<Underlying, Scalar> Add<Shim2<Underlying, Scalar>> for Shim2<Underlying, Scalar> where
    Underlying: Copy + Add<Underlying, Output = Underlying>, 

type Output = Self

The resulting type after applying the + operator.

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

Performs the + operation.

impl<Underlying, Scalar> AddAssign<Scalar> for Shim2<Underlying, Scalar> where
    Underlying: Copy + AddAssign<Scalar>,
    Scalar: Copy, 

fn add_assign(&mut self, rhs: Scalar)

Performs the += operation.

impl<Underlying, Scalar> AddAssign<Shim2<Underlying, Scalar>> for Shim2<Underlying, Scalar> where
    Underlying: Copy + AddAssign<Underlying>,
    Scalar: Copy, 

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<Underlying, Scalar> AsMut<[Scalar]> for Shim2<Underlying, Scalar> where
    Underlying: Vector<Scalar = Scalar>,
    Underlying::Width: Double,
    Scalar: Copy, 

fn as_mut(&mut self) -> &mut [Scalar]

Performs the conversion.

impl<Underlying, Scalar> AsRef<[Scalar]> for Shim2<Underlying, Scalar> where
    Underlying: Vector<Scalar = Scalar>,
    Underlying::Width: Double,
    Scalar: Copy, 

fn as_ref(&self) -> &[Scalar]

Performs the conversion.

impl<Underlying: Clone, Scalar: Clone> Clone for Shim2<Underlying, Scalar>

fn clone(&self) -> Shim2<Underlying, Scalar>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Underlying, Real> Complex for Shim2<Underlying, Complex<Real>> where
    Underlying: Vector<Scalar = Complex<Real>> + Complex<RealScalar = Real>,
    Underlying::Width: Double,
    Real: Copy, 

type RealScalar = Real

The real scalar type.

fn conj(self) -> Self

Conjugate.

fn mul_i(self) -> Self

Multiply by i.

fn mul_neg_i(self) -> Self

Multiply by -i.

impl<Underlying: Copy, Scalar: Copy> Copy for Shim2<Underlying, Scalar>

impl<Underlying: Debug, Scalar: Debug> Debug for Shim2<Underlying, Scalar>

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

Formats the value using the given formatter.

impl<Underlying, Scalar> Deref for Shim2<Underlying, Scalar> where
    Underlying: Vector<Scalar = Scalar>,
    Underlying::Width: Double,
    Scalar: Copy, 

type Target = [Scalar]

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<Underlying, Scalar> DerefMut for Shim2<Underlying, Scalar> where
    Underlying: Vector<Scalar = Scalar>,
    Underlying::Width: Double,
    Scalar: Copy, 

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<Underlying, Scalar> Div<Scalar> for Shim2<Underlying, Scalar> where
    Underlying: Copy + Div<Scalar, Output = Underlying>,
    Scalar: Copy, 

type Output = Self

The resulting type after applying the / operator.

fn div(self, rhs: Scalar) -> Self

Performs the / operation.

impl<Underlying, Scalar> Div<Shim2<Underlying, Scalar>> for Shim2<Underlying, Scalar> where
    Underlying: Copy + Div<Underlying, Output = Underlying>, 

type Output = Self

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Underlying, Scalar> DivAssign<Scalar> for Shim2<Underlying, Scalar> where
    Underlying: Copy + DivAssign<Scalar>,
    Scalar: Copy, 

fn div_assign(&mut self, rhs: Scalar)

Performs the /= operation.

impl<Underlying, Scalar> DivAssign<Shim2<Underlying, Scalar>> for Shim2<Underlying, Scalar> where
    Underlying: Copy + DivAssign<Underlying>,
    Scalar: Copy, 

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl<Underlying, Scalar> Mul<Scalar> for Shim2<Underlying, Scalar> where
    Underlying: Copy + Mul<Scalar, Output = Underlying>,
    Scalar: Copy, 

type Output = Self

The resulting type after applying the * operator.

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

Performs the * operation.

impl<Underlying, Scalar> Mul<Shim2<Underlying, Scalar>> for Shim2<Underlying, Scalar> where
    Underlying: Copy + Mul<Underlying, Output = Underlying>, 

type Output = Self

The resulting type after applying the * operator.

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

Performs the * operation.

impl<Underlying, Scalar> MulAssign<Scalar> for Shim2<Underlying, Scalar> where
    Underlying: Copy + MulAssign<Scalar>,
    Scalar: Copy, 

fn mul_assign(&mut self, rhs: Scalar)

Performs the *= operation.

impl<Underlying, Scalar> MulAssign<Shim2<Underlying, Scalar>> for Shim2<Underlying, Scalar> where
    Underlying: Copy + MulAssign<Underlying>,
    Scalar: Copy, 

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<Underlying, Scalar> Neg for Shim2<Underlying, Scalar> where
    Underlying: Copy + Neg<Output = Underlying>, 

type Output = Self

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl<Underlying, Scalar> Product<Shim2<Underlying, Scalar>> for Option<Shim2<Underlying, Scalar>> where
    Shim2<Underlying, Scalar>: MulAssign,
    Underlying: Copy, 

fn product<I>(iter: I) -> Self where
    I: Iterator<Item = Shim2<Underlying, Scalar>>, 

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<Underlying, Scalar> Product<Shim2<Underlying, Scalar>> for <Shim2<Underlying, Scalar> as Vector>::Scalar where
    Option<Shim2<Underlying, Scalar>>: Product<Shim2<Underlying, Scalar>>,
    Underlying: Vector<Scalar = Scalar>,
    Underlying::Width: Double,
    Scalar: Copy + Mul<Self, Output = Self> + Default, 

fn product<I>(iter: I) -> Self where
    I: Iterator<Item = Shim2<Underlying, Scalar>>, 

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<Underlying, Scalar> Sub<Scalar> for Shim2<Underlying, Scalar> where
    Underlying: Copy + Sub<Scalar, Output = Underlying>,
    Scalar: Copy, 

type Output = Self

The resulting type after applying the - operator.

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

Performs the - operation.

impl<Underlying, Scalar> Sub<Shim2<Underlying, Scalar>> for Shim2<Underlying, Scalar> where
    Underlying: Copy + Sub<Underlying, Output = Underlying>, 

type Output = Self

The resulting type after applying the - operator.

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

Performs the - operation.

impl<Underlying, Scalar> SubAssign<Scalar> for Shim2<Underlying, Scalar> where
    Underlying: Copy + SubAssign<Scalar>,
    Scalar: Copy, 

fn sub_assign(&mut self, rhs: Scalar)

Performs the -= operation.

impl<Underlying, Scalar> SubAssign<Shim2<Underlying, Scalar>> for Shim2<Underlying, Scalar> where
    Underlying: Copy + SubAssign<Underlying>,
    Scalar: Copy, 

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<Underlying, Scalar> Sum<Shim2<Underlying, Scalar>> for Option<Shim2<Underlying, Scalar>> where
    Shim2<Underlying, Scalar>: AddAssign,
    Underlying: Copy, 

fn sum<I>(iter: I) -> Self where
    I: Iterator<Item = Shim2<Underlying, Scalar>>, 

Method which takes an iterator and generates Self from the elements by "summing up" the items.

impl<Underlying, Scalar> Sum<Shim2<Underlying, Scalar>> for <Shim2<Underlying, Scalar> as Vector>::Scalar where
    Option<Shim2<Underlying, Scalar>>: Sum<Shim2<Underlying, Scalar>>,
    Underlying: Vector<Scalar = Scalar>,
    Underlying::Width: Double,
    Scalar: Copy + Add<Self, Output = Self> + Default, 

fn sum<I>(iter: I) -> Self where
    I: Iterator<Item = Shim2<Underlying, Scalar>>, 

Method which takes an iterator and generates Self from the elements by "summing up" the items.

impl<Underlying, Scalar> Vector for Shim2<Underlying, Scalar> where
    Underlying: Vector<Scalar = Scalar>,
    Underlying::Width: Double,
    Scalar: Copy, 

type Scalar = Scalar

The type of elements in the vector.

type Token = <Underlying as Vector>::Token

The token that proves support for this vector on the CPU.

type Width = <Underlying::Width as Double>::Doubled

The number of elements in the vector.

type Underlying = [<Underlying as Vector>::Underlying; 2]

The underlying type

fn zeroed(token: Self::Token) -> Self

Create a new vector with each lane containing zeroes.

fn splat(token: Self::Token, from: Self::Scalar) -> Self

Create a new vector with each lane containing the provided value.

fn width() -> usize

Returns the number of lanes.

fn to_token(self) -> Self::Token

Creates a new instance of Token from a vector.

fn as_slice(&self) -> &[Self::Scalar]

Returns a slice containing the vector.

fn as_slice_mut(&mut self) -> &mut [Self::Scalar]

Returns a mutable slice containing the vector.

fn to_underlying(self) -> Self::Underlying

Converts this vector to its underlying type.

fn from_underlying(token: Self::Token, underlying: Self::Underlying) -> Self

Converts the underlying type to a vector.

unsafe fn read_ptr(token: Self::Token, from: *const Self::Scalar) -> Self

Read from a pointer.

unsafe fn read_aligned_ptr(
    token: Self::Token,
    from: *const Self::Scalar
) -> Self

Read from a vector-aligned pointer.

unsafe fn read_unchecked(token: Self::Token, from: &[Self::Scalar]) -> Self

Read from a vector-aligned pointer. Read from a slice without checking the length.

fn read(token: Self::Token, from: &[Self::Scalar]) -> Self

Read from a slice.

unsafe fn write_ptr(self, to: *mut Self::Scalar)

Write to a pointer.

unsafe fn write_aligned_ptr(self, to: *mut Self::Scalar)

Write to a pointer.

unsafe fn write_unchecked(self, to: &mut [Self::Scalar])

Write to a slice without checking the length.

fn write(self, to: &mut [Self::Scalar])

Write to a slice.