Struct ShimToken

pub struct ShimToken<Underlying, Scalar, Token>(/* private fields */);

Shim that converts the associated token.

Trait Implementations

impl<Underlying, Scalar, Token> Add<Scalar> for ShimToken<Underlying, Scalar, Token>

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

type Output = ShimToken<Underlying, Scalar, Token>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<Underlying, Scalar, Token> Add for ShimToken<Underlying, Scalar, Token>

where Underlying: Copy + Add<Underlying, Output = Underlying>,

type Output = ShimToken<Underlying, Scalar, Token>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<Underlying, Scalar, Token> AddAssign<Scalar> for ShimToken<Underlying, Scalar, Token>

where Underlying: Copy + AddAssign<Scalar>, Scalar: Copy,

fn add_assign(&mut self, rhs: Scalar)

Performs the += operation.

impl<Underlying, Scalar, Token> AddAssign for ShimToken<Underlying, Scalar, Token>

where Underlying: Copy + AddAssign<Underlying>, Scalar: Copy,

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<Underlying, Scalar, Token> AsMut<[Scalar]> for ShimToken<Underlying, Scalar, Token>

where Underlying: AsMut<[Scalar]>,

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

Converts this type into a mutable reference of the (usually inferred) input type.

impl<Underlying, Scalar, Token> AsRef<[Scalar]> for ShimToken<Underlying, Scalar, Token>

where Underlying: AsRef<[Scalar]>,

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

Converts this type into a shared reference of the (usually inferred) input type.

impl<Underlying: Clone, Scalar: Clone, Token: Clone> Clone for ShimToken<Underlying, Scalar, Token>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Underlying, Real, Token> Complex for ShimToken<Underlying, Complex<Real>, Token>

where Underlying: Vector<Scalar = Complex<Real>> + Complex<RealScalar = Real>, Real: Copy, Token: Token, Underlying::Token: From<Token>,

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: Debug, Scalar: Debug, Token: Debug> Debug for ShimToken<Underlying, Scalar, Token>

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

Formats the value using the given formatter.

impl<Underlying, Scalar, Token> Deref for ShimToken<Underlying, Scalar, Token>

where Underlying: Deref,

type Target = <Underlying as Deref>::Target

The resulting type after dereferencing.

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

Dereferences the value.

impl<Underlying, Scalar, Token> DerefMut for ShimToken<Underlying, Scalar, Token>

where Underlying: DerefMut,

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

Mutably dereferences the value.

impl<Underlying, Scalar, Token> Div<Scalar> for ShimToken<Underlying, Scalar, Token>

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

type Output = ShimToken<Underlying, Scalar, Token>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Underlying, Scalar, Token> Div for ShimToken<Underlying, Scalar, Token>

where Underlying: Copy + Div<Underlying, Output = Underlying>,

type Output = ShimToken<Underlying, Scalar, Token>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<Underlying, Scalar, Token> DivAssign<Scalar> for ShimToken<Underlying, Scalar, Token>

where Underlying: Copy + DivAssign<Scalar>, Scalar: Copy,

fn div_assign(&mut self, rhs: Scalar)

Performs the /= operation.

impl<Underlying, Scalar, Token> DivAssign for ShimToken<Underlying, Scalar, Token>

where Underlying: Copy + DivAssign<Underlying>, Scalar: Copy,

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl<Underlying, Scalar, Token> Mul<Scalar> for ShimToken<Underlying, Scalar, Token>

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

type Output = ShimToken<Underlying, Scalar, Token>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<Underlying, Scalar, Token> Mul for ShimToken<Underlying, Scalar, Token>

where Underlying: Copy + Mul<Underlying, Output = Underlying>,

type Output = ShimToken<Underlying, Scalar, Token>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<Underlying, Scalar, Token> MulAssign<Scalar> for ShimToken<Underlying, Scalar, Token>

where Underlying: Copy + MulAssign<Scalar>, Scalar: Copy,

fn mul_assign(&mut self, rhs: Scalar)

Performs the *= operation.

impl<Underlying, Scalar, Token> MulAssign for ShimToken<Underlying, Scalar, Token>

where Underlying: Copy + MulAssign<Underlying>, Scalar: Copy,

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<Underlying, Scalar, Token> Neg for ShimToken<Underlying, Scalar, Token>

where Underlying: Copy + Neg<Output = Underlying>,

type Output = ShimToken<Underlying, Scalar, Token>

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl<Underlying, Scalar, Token> Product<ShimToken<Underlying, Scalar, Token>> for <ShimToken<Underlying, Scalar, Token> as Vector>::Scalar

where Option<ShimToken<Underlying, Scalar, Token>>: Product<ShimToken<Underlying, Scalar, Token>>, Underlying: Vector<Scalar = Scalar>, Scalar: Copy + Mul<Self, Output = Self> + Default, Token: Token, Underlying::Token: From<Token>,

fn product<I>(iter: I) -> Self

where I: Iterator<Item = ShimToken<Underlying, Scalar, Token>>,

Takes an iterator and generates Self from the elements by multiplying the items.

impl<Underlying, Scalar, Token> Product<ShimToken<Underlying, Scalar, Token>> for Option<ShimToken<Underlying, Scalar, Token>>

where ShimToken<Underlying, Scalar, Token>: MulAssign, Underlying: Copy,

fn product<I>(iter: I) -> Self

where I: Iterator<Item = ShimToken<Underlying, Scalar, Token>>,

Takes an iterator and generates Self from the elements by multiplying the items.

impl<Underlying, Scalar, Token> Sub<Scalar> for ShimToken<Underlying, Scalar, Token>

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

type Output = ShimToken<Underlying, Scalar, Token>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<Underlying, Scalar, Token> Sub for ShimToken<Underlying, Scalar, Token>

where Underlying: Copy + Sub<Underlying, Output = Underlying>,

type Output = ShimToken<Underlying, Scalar, Token>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<Underlying, Scalar, Token> SubAssign<Scalar> for ShimToken<Underlying, Scalar, Token>

where Underlying: Copy + SubAssign<Scalar>, Scalar: Copy,

fn sub_assign(&mut self, rhs: Scalar)

Performs the -= operation.

impl<Underlying, Scalar, Token> SubAssign for ShimToken<Underlying, Scalar, Token>

where Underlying: Copy + SubAssign<Underlying>, Scalar: Copy,

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<Underlying, Scalar, Token> Sum<ShimToken<Underlying, Scalar, Token>> for <ShimToken<Underlying, Scalar, Token> as Vector>::Scalar

where Option<ShimToken<Underlying, Scalar, Token>>: Sum<ShimToken<Underlying, Scalar, Token>>, Underlying: Vector<Scalar = Scalar>, Scalar: Copy + Add<Self, Output = Self> + Default, Token: Token, Underlying::Token: From<Token>,

fn sum<I>(iter: I) -> Self

where I: Iterator<Item = ShimToken<Underlying, Scalar, Token>>,

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<Underlying, Scalar, Token> Sum<ShimToken<Underlying, Scalar, Token>> for Option<ShimToken<Underlying, Scalar, Token>>

where ShimToken<Underlying, Scalar, Token>: AddAssign, Underlying: Copy,

fn sum<I>(iter: I) -> Self

where I: Iterator<Item = ShimToken<Underlying, Scalar, Token>>,

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<Underlying, Scalar, Token> Vector for ShimToken<Underlying, Scalar, Token>

where Underlying: Vector<Scalar = Scalar>, Scalar: Copy, Token: Token + Into<<Underlying as Vector>::Token>,

type Scalar = Scalar

The type of elements in the vector.

type Token = Token

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

type Width = <Underlying as Vector>::Width

The number of elements in the vector.

type Underlying = <Underlying as Vector>::Underlying

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.

impl<Underlying: Copy, Scalar: Copy, Token: Copy> Copy for ShimToken<Underlying, Scalar, Token>