Struct Vector 

pub struct Vector<const N: usize, T, A: Alignment>(/* private fields */)
where
    T: Scalar,
    Length<N>: SupportedLength;

A generic vector type.

This type is the generic form of these type aliases:

• Vec2<T>, Vec3<T>, Vec4<T>.
• Vec2U<T>, Vec3U<T>, Vec4U<T>.

This type is generic over:

• N: Length (2, 3, or 4).
• T: Scalar type.
• A: Alignment (see Alignment).

Memory Layout

Type	Size	Alignment
Vec2<T>	size_of::<T>() * 2	See below
Vec3<T>	See below	See below
Vec4<T>	size_of::<T>() * 4	See below
Vec2U<T>	size_of::<T>() * 2	align_of::<T>()
Vec3U<T>	size_of::<T>() * 3	align_of::<T>()
Vec4U<T>	size_of::<T>() * 4	align_of::<T>()

The alignment of aligned vectors can be anything from the alignment of T to the size of the vector.

The size of Vec3<T> can either be size_of::<T>() * 3 or size_of::<T>() * 4. If its size is times 4, the padding is guaranteed to be an initialized value of T.

The specific representation of each vector type is controlled by the ScalarBackend trait.

Implementations

impl<const N: usize, T, A: Alignment> Vector<N, T, A>

where T: Scalar, Length<N>: SupportedLength,

pub const fn from_array(array: [T; N]) -> Self

Creates a vector from an array.

pub const fn splat(value: T) -> Self

Creates a vector with all elements set to the given value.

pub fn from_fn(f: impl FnMut(usize) -> T) -> Self

Creates a vector by calling function f for each element index.

Equivalent to (f(0), f(1), f(2), ...).

pub const fn to_alignment<A2: Alignment>(self) -> Vector<N, T, A2>

Converts the vector to the specified alignment.

pub const fn align(self) -> Vector<N, T, Aligned>

Converts the alignment of the vector to Aligned.

pub const fn unalign(self) -> Vector<N, T, Unaligned>

Converts the alignment of the vector to Unaligned.

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

Converts the vector to an array.

pub const fn as_array_ref(&self) -> &[T; N]

Returns a reference to the vector’s elements.

pub const fn as_array_mut(&mut self) -> &mut [T; N]

Returns a mutable reference to the vector’s elements.

pub fn iter(self) -> IntoIter<T, N>

Returns an iterator over the vector’s elements.

This method returns an iterator over T and not &T. to iterate over references use vec.as_array_ref().iter().

pub fn iter_mut(&mut self) -> IterMut<'_, T>

Returns an iterator over mutable references to the vector’s elements.

pub fn map<T2: Scalar>(self, f: impl Fn(T) -> T2) -> Vector<N, T2, A>

Calls function f for each element of the vector and returns the result.

pub const fn get(self, index: usize) -> Option<T>

Returns the element at the given index, or None if the index is out of bounds.

pub const fn get_mut(&mut self, index: usize) -> Option<&mut T>

Returns a mutable reference to the element at the given index, or None if the index is out of bounds.

pub fn reverse(self) -> Self

Returns the vector with its components in reverse order.

pub fn repr(self) -> <T as ScalarBackend<N, A>>::VectorRepr

where T: ScalarBackend<N, A>,

Returns the internal representation of the vector.

The internal representation is controlled by the implementation for the ScalarBackend trait.

This function should not be used outside the implementation for ScalarBackend because the internal representation could change silently and cause compile errors.

pub unsafe fn from_repr(repr: <T as ScalarBackend<N, A>>::VectorRepr) -> Self

where T: ScalarBackend<N, A>,

Creates a vector from its internal representation.

The internal representation is controlled by the implementation for the ScalarBackend trait.

This function should not be used outside the implementation for ScalarBackend because the internal representation could change silently and cause compile errors.

Safety

The provided value must be valid for this vector type, because the internal type may have less memory safety requirements than T.

impl<const N: usize, A: Alignment> Vector<N, f32, A>

where Length<N>: SupportedLength,

pub fn is_nan(self) -> bool

Returns true if any component of self is NaN.

pub fn is_finite(self) -> bool

Returns true if all components of self are finite.

pub fn recip(self) -> Self

Computes 1.0 / self.

pub fn element_sum(self) -> f32

Computes the sum of the vector’s elements.

The order of addition is unspecified and may differ between target architectures.

pub fn element_product(self) -> f32

Computes the product of the vector’s elements.

The order of multiplication is unspecified and may differ between target architectures.

pub fn max(self, other: Self) -> Self

Returns the maximum between the components of self and other.

This function is not consistent with IEEE semantics in regards to NaN propagation and handling of -0.0.

Panics

When assertions are enabled, this function panics if any input is NaN.

pub fn min(self, other: Self) -> Self

Returns the minimum between the components of self and other.

This function is not consistent with IEEE semantics in regards to NaN propagation and handling of -0.0.

Panics

When assertions are enabled, this function panics if any input is NaN.

pub fn clamp(self, min: Self, max: Self) -> Self

Clamps the components of self between the components of min and max.

This function is not consistent with IEEE semantics in regards to NaN propagation and handling of -0.0.

Panics

When assertions are enabled, this function panics if any input is NaN or if min > max.

pub fn max_element(self) -> f32

Returns the maximum component of the vector.

This function is not consistent with IEEE semantics in regards to NaN propagation and handling of -0.0.

Panics

When assertions are enabled, this function panics if any input is NaN.

pub fn min_element(self) -> f32

Returns the minimum component of the vector.

This function is not consistent with IEEE semantics in regards to NaN propagation and handling of -0.0.

Panics

When assertions are enabled, this function panics if any input is NaN.

pub fn abs(self) -> Self

Returns the absolute values of the components of self.

pub fn signum(self) -> Self

Returns the signum of the components of self.

For each component:

• 1.0 if the component is positive or +0.0.
• -1.0 if the component is negative or -0.0.
• NaN if the component is NaN.

pub fn copysign(self, sign: Self) -> Self

Returns a vector with the magnitudes of self and the signs of sign.

pub fn dot(self, rhs: Self) -> f32

Computes the dot product of self and rhs.

pub fn length_squared(self) -> f32

Computes the squared length/magnitude of self.

pub fn distance_squared(self, other: Self) -> f32

Computes the squared euclidean distance between self and other.

pub fn lerp(self, other: Self, t: f32) -> Self

Computes the linear interpolation between self and other based on the value t.

When t is 0.0, the result is self. When t is 1.0, the result is rhs. When t is outside of the range [0.0, 1.0], the result is linearly extrapolated.

pub fn midpoint(self, other: Self) -> Self

Computes the midpoint between self and other.

This function is equivalent to self.lerp(other, 0.5) but is cheaper to compute.

This function may return a slightly different value than lerp.

pub fn is_normalized(self) -> bool

Returns whether self has the length 1.0 or not.

This function uses a precision threshold of approximately 1e-4.

pub fn project_onto(self, other: Self) -> Self

Returns the vector projection of self onto other.

other must not be a zero vector.

Panics

When assertions are enabled, this function panics if other is a zero vector.

pub fn project_onto_normalized(self, other: Self) -> Self

Returns the vector projection of self onto other.

other must be normalized.

Panics

When assertions are enabled, this function panics if other is not normalized.

pub fn reject_from(self, other: Self) -> Self

Returns the vector rejection of self from other.

Vector rejection is the vector pointing from the projection to the original vector. Basically: self - self.project_onto(other).

other must not be a zero vector.

Panics

When assertions are enabled, this function panics if other is a zero vector.

pub fn reject_from_normalized(self, other: Self) -> Self

Returns the vector rejection of self from other.

Vector rejection is the vector pointing from the projection to the original vector. Basically: self - self.project_onto(other).

other must be normalized.

Panics

When assertions are enabled, this function panics if other is not normalized.

pub fn reflect(self, normal: Self) -> Self

Returns the vector reflection for self with normal.

Vector reflection is the reflection of the vector on a surface with the given normal.

normal must be normalized.

Panics

When assertions are enabled, this function panics if normal is not normalized.

impl<A: Alignment> Vector<3, f32, A>

pub fn cross(self, rhs: Self) -> Self

Computes the cross product of self and rhs.

pub fn any_orthogonal_vector(self) -> Self

Returns some vector that is orthogonal to self.

self must be finite and not a zero vector.

The output vector is not necessarily normalized. For that use Self::any_orthonormal_vector() instead.

pub fn any_orthonormal_vector(self) -> Self

Returns some unit vector that is orthogonal to self.

self must normalized.

Panics

When assertions are enabled, this function panics if self is not normalized.

pub fn any_orthonormal_pair(self) -> (Self, Self)

Returns two unit vectors that are orthogonal to self and to each other.

Together with self, they form an orthonormal basis where the three vectors are orthogonal to each other and are normalized.

Panics

When assertions are enabled, this function panics if self is not normalized.

impl<const N: usize, A: Alignment> Vector<N, f32, A>

where Length<N>: SupportedLength,

pub fn floor(self) -> Self

Rounds the components of self down.

pub fn ceil(self) -> Self

Rounds the components of self up.

pub fn round(self) -> Self

Rounds the components of self to the nearest integer.

pub fn trunc(self) -> Self

Rounds the components of self towards zero.

pub fn fract(self) -> Self

Returns the fractional part of self.

This function is equivalent to self - self.trunc().

pub fn mul_add(self, a: Self, b: Self) -> Self

Fused Multiply Add. Computes self * a + b with only one rounding error instead of two.

This is slower than an unfused multiply add for most target architectures.

This function is guaranteed to return the exact same value as the standard library.

pub fn div_euclid(self, rhs: Self) -> Self

Euclidiean Division.

This function is guaranteed to return the exact same value as the standard library.

pub fn rem_euclid(self, rhs: Self) -> Self

Euclidiean Remainder.

This function is guaranteed to return the exact same value as the standard library.

pub fn sqrt(self) -> Self

Computes the square root of the components of self.

This function is guaranteed to return the exact same value as the standard library.

pub fn sin(self) -> Self

Computes the sine of the components of self.

This function has unspecified precision and may return a different value than the standard library.

pub fn cos(self) -> Self

Computes the cosine of the components of self.

This function has unspecified precision and may return a different value than the standard library.

pub fn tan(self) -> Self

Computes the tangent of the components of self.

This function has unspecified precision and may return a different value than the standard library.

pub fn asin(self) -> Self

Computes the arc sine of the components of self.

This function has unspecified precision and may return a different value than the standard library.

pub fn acos(self) -> Self

Computes the arc cosine of the components of self.

This function has unspecified precision and may return a different value than the standard library.

pub fn atan(self) -> Self

Computes the arc tangent of the components of self.

This function has unspecified precision and may return a different value than the standard library.

pub fn sin_cos(self) -> (Self, Self)

Simultaneously computes the sine and cosine of the components of self.

This function has unspecified precision and may return a different value than the standard library.

pub fn length(self) -> f32

Returns the length/magnitude of self.

pub fn distance(self, other: Self) -> f32

Computes the euclidean distance between self and other.

pub fn move_towards(self, other: Self, max_delta: f32) -> Self

Moves self towards other by the value max_delta.

When max_delta is 0.0, the result is self. When max_delta is equal to or greater than self.distance(other), the result is other.

pub fn normalize(self) -> Self

Returns a vector with the direction of self and length 1.0.

Panics

When assertions are enabled, this function panics if the input is zero or if the result is non finite or zero.

pub fn try_normalize(self) -> Option<Self>

Computes self.normalize or returns None if the input is zero or if the result is non finite or zero.

pub fn normalize_or(self, fallback: Self) -> Self

Computes self.normalize or returns fallback if the input is zero or if the result is non finite or zero.

pub fn normalize_or_zero(self) -> Self

Computes self.normalize or returns a zero vector if the input is zero or if the result is non finite or zero.

pub fn normalize_and_length(self) -> (Self, f32)

Computes self.normalize() and self.length().

If self is a zero vector, the function returns (Self::ZERO, 0.0).

pub fn with_max_length(self, max: f32) -> Self

Returns self with a length of no more than max.

Panics

When assertions are enabled, this function panics if max is negative.

pub fn with_min_length(self, min: f32) -> Self

Returns self with a length of no less than min.

Panics

When assertions are enabled, this function panics if min is negative.

pub fn clamp_length(self, min: f32, max: f32) -> Self

Returns self with a length of no less than min and no more than max.

Panics

When assertions are enabled, this function panics if min is greater than max, or if either min or max are negative.

pub fn angle_between(self, other: Self) -> f32

Computes the angle (in radians) between two vectors in the range [0, +π].

The vectors do not need to be unit vectors but they do need to be non-zero.

This function has unspecified precision.

pub fn exp(self) -> Self

Computes the exponential function e^self for the components of self.

This function has unspecified precision and may return a different value than the standard library.

pub fn exp2(self) -> Self

Computes 2^self for the components of self.

This function has unspecified precision and may return a different value than the standard library.

pub fn ln(self) -> Self

Computes the natural logarithm for the components of self.

This function has unspecified precision and may return a different value than the standard library.

pub fn log2(self) -> Self

Computes the base 2 logarithm for the components of self.

This function has unspecified precision and may return a different value than the standard library.

pub fn powf(self, n: f32) -> Self

Computes self^n for the components of self.

This function has unspecified precision and may return a different value than the standard library.

pub fn refract(self, normal: Self, eta: f32) -> Self

Returns the vector refraction of self through normal and eta.

eta is the incident index divided by the transmitted index.

When total internal reflection occurs, this function returns a zero vector.

self and normal must be normalized.

Panics

When assertions are enabled, this function panics if self or normal are not normalized.

impl<A: Alignment> Vector<2, f32, A>

pub fn perp(self) -> Self

Returns self rotated by 90 degrees.

pub fn rotate(self, angle: f32) -> Self

Rotates self by angle (in radians).

This function has unspecified precision.

impl<A: Alignment> Vector<3, f32, A>

pub fn rotate_x(self, angle: f32) -> Self

Rotates self around the x axis by angle (in radians).

This function has unspecified precision.

pub fn rotate_y(self, angle: f32) -> Self

Rotates self around the y axis by angle (in radians).

This function has unspecified precision.

pub fn rotate_z(self, angle: f32) -> Self

Rotates self around the z axis by angle (in radians).

This function has unspecified precision.

impl<const N: usize, A: Alignment> Vector<N, f64, A>

where Length<N>: SupportedLength,

pub fn is_nan(self) -> bool

Returns true if any component of self is NaN.

pub fn is_finite(self) -> bool

Returns true if all components of self are finite.

pub fn recip(self) -> Self

Computes 1.0 / self.

pub fn element_sum(self) -> f64

Computes the sum of the vector’s elements.

The order of addition is unspecified and may differ between target architectures.

pub fn element_product(self) -> f64

Computes the product of the vector’s elements.

The order of multiplication is unspecified and may differ between target architectures.

pub fn max(self, other: Self) -> Self

Returns the maximum between the components of self and other.

This function is not consistent with IEEE semantics in regards to NaN propagation and handling of -0.0.

Panics

When assertions are enabled, this function panics if any input is NaN.

pub fn min(self, other: Self) -> Self

Returns the minimum between the components of self and other.

This function is not consistent with IEEE semantics in regards to NaN propagation and handling of -0.0.

Panics

When assertions are enabled, this function panics if any input is NaN.

pub fn clamp(self, min: Self, max: Self) -> Self

Clamps the components of self between the components of min and max.

This function is not consistent with IEEE semantics in regards to NaN propagation and handling of -0.0.

Panics

When assertions are enabled, this function panics if any input is NaN or if min > max.

pub fn max_element(self) -> f64

Returns the maximum component of the vector.

This function is not consistent with IEEE semantics in regards to NaN propagation and handling of -0.0.

Panics

When assertions are enabled, this function panics if any input is NaN.

pub fn min_element(self) -> f64

Returns the minimum component of the vector.

This function is not consistent with IEEE semantics in regards to NaN propagation and handling of -0.0.

Panics

When assertions are enabled, this function panics if any input is NaN.

pub fn abs(self) -> Self

Returns the absolute values of the components of self.

pub fn signum(self) -> Self

Returns the signum of the components of self.

For each component:

• 1.0 if the component is positive or +0.0.
• -1.0 if the component is negative or -0.0.
• NaN if the component is NaN.

pub fn copysign(self, sign: Self) -> Self

Returns a vector with the magnitudes of self and the signs of sign.

pub fn dot(self, rhs: Self) -> f64

Computes the dot product of self and rhs.

pub fn length_squared(self) -> f64

Computes the squared length/magnitude of self.

pub fn distance_squared(self, other: Self) -> f64

Computes the squared euclidean distance between self and other.

pub fn lerp(self, other: Self, t: f64) -> Self

Computes the linear interpolation between self and other based on the value t.

When t is 0.0, the result is self. When t is 1.0, the result is rhs. When t is outside of the range [0.0, 1.0], the result is linearly extrapolated.

pub fn midpoint(self, other: Self) -> Self

Computes the midpoint between self and other.

This function is equivalent to self.lerp(other, 0.5) but is cheaper to compute.

This function may return a slightly different value than lerp.

pub fn is_normalized(self) -> bool

Returns whether self has the length 1.0 or not.

This function uses a precision threshold of approximately 1e-4.

pub fn project_onto(self, other: Self) -> Self

Returns the vector projection of self onto other.

other must not be a zero vector.

Panics

When assertions are enabled, this function panics if other is a zero vector.

pub fn project_onto_normalized(self, other: Self) -> Self

Returns the vector projection of self onto other.

other must be normalized.

Panics

When assertions are enabled, this function panics if other is not normalized.

pub fn reject_from(self, other: Self) -> Self

Returns the vector rejection of self from other.

Vector rejection is the vector pointing from the projection to the original vector. Basically: self - self.project_onto(other).

other must not be a zero vector.

Panics

When assertions are enabled, this function panics if other is a zero vector.

pub fn reject_from_normalized(self, other: Self) -> Self

Returns the vector rejection of self from other.

Vector rejection is the vector pointing from the projection to the original vector. Basically: self - self.project_onto(other).

other must be normalized.

Panics

When assertions are enabled, this function panics if other is not normalized.

pub fn reflect(self, normal: Self) -> Self

Returns the vector reflection for self with normal.

Vector reflection is the reflection of the vector on a surface with the given normal.

normal must be normalized.

Panics

When assertions are enabled, this function panics if normal is not normalized.

impl<A: Alignment> Vector<3, f64, A>

pub fn cross(self, rhs: Self) -> Self

Computes the cross product of self and rhs.

pub fn any_orthogonal_vector(self) -> Self

Returns some vector that is orthogonal to self.

self must be finite and not a zero vector.

The output vector is not necessarily normalized. For that use Self::any_orthonormal_vector() instead.

pub fn any_orthonormal_vector(self) -> Self

Returns some unit vector that is orthogonal to self.

self must normalized.

Panics

When assertions are enabled, this function panics if self is not normalized.

pub fn any_orthonormal_pair(self) -> (Self, Self)

Returns two unit vectors that are orthogonal to self and to each other.

Together with self, they form an orthonormal basis where the three vectors are orthogonal to each other and are normalized.

Panics

When assertions are enabled, this function panics if self is not normalized.

impl<const N: usize, A: Alignment> Vector<N, f64, A>

where Length<N>: SupportedLength,

pub fn floor(self) -> Self

Rounds the components of self down.

pub fn ceil(self) -> Self

Rounds the components of self up.

pub fn round(self) -> Self

Rounds the components of self to the nearest integer.

pub fn trunc(self) -> Self

Rounds the components of self towards zero.

pub fn fract(self) -> Self

Returns the fractional part of self.

This function is equivalent to self - self.trunc().

pub fn mul_add(self, a: Self, b: Self) -> Self

Fused Multiply Add. Computes self * a + b with only one rounding error instead of two.

This is slower than an unfused multiply add for most target architectures.

This function is guaranteed to return the exact same value as the standard library.

pub fn div_euclid(self, rhs: Self) -> Self

Euclidiean Division.

This function is guaranteed to return the exact same value as the standard library.

pub fn rem_euclid(self, rhs: Self) -> Self

Euclidiean Remainder.

This function is guaranteed to return the exact same value as the standard library.

pub fn sqrt(self) -> Self

Computes the square root of the components of self.

This function is guaranteed to return the exact same value as the standard library.

pub fn sin(self) -> Self

Computes the sine of the components of self.

This function has unspecified precision and may return a different value than the standard library.

pub fn cos(self) -> Self

Computes the cosine of the components of self.

This function has unspecified precision and may return a different value than the standard library.

pub fn tan(self) -> Self

Computes the tangent of the components of self.

This function has unspecified precision and may return a different value than the standard library.

pub fn asin(self) -> Self

Computes the arc sine of the components of self.

This function has unspecified precision and may return a different value than the standard library.

pub fn acos(self) -> Self

Computes the arc cosine of the components of self.

This function has unspecified precision and may return a different value than the standard library.

pub fn atan(self) -> Self

Computes the arc tangent of the components of self.

This function has unspecified precision and may return a different value than the standard library.

pub fn sin_cos(self) -> (Self, Self)

Simultaneously computes the sine and cosine of the components of self.

This function has unspecified precision and may return a different value than the standard library.

pub fn length(self) -> f64

Returns the length/magnitude of self.

pub fn distance(self, other: Self) -> f64

Computes the euclidean distance between self and other.

pub fn move_towards(self, other: Self, max_delta: f64) -> Self

Moves self towards other by the value max_delta.

When max_delta is 0.0, the result is self. When max_delta is equal to or greater than self.distance(other), the result is other.

pub fn normalize(self) -> Self

Returns a vector with the direction of self and length 1.0.

Panics

When assertions are enabled, this function panics if the input is zero or if the result is non finite or zero.

pub fn try_normalize(self) -> Option<Self>

Computes self.normalize or returns None if the input is zero or if the result is non finite or zero.

pub fn normalize_or(self, fallback: Self) -> Self

Computes self.normalize or returns fallback if the input is zero or if the result is non finite or zero.

pub fn normalize_or_zero(self) -> Self

Computes self.normalize or returns a zero vector if the input is zero or if the result is non finite or zero.

pub fn normalize_and_length(self) -> (Self, f64)

Computes self.normalize() and self.length().

If self is a zero vector, the function returns (Self::ZERO, 0.0).

pub fn with_max_length(self, max: f64) -> Self

Returns self with a length of no more than max.

Panics

When assertions are enabled, this function panics if max is negative.

pub fn with_min_length(self, min: f64) -> Self

Returns self with a length of no less than min.

Panics

When assertions are enabled, this function panics if min is negative.

pub fn clamp_length(self, min: f64, max: f64) -> Self

Returns self with a length of no less than min and no more than max.

Panics

When assertions are enabled, this function panics if min is greater than max, or if either min or max are negative.

pub fn angle_between(self, other: Self) -> f64

Computes the angle (in radians) between two vectors in the range [0, +π].

The vectors do not need to be unit vectors but they do need to be non-zero.

This function has unspecified precision.

pub fn exp(self) -> Self

Computes the exponential function e^self for the components of self.

This function has unspecified precision and may return a different value than the standard library.

pub fn exp2(self) -> Self

Computes 2^self for the components of self.

This function has unspecified precision and may return a different value than the standard library.

pub fn ln(self) -> Self

Computes the natural logarithm for the components of self.

This function has unspecified precision and may return a different value than the standard library.

pub fn log2(self) -> Self

Computes the base 2 logarithm for the components of self.

This function has unspecified precision and may return a different value than the standard library.

pub fn powf(self, n: f64) -> Self

Computes self^n for the components of self.

This function has unspecified precision and may return a different value than the standard library.

pub fn refract(self, normal: Self, eta: f64) -> Self

Returns the vector refraction of self through normal and eta.

eta is the incident index divided by the transmitted index.

When total internal reflection occurs, this function returns a zero vector.

self and normal must be normalized.

Panics

When assertions are enabled, this function panics if self or normal are not normalized.

impl<A: Alignment> Vector<2, f64, A>

pub fn perp(self) -> Self

Returns self rotated by 90 degrees.

pub fn rotate(self, angle: f64) -> Self

Rotates self by angle (in radians).

This function has unspecified precision.

impl<A: Alignment> Vector<3, f64, A>

pub fn rotate_x(self, angle: f64) -> Self

Rotates self around the x axis by angle (in radians).

This function has unspecified precision.

pub fn rotate_y(self, angle: f64) -> Self

Rotates self around the y axis by angle (in radians).

This function has unspecified precision.

pub fn rotate_z(self, angle: f64) -> Self

Rotates self around the z axis by angle (in radians).

This function has unspecified precision.

impl<const N: usize, A: Alignment> Vector<N, i8, A>

where Length<N>: SupportedLength,

pub fn element_sum(self) -> i8

Computes the sum of the vector’s elements.

Panics

When assertions are enabled, this function panics if any addition overflows (addition is performed in order).

pub fn element_product(self) -> i8

Computes the product of the vector’s elements.

Panics

When assertions are enabled, this function panics if any multiplication overflows (multiplication is performed in order).

pub fn max(self, other: Self) -> Self

Returns the maximum between the components of self and other.

pub fn min(self, other: Self) -> Self

Returns the minimum between the components of self and other.

pub fn clamp(self, min: Self, max: Self) -> Self

Clamps the components of self between the components of min and max.

Panics

Panics if min > max.

pub fn max_element(self) -> i8

Returns the maximum out of the elements of self.

pub fn min_element(self) -> i8

Returns the minimum out of the elements of self.

pub fn abs(self) -> Self

Returns the absolute values of the components of self.

Panics

When assertions or overflow checks are enabled, this function panics if any input is T::MIN.

pub fn signum(self) -> Self

Returns the signum of the components of self.

For each component:

• 0 if the component is zero
• 1 if the component is positive
• -1 if the component is negative

pub fn dot(self, rhs: Self) -> i8

Computes the dot product of self and rhs.

Panics

When assertions or overflow checks are enabled, this function panics if an overflow occurs.

pub fn length_squared(self) -> i8

Computes the squared length/magnitude of self.

Panics

When assertions or overflow checks are enabled, this function panics if an overflow occurs.

pub fn distance_squared(self, other: Self) -> i8

Computes the squared euclidean distance between self and other.

Panics

When assertions or overflow checks are enabled, this function panics if an overflow occurs.

pub fn checked_add(self, rhs: Self) -> Option<Self>

Computes self + rhs, returning None if overflow occured.

pub fn checked_sub(self, rhs: Self) -> Option<Self>

Computes self - rhs, returning None if overflow occured.

pub fn checked_mul(self, rhs: Self) -> Option<Self>

Computes self * rhs, returning None if overflow occured.

pub fn checked_div(self, rhs: Self) -> Option<Self>

Computes self / rhs, returning None if division by zero or overflow occured.

pub fn checked_rem(self, rhs: Self) -> Option<Self>

Computes self % rhs, returning None if division by zero or overflow occurred.

pub fn saturating_add(self, rhs: Self) -> Self

Computes self + rhs, saturating at the numeric bounds instead of overflowing.

pub fn saturating_sub(self, rhs: Self) -> Self

Computes self - rhs, saturating at the numeric bounds instead of overflowing.

pub fn saturating_mul(self, rhs: Self) -> Self

Computes self * rhs, saturating at the numeric bounds instead of overflowing.

pub fn saturating_div(self, rhs: Self) -> Self

Computes self / rhs, saturating at the numeric bounds instead of overflowing.

Panics

This function will panic if rhs is zero.

pub fn wrapping_add(self, rhs: Self) -> Self

Computes self + rhs, wrapping around at the boundary of the type.

pub fn wrapping_sub(self, rhs: Self) -> Self

Computes self - rhs, wrapping around at the boundary of the type.

pub fn wrapping_mul(self, rhs: Self) -> Self

Computes self * rhs, wrapping around at the boundary of the type.

pub fn wrapping_div(self, rhs: Self) -> Self

Computes self / rhs, wrapping around at the boundary of the type.

Panics

This function will panic if rhs is zero.

pub fn wrapping_rem(self, rhs: Self) -> Self

Computes self % rhs, wrapping around at the boundary of the type.

Panics

This function will panic if rhs is zero.

impl<A: Alignment> Vector<2, i8, A>

pub fn perp(self) -> Self

Returns self rotated by 90 degrees.

impl<A: Alignment> Vector<3, i8, A>

pub fn cross(self, rhs: Self) -> Self

Computes the cross product of self and rhs.

impl<const N: usize, A: Alignment> Vector<N, i16, A>

where Length<N>: SupportedLength,

pub fn element_sum(self) -> i16

Computes the sum of the vector’s elements.

Panics

When assertions are enabled, this function panics if any addition overflows (addition is performed in order).

pub fn element_product(self) -> i16

Computes the product of the vector’s elements.

Panics

When assertions are enabled, this function panics if any multiplication overflows (multiplication is performed in order).

pub fn max(self, other: Self) -> Self

Returns the maximum between the components of self and other.

pub fn min(self, other: Self) -> Self

Returns the minimum between the components of self and other.

pub fn clamp(self, min: Self, max: Self) -> Self

Clamps the components of self between the components of min and max.

Panics

Panics if min > max.

pub fn max_element(self) -> i16

Returns the maximum out of the elements of self.

pub fn min_element(self) -> i16

Returns the minimum out of the elements of self.

pub fn abs(self) -> Self

Returns the absolute values of the components of self.

Panics

When assertions or overflow checks are enabled, this function panics if any input is T::MIN.

pub fn signum(self) -> Self

Returns the signum of the components of self.

For each component:

• 0 if the component is zero
• 1 if the component is positive
• -1 if the component is negative

pub fn dot(self, rhs: Self) -> i16

Computes the dot product of self and rhs.

Panics

When assertions or overflow checks are enabled, this function panics if an overflow occurs.

pub fn length_squared(self) -> i16

Computes the squared length/magnitude of self.

Panics

When assertions or overflow checks are enabled, this function panics if an overflow occurs.

pub fn distance_squared(self, other: Self) -> i16

Computes the squared euclidean distance between self and other.

Panics

When assertions or overflow checks are enabled, this function panics if an overflow occurs.

pub fn checked_add(self, rhs: Self) -> Option<Self>

Computes self + rhs, returning None if overflow occured.

pub fn checked_sub(self, rhs: Self) -> Option<Self>

Computes self - rhs, returning None if overflow occured.

pub fn checked_mul(self, rhs: Self) -> Option<Self>

Computes self * rhs, returning None if overflow occured.

pub fn checked_div(self, rhs: Self) -> Option<Self>

Computes self / rhs, returning None if division by zero or overflow occured.

pub fn checked_rem(self, rhs: Self) -> Option<Self>

Computes self % rhs, returning None if division by zero or overflow occurred.

pub fn saturating_add(self, rhs: Self) -> Self

Computes self + rhs, saturating at the numeric bounds instead of overflowing.

pub fn saturating_sub(self, rhs: Self) -> Self

Computes self - rhs, saturating at the numeric bounds instead of overflowing.

pub fn saturating_mul(self, rhs: Self) -> Self

Computes self * rhs, saturating at the numeric bounds instead of overflowing.

pub fn saturating_div(self, rhs: Self) -> Self

Computes self / rhs, saturating at the numeric bounds instead of overflowing.

Panics

This function will panic if rhs is zero.

pub fn wrapping_add(self, rhs: Self) -> Self

Computes self + rhs, wrapping around at the boundary of the type.

pub fn wrapping_sub(self, rhs: Self) -> Self

Computes self - rhs, wrapping around at the boundary of the type.

pub fn wrapping_mul(self, rhs: Self) -> Self

Computes self * rhs, wrapping around at the boundary of the type.

pub fn wrapping_div(self, rhs: Self) -> Self

Computes self / rhs, wrapping around at the boundary of the type.

Panics

This function will panic if rhs is zero.

pub fn wrapping_rem(self, rhs: Self) -> Self

Computes self % rhs, wrapping around at the boundary of the type.

Panics

This function will panic if rhs is zero.

impl<A: Alignment> Vector<2, i16, A>

pub fn perp(self) -> Self

Returns self rotated by 90 degrees.

impl<A: Alignment> Vector<3, i16, A>

pub fn cross(self, rhs: Self) -> Self

Computes the cross product of self and rhs.

impl<const N: usize, A: Alignment> Vector<N, i32, A>

where Length<N>: SupportedLength,

pub fn element_sum(self) -> i32

Computes the sum of the vector’s elements.

Panics

When assertions are enabled, this function panics if any addition overflows (addition is performed in order).

pub fn element_product(self) -> i32

Computes the product of the vector’s elements.

Panics

When assertions are enabled, this function panics if any multiplication overflows (multiplication is performed in order).

pub fn max(self, other: Self) -> Self

Returns the maximum between the components of self and other.

pub fn min(self, other: Self) -> Self

Returns the minimum between the components of self and other.

pub fn clamp(self, min: Self, max: Self) -> Self

Clamps the components of self between the components of min and max.

Panics

Panics if min > max.

pub fn max_element(self) -> i32

Returns the maximum out of the elements of self.

pub fn min_element(self) -> i32

Returns the minimum out of the elements of self.

pub fn abs(self) -> Self

Returns the absolute values of the components of self.

Panics

When assertions or overflow checks are enabled, this function panics if any input is T::MIN.

pub fn signum(self) -> Self

Returns the signum of the components of self.

For each component:

• 0 if the component is zero
• 1 if the component is positive
• -1 if the component is negative

pub fn dot(self, rhs: Self) -> i32

Computes the dot product of self and rhs.

Panics

When assertions or overflow checks are enabled, this function panics if an overflow occurs.

pub fn length_squared(self) -> i32

Computes the squared length/magnitude of self.

Panics

When assertions or overflow checks are enabled, this function panics if an overflow occurs.

pub fn distance_squared(self, other: Self) -> i32

Computes the squared euclidean distance between self and other.

Panics

When assertions or overflow checks are enabled, this function panics if an overflow occurs.

pub fn checked_add(self, rhs: Self) -> Option<Self>

Computes self + rhs, returning None if overflow occured.

pub fn checked_sub(self, rhs: Self) -> Option<Self>

Computes self - rhs, returning None if overflow occured.

pub fn checked_mul(self, rhs: Self) -> Option<Self>

Computes self * rhs, returning None if overflow occured.

pub fn checked_div(self, rhs: Self) -> Option<Self>

Computes self / rhs, returning None if division by zero or overflow occured.

pub fn checked_rem(self, rhs: Self) -> Option<Self>

Computes self % rhs, returning None if division by zero or overflow occurred.

pub fn saturating_add(self, rhs: Self) -> Self

Computes self + rhs, saturating at the numeric bounds instead of overflowing.

pub fn saturating_sub(self, rhs: Self) -> Self

Computes self - rhs, saturating at the numeric bounds instead of overflowing.

pub fn saturating_mul(self, rhs: Self) -> Self

Computes self * rhs, saturating at the numeric bounds instead of overflowing.

pub fn saturating_div(self, rhs: Self) -> Self

Computes self / rhs, saturating at the numeric bounds instead of overflowing.

Panics

This function will panic if rhs is zero.

pub fn wrapping_add(self, rhs: Self) -> Self

Computes self + rhs, wrapping around at the boundary of the type.

pub fn wrapping_sub(self, rhs: Self) -> Self

Computes self - rhs, wrapping around at the boundary of the type.

pub fn wrapping_mul(self, rhs: Self) -> Self

Computes self * rhs, wrapping around at the boundary of the type.

pub fn wrapping_div(self, rhs: Self) -> Self

Computes self / rhs, wrapping around at the boundary of the type.

Panics

This function will panic if rhs is zero.

pub fn wrapping_rem(self, rhs: Self) -> Self

Computes self % rhs, wrapping around at the boundary of the type.

Panics

This function will panic if rhs is zero.

impl<A: Alignment> Vector<2, i32, A>

pub fn perp(self) -> Self

Returns self rotated by 90 degrees.

impl<A: Alignment> Vector<3, i32, A>

pub fn cross(self, rhs: Self) -> Self

Computes the cross product of self and rhs.

impl<const N: usize, A: Alignment> Vector<N, i64, A>

where Length<N>: SupportedLength,

pub fn element_sum(self) -> i64

Computes the sum of the vector’s elements.

Panics

When assertions are enabled, this function panics if any addition overflows (addition is performed in order).

pub fn element_product(self) -> i64

Computes the product of the vector’s elements.

Panics

When assertions are enabled, this function panics if any multiplication overflows (multiplication is performed in order).

pub fn max(self, other: Self) -> Self

Returns the maximum between the components of self and other.

pub fn min(self, other: Self) -> Self

Returns the minimum between the components of self and other.

pub fn clamp(self, min: Self, max: Self) -> Self

Clamps the components of self between the components of min and max.

Panics

Panics if min > max.

pub fn max_element(self) -> i64

Returns the maximum out of the elements of self.

pub fn min_element(self) -> i64

Returns the minimum out of the elements of self.

pub fn abs(self) -> Self

Returns the absolute values of the components of self.

Panics

When assertions or overflow checks are enabled, this function panics if any input is T::MIN.

pub fn signum(self) -> Self

Returns the signum of the components of self.

For each component:

• 0 if the component is zero
• 1 if the component is positive
• -1 if the component is negative

pub fn dot(self, rhs: Self) -> i64

Computes the dot product of self and rhs.

Panics

When assertions or overflow checks are enabled, this function panics if an overflow occurs.

pub fn length_squared(self) -> i64

Computes the squared length/magnitude of self.

Panics

When assertions or overflow checks are enabled, this function panics if an overflow occurs.

pub fn distance_squared(self, other: Self) -> i64

Computes the squared euclidean distance between self and other.

Panics

When assertions or overflow checks are enabled, this function panics if an overflow occurs.

pub fn checked_add(self, rhs: Self) -> Option<Self>

Computes self + rhs, returning None if overflow occured.

pub fn checked_sub(self, rhs: Self) -> Option<Self>

Computes self - rhs, returning None if overflow occured.

pub fn checked_mul(self, rhs: Self) -> Option<Self>

Computes self * rhs, returning None if overflow occured.

pub fn checked_div(self, rhs: Self) -> Option<Self>

Computes self / rhs, returning None if division by zero or overflow occured.

pub fn checked_rem(self, rhs: Self) -> Option<Self>

Computes self % rhs, returning None if division by zero or overflow occurred.

pub fn saturating_add(self, rhs: Self) -> Self

Computes self + rhs, saturating at the numeric bounds instead of overflowing.

pub fn saturating_sub(self, rhs: Self) -> Self

Computes self - rhs, saturating at the numeric bounds instead of overflowing.

pub fn saturating_mul(self, rhs: Self) -> Self

Computes self * rhs, saturating at the numeric bounds instead of overflowing.

pub fn saturating_div(self, rhs: Self) -> Self

Computes self / rhs, saturating at the numeric bounds instead of overflowing.

Panics

This function will panic if rhs is zero.

pub fn wrapping_add(self, rhs: Self) -> Self

Computes self + rhs, wrapping around at the boundary of the type.

pub fn wrapping_sub(self, rhs: Self) -> Self

Computes self - rhs, wrapping around at the boundary of the type.

pub fn wrapping_mul(self, rhs: Self) -> Self

Computes self * rhs, wrapping around at the boundary of the type.

pub fn wrapping_div(self, rhs: Self) -> Self

Computes self / rhs, wrapping around at the boundary of the type.

Panics

This function will panic if rhs is zero.

pub fn wrapping_rem(self, rhs: Self) -> Self

Computes self % rhs, wrapping around at the boundary of the type.

Panics

This function will panic if rhs is zero.

impl<A: Alignment> Vector<2, i64, A>

pub fn perp(self) -> Self

Returns self rotated by 90 degrees.

impl<A: Alignment> Vector<3, i64, A>

pub fn cross(self, rhs: Self) -> Self

Computes the cross product of self and rhs.

impl<const N: usize, A: Alignment> Vector<N, i128, A>

where Length<N>: SupportedLength,

pub fn element_sum(self) -> i128

Computes the sum of the vector’s elements.

Panics

When assertions are enabled, this function panics if any addition overflows (addition is performed in order).

pub fn element_product(self) -> i128

Computes the product of the vector’s elements.

Panics

When assertions are enabled, this function panics if any multiplication overflows (multiplication is performed in order).

pub fn max(self, other: Self) -> Self

Returns the maximum between the components of self and other.

pub fn min(self, other: Self) -> Self

Returns the minimum between the components of self and other.

pub fn clamp(self, min: Self, max: Self) -> Self

Clamps the components of self between the components of min and max.

Panics

Panics if min > max.

pub fn max_element(self) -> i128

Returns the maximum out of the elements of self.

pub fn min_element(self) -> i128

Returns the minimum out of the elements of self.

pub fn abs(self) -> Self

Returns the absolute values of the components of self.

Panics

When assertions or overflow checks are enabled, this function panics if any input is T::MIN.

pub fn signum(self) -> Self

Returns the signum of the components of self.

For each component:

• 0 if the component is zero
• 1 if the component is positive
• -1 if the component is negative

pub fn dot(self, rhs: Self) -> i128

Computes the dot product of self and rhs.

Panics

When assertions or overflow checks are enabled, this function panics if an overflow occurs.

pub fn length_squared(self) -> i128

Computes the squared length/magnitude of self.

Panics

When assertions or overflow checks are enabled, this function panics if an overflow occurs.

pub fn distance_squared(self, other: Self) -> i128

Computes the squared euclidean distance between self and other.

Panics

When assertions or overflow checks are enabled, this function panics if an overflow occurs.

pub fn checked_add(self, rhs: Self) -> Option<Self>

Computes self + rhs, returning None if overflow occured.

pub fn checked_sub(self, rhs: Self) -> Option<Self>

Computes self - rhs, returning None if overflow occured.

pub fn checked_mul(self, rhs: Self) -> Option<Self>

Computes self * rhs, returning None if overflow occured.

pub fn checked_div(self, rhs: Self) -> Option<Self>

Computes self / rhs, returning None if division by zero or overflow occured.

pub fn checked_rem(self, rhs: Self) -> Option<Self>

Computes self % rhs, returning None if division by zero or overflow occurred.

pub fn saturating_add(self, rhs: Self) -> Self

Computes self + rhs, saturating at the numeric bounds instead of overflowing.

pub fn saturating_sub(self, rhs: Self) -> Self

Computes self - rhs, saturating at the numeric bounds instead of overflowing.

pub fn saturating_mul(self, rhs: Self) -> Self

Computes self * rhs, saturating at the numeric bounds instead of overflowing.

pub fn saturating_div(self, rhs: Self) -> Self

Computes self / rhs, saturating at the numeric bounds instead of overflowing.

Panics

This function will panic if rhs is zero.

pub fn wrapping_add(self, rhs: Self) -> Self

Computes self + rhs, wrapping around at the boundary of the type.

pub fn wrapping_sub(self, rhs: Self) -> Self

Computes self - rhs, wrapping around at the boundary of the type.

pub fn wrapping_mul(self, rhs: Self) -> Self

Computes self * rhs, wrapping around at the boundary of the type.

pub fn wrapping_div(self, rhs: Self) -> Self

Computes self / rhs, wrapping around at the boundary of the type.

Panics

This function will panic if rhs is zero.

pub fn wrapping_rem(self, rhs: Self) -> Self

Computes self % rhs, wrapping around at the boundary of the type.

Panics

This function will panic if rhs is zero.

impl<A: Alignment> Vector<2, i128, A>

pub fn perp(self) -> Self

Returns self rotated by 90 degrees.

impl<A: Alignment> Vector<3, i128, A>

pub fn cross(self, rhs: Self) -> Self

Computes the cross product of self and rhs.

impl<const N: usize, A: Alignment> Vector<N, isize, A>

where Length<N>: SupportedLength,

pub fn element_sum(self) -> isize

Computes the sum of the vector’s elements.

Panics

When assertions are enabled, this function panics if any addition overflows (addition is performed in order).

pub fn element_product(self) -> isize

Computes the product of the vector’s elements.

Panics

When assertions are enabled, this function panics if any multiplication overflows (multiplication is performed in order).

pub fn max(self, other: Self) -> Self

Returns the maximum between the components of self and other.

pub fn min(self, other: Self) -> Self

Returns the minimum between the components of self and other.

pub fn clamp(self, min: Self, max: Self) -> Self

Clamps the components of self between the components of min and max.

Panics

Panics if min > max.

pub fn max_element(self) -> isize

Returns the maximum out of the elements of self.

pub fn min_element(self) -> isize

Returns the minimum out of the elements of self.

pub fn abs(self) -> Self

Returns the absolute values of the components of self.

Panics

When assertions or overflow checks are enabled, this function panics if any input is T::MIN.

pub fn signum(self) -> Self

Returns the signum of the components of self.

For each component:

• 0 if the component is zero
• 1 if the component is positive
• -1 if the component is negative

pub fn dot(self, rhs: Self) -> isize

Computes the dot product of self and rhs.

Panics

When assertions or overflow checks are enabled, this function panics if an overflow occurs.

pub fn length_squared(self) -> isize

Computes the squared length/magnitude of self.

Panics

When assertions or overflow checks are enabled, this function panics if an overflow occurs.

pub fn distance_squared(self, other: Self) -> isize

Computes the squared euclidean distance between self and other.

Panics

When assertions or overflow checks are enabled, this function panics if an overflow occurs.

pub fn checked_add(self, rhs: Self) -> Option<Self>

Computes self + rhs, returning None if overflow occured.

pub fn checked_sub(self, rhs: Self) -> Option<Self>

Computes self - rhs, returning None if overflow occured.

pub fn checked_mul(self, rhs: Self) -> Option<Self>

Computes self * rhs, returning None if overflow occured.

pub fn checked_div(self, rhs: Self) -> Option<Self>

Computes self / rhs, returning None if division by zero or overflow occured.

pub fn checked_rem(self, rhs: Self) -> Option<Self>

Computes self % rhs, returning None if division by zero or overflow occurred.

pub fn saturating_add(self, rhs: Self) -> Self

Computes self + rhs, saturating at the numeric bounds instead of overflowing.

pub fn saturating_sub(self, rhs: Self) -> Self

Computes self - rhs, saturating at the numeric bounds instead of overflowing.

pub fn saturating_mul(self, rhs: Self) -> Self

Computes self * rhs, saturating at the numeric bounds instead of overflowing.

pub fn saturating_div(self, rhs: Self) -> Self

Computes self / rhs, saturating at the numeric bounds instead of overflowing.

Panics

This function will panic if rhs is zero.

pub fn wrapping_add(self, rhs: Self) -> Self

Computes self + rhs, wrapping around at the boundary of the type.

pub fn wrapping_sub(self, rhs: Self) -> Self

Computes self - rhs, wrapping around at the boundary of the type.

pub fn wrapping_mul(self, rhs: Self) -> Self

Computes self * rhs, wrapping around at the boundary of the type.

pub fn wrapping_div(self, rhs: Self) -> Self

Computes self / rhs, wrapping around at the boundary of the type.

Panics

This function will panic if rhs is zero.

pub fn wrapping_rem(self, rhs: Self) -> Self

Computes self % rhs, wrapping around at the boundary of the type.

Panics

This function will panic if rhs is zero.

impl<A: Alignment> Vector<2, isize, A>

pub fn perp(self) -> Self

Returns self rotated by 90 degrees.

impl<A: Alignment> Vector<3, isize, A>

pub fn cross(self, rhs: Self) -> Self

Computes the cross product of self and rhs.

impl<const N: usize, A: Alignment> Vector<N, u8, A>

where Length<N>: SupportedLength,

pub fn element_sum(self) -> u8

Computes the sum of the vector’s elements.

Panics

When assertions are enabled, this function panics if any addition overflows (addition is performed in order).

pub fn element_product(self) -> u8

Computes the product of the vector’s elements.

Panics

When assertions are enabled, this function panics if any multiplication overflows (multiplication is performed in order).

pub fn max(self, other: Self) -> Self

Returns the maximum between the components of self and other.

pub fn min(self, other: Self) -> Self

Returns the minimum between the components of self and other.

pub fn clamp(self, min: Self, max: Self) -> Self

Clamps the components of self between the components of min and max.

Panics

Panics if min > max.

pub fn max_element(self) -> u8

Returns the maximum out of the elements of self.

pub fn min_element(self) -> u8

Returns the minimum out of the elements of self.

pub fn dot(self, rhs: Self) -> u8

Computes the dot product of self and rhs.

Panics

When assertions or overflow checks are enabled, this function panics if an overflow occurs.

pub fn length_squared(self) -> u8

Computes the squared length/magnitude of self.

Panics

When assertions or overflow checks are enabled, this function panics if an overflow occurs.

pub fn checked_add(self, rhs: Self) -> Option<Self>

Computes self + rhs, returning None if overflow occured.

pub fn checked_sub(self, rhs: Self) -> Option<Self>

Computes self - rhs, returning None if overflow occured.

pub fn checked_mul(self, rhs: Self) -> Option<Self>

Computes self * rhs, returning None if overflow occured.

pub fn checked_div(self, rhs: Self) -> Option<Self>

Computes self / rhs, returning None if division by zero occured.

pub fn checked_rem(self, rhs: Self) -> Option<Self>

Computes self % rhs, returning None if division by zero occurred.

pub fn saturating_add(self, rhs: Self) -> Self

Computes self + rhs, saturating at the numeric bounds instead of overflowing.

pub fn saturating_sub(self, rhs: Self) -> Self

Computes self - rhs, saturating at the numeric bounds instead of overflowing.

pub fn saturating_mul(self, rhs: Self) -> Self

Computes self * rhs, saturating at the numeric bounds instead of overflowing.

pub fn wrapping_add(self, rhs: Self) -> Self

Computes self + rhs, wrapping around at the boundary of the type.

pub fn wrapping_sub(self, rhs: Self) -> Self

Computes self - rhs, wrapping around at the boundary of the type.

pub fn wrapping_mul(self, rhs: Self) -> Self

Computes self * rhs, wrapping around at the boundary of the type.

impl<const N: usize, A: Alignment> Vector<N, u16, A>

where Length<N>: SupportedLength,

pub fn element_sum(self) -> u16

Computes the sum of the vector’s elements.

Panics

When assertions are enabled, this function panics if any addition overflows (addition is performed in order).

pub fn element_product(self) -> u16

Computes the product of the vector’s elements.

Panics

When assertions are enabled, this function panics if any multiplication overflows (multiplication is performed in order).

pub fn max(self, other: Self) -> Self

Returns the maximum between the components of self and other.

pub fn min(self, other: Self) -> Self

Returns the minimum between the components of self and other.

pub fn clamp(self, min: Self, max: Self) -> Self

Clamps the components of self between the components of min and max.

Panics

Panics if min > max.

pub fn max_element(self) -> u16

Returns the maximum out of the elements of self.

pub fn min_element(self) -> u16

Returns the minimum out of the elements of self.

pub fn dot(self, rhs: Self) -> u16

Computes the dot product of self and rhs.

Panics

When assertions or overflow checks are enabled, this function panics if an overflow occurs.

pub fn length_squared(self) -> u16

Computes the squared length/magnitude of self.

Panics

When assertions or overflow checks are enabled, this function panics if an overflow occurs.

pub fn checked_add(self, rhs: Self) -> Option<Self>

Computes self + rhs, returning None if overflow occured.

pub fn checked_sub(self, rhs: Self) -> Option<Self>

Computes self - rhs, returning None if overflow occured.

pub fn checked_mul(self, rhs: Self) -> Option<Self>

Computes self * rhs, returning None if overflow occured.

pub fn checked_div(self, rhs: Self) -> Option<Self>

Computes self / rhs, returning None if division by zero occured.

pub fn checked_rem(self, rhs: Self) -> Option<Self>

Computes self % rhs, returning None if division by zero occurred.

pub fn saturating_add(self, rhs: Self) -> Self

Computes self + rhs, saturating at the numeric bounds instead of overflowing.

pub fn saturating_sub(self, rhs: Self) -> Self

Computes self - rhs, saturating at the numeric bounds instead of overflowing.

pub fn saturating_mul(self, rhs: Self) -> Self

Computes self * rhs, saturating at the numeric bounds instead of overflowing.

pub fn wrapping_add(self, rhs: Self) -> Self

Computes self + rhs, wrapping around at the boundary of the type.

pub fn wrapping_sub(self, rhs: Self) -> Self

Computes self - rhs, wrapping around at the boundary of the type.

pub fn wrapping_mul(self, rhs: Self) -> Self

Computes self * rhs, wrapping around at the boundary of the type.

impl<const N: usize, A: Alignment> Vector<N, u32, A>

where Length<N>: SupportedLength,

pub fn element_sum(self) -> u32

Computes the sum of the vector’s elements.

Panics

When assertions are enabled, this function panics if any addition overflows (addition is performed in order).

pub fn element_product(self) -> u32

Computes the product of the vector’s elements.

Panics

When assertions are enabled, this function panics if any multiplication overflows (multiplication is performed in order).

pub fn max(self, other: Self) -> Self

Returns the maximum between the components of self and other.

pub fn min(self, other: Self) -> Self

Returns the minimum between the components of self and other.

pub fn clamp(self, min: Self, max: Self) -> Self

Clamps the components of self between the components of min and max.

Panics

Panics if min > max.

pub fn max_element(self) -> u32

Returns the maximum out of the elements of self.

pub fn min_element(self) -> u32

Returns the minimum out of the elements of self.

pub fn dot(self, rhs: Self) -> u32

Computes the dot product of self and rhs.

Panics

When assertions or overflow checks are enabled, this function panics if an overflow occurs.

pub fn length_squared(self) -> u32

Computes the squared length/magnitude of self.

Panics

When assertions or overflow checks are enabled, this function panics if an overflow occurs.

pub fn checked_add(self, rhs: Self) -> Option<Self>

Computes self + rhs, returning None if overflow occured.

pub fn checked_sub(self, rhs: Self) -> Option<Self>

Computes self - rhs, returning None if overflow occured.

pub fn checked_mul(self, rhs: Self) -> Option<Self>

Computes self * rhs, returning None if overflow occured.

pub fn checked_div(self, rhs: Self) -> Option<Self>

Computes self / rhs, returning None if division by zero occured.

pub fn checked_rem(self, rhs: Self) -> Option<Self>

Computes self % rhs, returning None if division by zero occurred.

pub fn saturating_add(self, rhs: Self) -> Self

Computes self + rhs, saturating at the numeric bounds instead of overflowing.

pub fn saturating_sub(self, rhs: Self) -> Self

Computes self - rhs, saturating at the numeric bounds instead of overflowing.

pub fn saturating_mul(self, rhs: Self) -> Self

Computes self * rhs, saturating at the numeric bounds instead of overflowing.

pub fn wrapping_add(self, rhs: Self) -> Self

Computes self + rhs, wrapping around at the boundary of the type.

pub fn wrapping_sub(self, rhs: Self) -> Self

Computes self - rhs, wrapping around at the boundary of the type.

pub fn wrapping_mul(self, rhs: Self) -> Self

Computes self * rhs, wrapping around at the boundary of the type.

impl<const N: usize, A: Alignment> Vector<N, u64, A>

where Length<N>: SupportedLength,

pub fn element_sum(self) -> u64

Computes the sum of the vector’s elements.

Panics

When assertions are enabled, this function panics if any addition overflows (addition is performed in order).

pub fn element_product(self) -> u64

Computes the product of the vector’s elements.

Panics

When assertions are enabled, this function panics if any multiplication overflows (multiplication is performed in order).

pub fn max(self, other: Self) -> Self

Returns the maximum between the components of self and other.

pub fn min(self, other: Self) -> Self

Returns the minimum between the components of self and other.

pub fn clamp(self, min: Self, max: Self) -> Self

Clamps the components of self between the components of min and max.

Panics

Panics if min > max.

pub fn max_element(self) -> u64

Returns the maximum out of the elements of self.

pub fn min_element(self) -> u64

Returns the minimum out of the elements of self.

pub fn dot(self, rhs: Self) -> u64

Computes the dot product of self and rhs.

Panics

When assertions or overflow checks are enabled, this function panics if an overflow occurs.

pub fn length_squared(self) -> u64

Computes the squared length/magnitude of self.

Panics

When assertions or overflow checks are enabled, this function panics if an overflow occurs.

pub fn checked_add(self, rhs: Self) -> Option<Self>

Computes self + rhs, returning None if overflow occured.

pub fn checked_sub(self, rhs: Self) -> Option<Self>

Computes self - rhs, returning None if overflow occured.

pub fn checked_mul(self, rhs: Self) -> Option<Self>

Computes self * rhs, returning None if overflow occured.

pub fn checked_div(self, rhs: Self) -> Option<Self>

Computes self / rhs, returning None if division by zero occured.

pub fn checked_rem(self, rhs: Self) -> Option<Self>

Computes self % rhs, returning None if division by zero occurred.

pub fn saturating_add(self, rhs: Self) -> Self

Computes self + rhs, saturating at the numeric bounds instead of overflowing.

pub fn saturating_sub(self, rhs: Self) -> Self

Computes self - rhs, saturating at the numeric bounds instead of overflowing.

pub fn saturating_mul(self, rhs: Self) -> Self

Computes self * rhs, saturating at the numeric bounds instead of overflowing.

pub fn wrapping_add(self, rhs: Self) -> Self

Computes self + rhs, wrapping around at the boundary of the type.

pub fn wrapping_sub(self, rhs: Self) -> Self

Computes self - rhs, wrapping around at the boundary of the type.

pub fn wrapping_mul(self, rhs: Self) -> Self

Computes self * rhs, wrapping around at the boundary of the type.

impl<const N: usize, A: Alignment> Vector<N, u128, A>

where Length<N>: SupportedLength,

pub fn element_sum(self) -> u128

Computes the sum of the vector’s elements.

Panics

When assertions are enabled, this function panics if any addition overflows (addition is performed in order).

pub fn element_product(self) -> u128

Computes the product of the vector’s elements.

Panics

When assertions are enabled, this function panics if any multiplication overflows (multiplication is performed in order).

pub fn max(self, other: Self) -> Self

Returns the maximum between the components of self and other.

pub fn min(self, other: Self) -> Self

Returns the minimum between the components of self and other.

pub fn clamp(self, min: Self, max: Self) -> Self

Clamps the components of self between the components of min and max.

Panics

Panics if min > max.

pub fn max_element(self) -> u128

Returns the maximum out of the elements of self.

pub fn min_element(self) -> u128

Returns the minimum out of the elements of self.

pub fn dot(self, rhs: Self) -> u128

Computes the dot product of self and rhs.

Panics

When assertions or overflow checks are enabled, this function panics if an overflow occurs.

pub fn length_squared(self) -> u128

Computes the squared length/magnitude of self.

Panics

When assertions or overflow checks are enabled, this function panics if an overflow occurs.

pub fn checked_add(self, rhs: Self) -> Option<Self>

Computes self + rhs, returning None if overflow occured.

pub fn checked_sub(self, rhs: Self) -> Option<Self>

Computes self - rhs, returning None if overflow occured.

pub fn checked_mul(self, rhs: Self) -> Option<Self>

Computes self * rhs, returning None if overflow occured.

pub fn checked_div(self, rhs: Self) -> Option<Self>

Computes self / rhs, returning None if division by zero occured.

pub fn checked_rem(self, rhs: Self) -> Option<Self>

Computes self % rhs, returning None if division by zero occurred.

pub fn saturating_add(self, rhs: Self) -> Self

Computes self + rhs, saturating at the numeric bounds instead of overflowing.

pub fn saturating_sub(self, rhs: Self) -> Self

Computes self - rhs, saturating at the numeric bounds instead of overflowing.

pub fn saturating_mul(self, rhs: Self) -> Self

Computes self * rhs, saturating at the numeric bounds instead of overflowing.

pub fn wrapping_add(self, rhs: Self) -> Self

Computes self + rhs, wrapping around at the boundary of the type.

pub fn wrapping_sub(self, rhs: Self) -> Self

Computes self - rhs, wrapping around at the boundary of the type.

pub fn wrapping_mul(self, rhs: Self) -> Self

Computes self * rhs, wrapping around at the boundary of the type.

impl<const N: usize, A: Alignment> Vector<N, usize, A>

where Length<N>: SupportedLength,

pub fn element_sum(self) -> usize

Computes the sum of the vector’s elements.

Panics

When assertions are enabled, this function panics if any addition overflows (addition is performed in order).

pub fn element_product(self) -> usize

Computes the product of the vector’s elements.

Panics

When assertions are enabled, this function panics if any multiplication overflows (multiplication is performed in order).

pub fn max(self, other: Self) -> Self

Returns the maximum between the components of self and other.

pub fn min(self, other: Self) -> Self

Returns the minimum between the components of self and other.

pub fn clamp(self, min: Self, max: Self) -> Self

Clamps the components of self between the components of min and max.

Panics

Panics if min > max.

pub fn max_element(self) -> usize

Returns the maximum out of the elements of self.

pub fn min_element(self) -> usize

Returns the minimum out of the elements of self.

pub fn dot(self, rhs: Self) -> usize

Computes the dot product of self and rhs.

Panics

When assertions or overflow checks are enabled, this function panics if an overflow occurs.

pub fn length_squared(self) -> usize

Computes the squared length/magnitude of self.

Panics

When assertions or overflow checks are enabled, this function panics if an overflow occurs.

pub fn checked_add(self, rhs: Self) -> Option<Self>

Computes self + rhs, returning None if overflow occured.

pub fn checked_sub(self, rhs: Self) -> Option<Self>

Computes self - rhs, returning None if overflow occured.

pub fn checked_mul(self, rhs: Self) -> Option<Self>

Computes self * rhs, returning None if overflow occured.

pub fn checked_div(self, rhs: Self) -> Option<Self>

Computes self / rhs, returning None if division by zero occured.

pub fn checked_rem(self, rhs: Self) -> Option<Self>

Computes self % rhs, returning None if division by zero occurred.

pub fn saturating_add(self, rhs: Self) -> Self

Computes self + rhs, saturating at the numeric bounds instead of overflowing.

pub fn saturating_sub(self, rhs: Self) -> Self

Computes self - rhs, saturating at the numeric bounds instead of overflowing.

pub fn saturating_mul(self, rhs: Self) -> Self

Computes self * rhs, saturating at the numeric bounds instead of overflowing.

pub fn wrapping_add(self, rhs: Self) -> Self

Computes self + rhs, wrapping around at the boundary of the type.

pub fn wrapping_sub(self, rhs: Self) -> Self

Computes self - rhs, wrapping around at the boundary of the type.

pub fn wrapping_mul(self, rhs: Self) -> Self

Computes self * rhs, wrapping around at the boundary of the type.

impl<const N: usize, A: Alignment> Vector<N, bool, A>

where Length<N>: SupportedLength,

pub fn all(self) -> bool

Returns true if all components are true.

pub fn any(self) -> bool

Returns true if any component is true.

pub fn select<T: Scalar>( self, if_true: Vector<N, T, A>, if_false: Vector<N, T, A>, ) -> Vector<N, T, A>

Selects elements from if_true and if_false based on the values of the vector.

impl<const N: usize, T, A: Alignment> Vector<N, T, A>

where T: Scalar + Zero, Length<N>: SupportedLength,

pub const ZERO: Self

0.

impl<const N: usize, T, A: Alignment> Vector<N, T, A>

where T: Scalar + One, Length<N>: SupportedLength,

pub const ONE: Self

All 1.

impl<const N: usize, T, A: Alignment> Vector<N, T, A>

where T: Scalar + NegOne, Length<N>: SupportedLength,

pub const NEG_ONE: Self

All -1.

impl<const N: usize, T, A: Alignment> Vector<N, T, A>

where T: Scalar + Min, Length<N>: SupportedLength,

pub const MIN: Self

The minimum value representable by T for all elements.

impl<const N: usize, T, A: Alignment> Vector<N, T, A>

where T: Scalar + Max, Length<N>: SupportedLength,

pub const MAX: Self

The maximum value representable by T for all elements.

impl<const N: usize, T, A: Alignment> Vector<N, T, A>

where T: Scalar + NaN, Length<N>: SupportedLength,

pub const NAN: Self

All elements set to Not a Number (NaN).

impl<const N: usize, T, A: Alignment> Vector<N, T, A>

where T: Scalar + Infinity, Length<N>: SupportedLength,

pub const INFINITY: Self

All elements set to Infinity (∞).

impl<const N: usize, T, A: Alignment> Vector<N, T, A>

where T: Scalar + NegInfinity, Length<N>: SupportedLength,

pub const NEG_INFINITY: Self

All elements set to Negative Infinity (-∞).

impl<const N: usize, T, A: Alignment> Vector<N, T, A>

where T: Scalar + True, Length<N>: SupportedLength,

pub const TRUE: Self

All true.

impl<const N: usize, T, A: Alignment> Vector<N, T, A>

where T: Scalar + False, Length<N>: SupportedLength,

pub const FALSE: Self

All false.

impl<T, A: Alignment> Vector<2, T, A>

where T: Scalar + Zero + One,

pub const X: Self

(1, 0).

pub const Y: Self

(0, 1).

impl<T, A: Alignment> Vector<3, T, A>

where T: Scalar + Zero + One,

pub const X: Self

(1, 0, 0).

pub const Y: Self

(0, 1, 0).

pub const Z: Self

(0, 0, 1).

impl<T, A: Alignment> Vector<4, T, A>

where T: Scalar + Zero + One,

pub const X: Self

(1, 0, 0, 0).

pub const Y: Self

(0, 1, 0, 0).

pub const Z: Self

(0, 0, 1, 0).

pub const W: Self

(0, 0, 0, 1).

impl<T, A: Alignment> Vector<2, T, A>

where T: Scalar + Zero + NegOne,

pub const NEG_X: Self

(-1, 0).

pub const NEG_Y: Self

(0, -1).

impl<T, A: Alignment> Vector<3, T, A>

where T: Scalar + Zero + NegOne,

pub const NEG_X: Self

(-1, 0, 0).

pub const NEG_Y: Self

(0, -1, 0).

pub const NEG_Z: Self

(0, 0, -1).

impl<T, A: Alignment> Vector<4, T, A>

where T: Scalar + Zero + NegOne,

pub const NEG_X: Self

(-1, 0, 0, 0).

pub const NEG_Y: Self

(0, -1, 0, 0).

pub const NEG_Z: Self

(0, 0, -1, 0).

pub const NEG_W: Self

(0, 0, 0, -1).

impl<T, A: Alignment> Vector<2, T, A>

where T: Scalar,

pub fn xx(self) -> Vector<2, T, A>

Returns (self.x, self.x).

pub fn xy(self) -> Vector<2, T, A>

Returns (self.x, self.y).

pub fn yx(self) -> Vector<2, T, A>

Returns (self.y, self.x).

pub fn yy(self) -> Vector<2, T, A>

Returns (self.y, self.y).

pub fn xxx(self) -> Vector<3, T, A>

Returns (self.x, self.x, self.x).

pub fn xxy(self) -> Vector<3, T, A>

Returns (self.x, self.x, self.y).

pub fn xyx(self) -> Vector<3, T, A>

Returns (self.x, self.y, self.x).

pub fn xyy(self) -> Vector<3, T, A>

Returns (self.x, self.y, self.y).

pub fn yxx(self) -> Vector<3, T, A>

Returns (self.y, self.x, self.x).

pub fn yxy(self) -> Vector<3, T, A>

Returns (self.y, self.x, self.y).

pub fn yyx(self) -> Vector<3, T, A>

Returns (self.y, self.y, self.x).

pub fn yyy(self) -> Vector<3, T, A>

Returns (self.y, self.y, self.y).

pub fn xxxx(self) -> Vector<4, T, A>

Returns (self.x, self.x, self.x, self.x).

pub fn xxxy(self) -> Vector<4, T, A>

Returns (self.x, self.x, self.x, self.y).

pub fn xxyx(self) -> Vector<4, T, A>

Returns (self.x, self.x, self.y, self.x).

pub fn xxyy(self) -> Vector<4, T, A>

Returns (self.x, self.x, self.y, self.y).

pub fn xyxx(self) -> Vector<4, T, A>

Returns (self.x, self.y, self.x, self.x).

pub fn xyxy(self) -> Vector<4, T, A>

Returns (self.x, self.y, self.x, self.y).

pub fn xyyx(self) -> Vector<4, T, A>

Returns (self.x, self.y, self.y, self.x).

pub fn xyyy(self) -> Vector<4, T, A>

Returns (self.x, self.y, self.y, self.y).

pub fn yxxx(self) -> Vector<4, T, A>

Returns (self.y, self.x, self.x, self.x).

pub fn yxxy(self) -> Vector<4, T, A>

Returns (self.y, self.x, self.x, self.y).

pub fn yxyx(self) -> Vector<4, T, A>

Returns (self.y, self.x, self.y, self.x).

pub fn yxyy(self) -> Vector<4, T, A>

Returns (self.y, self.x, self.y, self.y).

pub fn yyxx(self) -> Vector<4, T, A>

Returns (self.y, self.y, self.x, self.x).

pub fn yyxy(self) -> Vector<4, T, A>

Returns (self.y, self.y, self.x, self.y).

pub fn yyyx(self) -> Vector<4, T, A>

Returns (self.y, self.y, self.y, self.x).

pub fn yyyy(self) -> Vector<4, T, A>

Returns (self.y, self.y, self.y, self.y).

pub fn with_x(self, value: T) -> Self

Returns the vector with the x component set to the given value.

pub fn with_y(self, value: T) -> Self

Returns the vector with the y component set to the given value.

pub fn with_xy(self, value: Vector<2, T, A>) -> Self

Returns the vector with the x and y components set to the given values.

pub fn with_yx(self, value: Vector<2, T, A>) -> Self

Returns the vector with the y and x components set to the given values.

impl<T, A: Alignment> Vector<3, T, A>

where T: Scalar,

pub fn xx(self) -> Vector<2, T, A>

Returns (self.x, self.x).

pub fn xy(self) -> Vector<2, T, A>

Returns (self.x, self.y).

pub fn xz(self) -> Vector<2, T, A>

Returns (self.x, self.z).

pub fn yx(self) -> Vector<2, T, A>

Returns (self.y, self.x).

pub fn yy(self) -> Vector<2, T, A>

Returns (self.y, self.y).

pub fn yz(self) -> Vector<2, T, A>

Returns (self.y, self.z).

pub fn zx(self) -> Vector<2, T, A>

Returns (self.z, self.x).

pub fn zy(self) -> Vector<2, T, A>

Returns (self.z, self.y).

pub fn zz(self) -> Vector<2, T, A>

Returns (self.z, self.z).

pub fn xxx(self) -> Vector<3, T, A>

Returns (self.x, self.x, self.x).

pub fn xxy(self) -> Vector<3, T, A>

Returns (self.x, self.x, self.y).

pub fn xxz(self) -> Vector<3, T, A>

Returns (self.x, self.x, self.z).

pub fn xyx(self) -> Vector<3, T, A>

Returns (self.x, self.y, self.x).

pub fn xyy(self) -> Vector<3, T, A>

Returns (self.x, self.y, self.y).

pub fn xyz(self) -> Vector<3, T, A>

Returns (self.x, self.y, self.z).

pub fn xzx(self) -> Vector<3, T, A>

Returns (self.x, self.z, self.x).

pub fn xzy(self) -> Vector<3, T, A>

Returns (self.x, self.z, self.y).

pub fn xzz(self) -> Vector<3, T, A>

Returns (self.x, self.z, self.z).

pub fn yxx(self) -> Vector<3, T, A>

Returns (self.y, self.x, self.x).

pub fn yxy(self) -> Vector<3, T, A>

Returns (self.y, self.x, self.y).

pub fn yxz(self) -> Vector<3, T, A>

Returns (self.y, self.x, self.z).

pub fn yyx(self) -> Vector<3, T, A>

Returns (self.y, self.y, self.x).

pub fn yyy(self) -> Vector<3, T, A>

Returns (self.y, self.y, self.y).

pub fn yyz(self) -> Vector<3, T, A>

Returns (self.y, self.y, self.z).

pub fn yzx(self) -> Vector<3, T, A>

Returns (self.y, self.z, self.x).

pub fn yzy(self) -> Vector<3, T, A>

Returns (self.y, self.z, self.y).

pub fn yzz(self) -> Vector<3, T, A>

Returns (self.y, self.z, self.z).

pub fn zxx(self) -> Vector<3, T, A>

Returns (self.z, self.x, self.x).

pub fn zxy(self) -> Vector<3, T, A>

Returns (self.z, self.x, self.y).

pub fn zxz(self) -> Vector<3, T, A>

Returns (self.z, self.x, self.z).

pub fn zyx(self) -> Vector<3, T, A>

Returns (self.z, self.y, self.x).

pub fn zyy(self) -> Vector<3, T, A>

Returns (self.z, self.y, self.y).

pub fn zyz(self) -> Vector<3, T, A>

Returns (self.z, self.y, self.z).

pub fn zzx(self) -> Vector<3, T, A>

Returns (self.z, self.z, self.x).

pub fn zzy(self) -> Vector<3, T, A>

Returns (self.z, self.z, self.y).

pub fn zzz(self) -> Vector<3, T, A>

Returns (self.z, self.z, self.z).

pub fn xxxx(self) -> Vector<4, T, A>

Returns (self.x, self.x, self.x, self.x).

pub fn xxxy(self) -> Vector<4, T, A>

Returns (self.x, self.x, self.x, self.y).

pub fn xxxz(self) -> Vector<4, T, A>

Returns (self.x, self.x, self.x, self.z).

pub fn xxyx(self) -> Vector<4, T, A>

Returns (self.x, self.x, self.y, self.x).

pub fn xxyy(self) -> Vector<4, T, A>

Returns (self.x, self.x, self.y, self.y).

pub fn xxyz(self) -> Vector<4, T, A>

Returns (self.x, self.x, self.y, self.z).

pub fn xxzx(self) -> Vector<4, T, A>

Returns (self.x, self.x, self.z, self.x).

pub fn xxzy(self) -> Vector<4, T, A>

Returns (self.x, self.x, self.z, self.y).

pub fn xxzz(self) -> Vector<4, T, A>

Returns (self.x, self.x, self.z, self.z).

pub fn xyxx(self) -> Vector<4, T, A>

Returns (self.x, self.y, self.x, self.x).

pub fn xyxy(self) -> Vector<4, T, A>

Returns (self.x, self.y, self.x, self.y).

pub fn xyxz(self) -> Vector<4, T, A>

Returns (self.x, self.y, self.x, self.z).

pub fn xyyx(self) -> Vector<4, T, A>

Returns (self.x, self.y, self.y, self.x).

pub fn xyyy(self) -> Vector<4, T, A>

Returns (self.x, self.y, self.y, self.y).

pub fn xyyz(self) -> Vector<4, T, A>

Returns (self.x, self.y, self.y, self.z).

pub fn xyzx(self) -> Vector<4, T, A>

Returns (self.x, self.y, self.z, self.x).

pub fn xyzy(self) -> Vector<4, T, A>

Returns (self.x, self.y, self.z, self.y).

pub fn xyzz(self) -> Vector<4, T, A>

Returns (self.x, self.y, self.z, self.z).

pub fn xzxx(self) -> Vector<4, T, A>

Returns (self.x, self.z, self.x, self.x).

pub fn xzxy(self) -> Vector<4, T, A>

Returns (self.x, self.z, self.x, self.y).

pub fn xzxz(self) -> Vector<4, T, A>

Returns (self.x, self.z, self.x, self.z).

pub fn xzyx(self) -> Vector<4, T, A>

Returns (self.x, self.z, self.y, self.x).

pub fn xzyy(self) -> Vector<4, T, A>

Returns (self.x, self.z, self.y, self.y).

pub fn xzyz(self) -> Vector<4, T, A>

Returns (self.x, self.z, self.y, self.z).

pub fn xzzx(self) -> Vector<4, T, A>

Returns (self.x, self.z, self.z, self.x).

pub fn xzzy(self) -> Vector<4, T, A>

Returns (self.x, self.z, self.z, self.y).

pub fn xzzz(self) -> Vector<4, T, A>

Returns (self.x, self.z, self.z, self.z).

pub fn yxxx(self) -> Vector<4, T, A>

Returns (self.y, self.x, self.x, self.x).

pub fn yxxy(self) -> Vector<4, T, A>

Returns (self.y, self.x, self.x, self.y).

pub fn yxxz(self) -> Vector<4, T, A>

Returns (self.y, self.x, self.x, self.z).

pub fn yxyx(self) -> Vector<4, T, A>

Returns (self.y, self.x, self.y, self.x).

pub fn yxyy(self) -> Vector<4, T, A>

Returns (self.y, self.x, self.y, self.y).

pub fn yxyz(self) -> Vector<4, T, A>

Returns (self.y, self.x, self.y, self.z).

pub fn yxzx(self) -> Vector<4, T, A>

Returns (self.y, self.x, self.z, self.x).

pub fn yxzy(self) -> Vector<4, T, A>

Returns (self.y, self.x, self.z, self.y).

pub fn yxzz(self) -> Vector<4, T, A>

Returns (self.y, self.x, self.z, self.z).

pub fn yyxx(self) -> Vector<4, T, A>

Returns (self.y, self.y, self.x, self.x).

pub fn yyxy(self) -> Vector<4, T, A>

Returns (self.y, self.y, self.x, self.y).

pub fn yyxz(self) -> Vector<4, T, A>

Returns (self.y, self.y, self.x, self.z).

pub fn yyyx(self) -> Vector<4, T, A>

Returns (self.y, self.y, self.y, self.x).

pub fn yyyy(self) -> Vector<4, T, A>

Returns (self.y, self.y, self.y, self.y).

pub fn yyyz(self) -> Vector<4, T, A>

Returns (self.y, self.y, self.y, self.z).

pub fn yyzx(self) -> Vector<4, T, A>

Returns (self.y, self.y, self.z, self.x).

pub fn yyzy(self) -> Vector<4, T, A>

Returns (self.y, self.y, self.z, self.y).

pub fn yyzz(self) -> Vector<4, T, A>

Returns (self.y, self.y, self.z, self.z).

pub fn yzxx(self) -> Vector<4, T, A>

Returns (self.y, self.z, self.x, self.x).

pub fn yzxy(self) -> Vector<4, T, A>

Returns (self.y, self.z, self.x, self.y).

pub fn yzxz(self) -> Vector<4, T, A>

Returns (self.y, self.z, self.x, self.z).

pub fn yzyx(self) -> Vector<4, T, A>

Returns (self.y, self.z, self.y, self.x).

pub fn yzyy(self) -> Vector<4, T, A>

Returns (self.y, self.z, self.y, self.y).

pub fn yzyz(self) -> Vector<4, T, A>

Returns (self.y, self.z, self.y, self.z).

pub fn yzzx(self) -> Vector<4, T, A>

Returns (self.y, self.z, self.z, self.x).

pub fn yzzy(self) -> Vector<4, T, A>

Returns (self.y, self.z, self.z, self.y).

pub fn yzzz(self) -> Vector<4, T, A>

Returns (self.y, self.z, self.z, self.z).

pub fn zxxx(self) -> Vector<4, T, A>

Returns (self.z, self.x, self.x, self.x).

pub fn zxxy(self) -> Vector<4, T, A>

Returns (self.z, self.x, self.x, self.y).

pub fn zxxz(self) -> Vector<4, T, A>

Returns (self.z, self.x, self.x, self.z).

pub fn zxyx(self) -> Vector<4, T, A>

Returns (self.z, self.x, self.y, self.x).

pub fn zxyy(self) -> Vector<4, T, A>

Returns (self.z, self.x, self.y, self.y).

pub fn zxyz(self) -> Vector<4, T, A>

Returns (self.z, self.x, self.y, self.z).

pub fn zxzx(self) -> Vector<4, T, A>

Returns (self.z, self.x, self.z, self.x).

pub fn zxzy(self) -> Vector<4, T, A>

Returns (self.z, self.x, self.z, self.y).

pub fn zxzz(self) -> Vector<4, T, A>

Returns (self.z, self.x, self.z, self.z).

pub fn zyxx(self) -> Vector<4, T, A>

Returns (self.z, self.y, self.x, self.x).

pub fn zyxy(self) -> Vector<4, T, A>

Returns (self.z, self.y, self.x, self.y).

pub fn zyxz(self) -> Vector<4, T, A>

Returns (self.z, self.y, self.x, self.z).

pub fn zyyx(self) -> Vector<4, T, A>

Returns (self.z, self.y, self.y, self.x).

pub fn zyyy(self) -> Vector<4, T, A>

Returns (self.z, self.y, self.y, self.y).

pub fn zyyz(self) -> Vector<4, T, A>

Returns (self.z, self.y, self.y, self.z).

pub fn zyzx(self) -> Vector<4, T, A>

Returns (self.z, self.y, self.z, self.x).

pub fn zyzy(self) -> Vector<4, T, A>

Returns (self.z, self.y, self.z, self.y).

pub fn zyzz(self) -> Vector<4, T, A>

Returns (self.z, self.y, self.z, self.z).

pub fn zzxx(self) -> Vector<4, T, A>

Returns (self.z, self.z, self.x, self.x).

pub fn zzxy(self) -> Vector<4, T, A>

Returns (self.z, self.z, self.x, self.y).

pub fn zzxz(self) -> Vector<4, T, A>

Returns (self.z, self.z, self.x, self.z).

pub fn zzyx(self) -> Vector<4, T, A>

Returns (self.z, self.z, self.y, self.x).

pub fn zzyy(self) -> Vector<4, T, A>

Returns (self.z, self.z, self.y, self.y).

pub fn zzyz(self) -> Vector<4, T, A>

Returns (self.z, self.z, self.y, self.z).

pub fn zzzx(self) -> Vector<4, T, A>

Returns (self.z, self.z, self.z, self.x).

pub fn zzzy(self) -> Vector<4, T, A>

Returns (self.z, self.z, self.z, self.y).

pub fn zzzz(self) -> Vector<4, T, A>

Returns (self.z, self.z, self.z, self.z).

pub fn with_x(self, value: T) -> Self

Returns the vector with the x component set to the given value.

pub fn with_y(self, value: T) -> Self

Returns the vector with the y component set to the given value.

pub fn with_z(self, value: T) -> Self

Returns the vector with the z component set to the given value.

pub fn with_xy(self, value: Vector<2, T, A>) -> Self

Returns the vector with the x and y components set to the given values.

pub fn with_xz(self, value: Vector<2, T, A>) -> Self

Returns the vector with the x and z components set to the given values.

pub fn with_yx(self, value: Vector<2, T, A>) -> Self

Returns the vector with the y and x components set to the given values.

pub fn with_yz(self, value: Vector<2, T, A>) -> Self

Returns the vector with the y and z components set to the given values.

pub fn with_zx(self, value: Vector<2, T, A>) -> Self

Returns the vector with the z and x components set to the given values.

pub fn with_zy(self, value: Vector<2, T, A>) -> Self

Returns the vector with the z and y components set to the given values.

pub fn with_xyz(self, value: Vector<3, T, A>) -> Self

Returns the vector with the x, y and z components set to the given values.

pub fn with_xzy(self, value: Vector<3, T, A>) -> Self

Returns the vector with the x, z and y components set to the given values.

pub fn with_yxz(self, value: Vector<3, T, A>) -> Self

Returns the vector with the y, x and z components set to the given values.

pub fn with_yzx(self, value: Vector<3, T, A>) -> Self

Returns the vector with the y, z and x components set to the given values.

pub fn with_zxy(self, value: Vector<3, T, A>) -> Self

Returns the vector with the z, x and y components set to the given values.

pub fn with_zyx(self, value: Vector<3, T, A>) -> Self

Returns the vector with the z, y and x components set to the given values.

impl<T, A: Alignment> Vector<4, T, A>

where T: Scalar,

pub fn xx(self) -> Vector<2, T, A>

Returns (self.x, self.x).

pub fn xy(self) -> Vector<2, T, A>

Returns (self.x, self.y).

pub fn xz(self) -> Vector<2, T, A>

Returns (self.x, self.z).

pub fn xw(self) -> Vector<2, T, A>

Returns (self.x, self.w).

pub fn yx(self) -> Vector<2, T, A>

Returns (self.y, self.x).

pub fn yy(self) -> Vector<2, T, A>

Returns (self.y, self.y).

pub fn yz(self) -> Vector<2, T, A>

Returns (self.y, self.z).

pub fn yw(self) -> Vector<2, T, A>

Returns (self.y, self.w).

pub fn zx(self) -> Vector<2, T, A>

Returns (self.z, self.x).

pub fn zy(self) -> Vector<2, T, A>

Returns (self.z, self.y).

pub fn zz(self) -> Vector<2, T, A>

Returns (self.z, self.z).

pub fn zw(self) -> Vector<2, T, A>

Returns (self.z, self.w).

pub fn wx(self) -> Vector<2, T, A>

Returns (self.w, self.x).

pub fn wy(self) -> Vector<2, T, A>

Returns (self.w, self.y).

pub fn wz(self) -> Vector<2, T, A>

Returns (self.w, self.z).

pub fn ww(self) -> Vector<2, T, A>

Returns (self.w, self.w).

pub fn xxx(self) -> Vector<3, T, A>

Returns (self.x, self.x, self.x).

pub fn xxy(self) -> Vector<3, T, A>

Returns (self.x, self.x, self.y).

pub fn xxz(self) -> Vector<3, T, A>

Returns (self.x, self.x, self.z).

pub fn xxw(self) -> Vector<3, T, A>

Returns (self.x, self.x, self.w).

pub fn xyx(self) -> Vector<3, T, A>

Returns (self.x, self.y, self.x).

pub fn xyy(self) -> Vector<3, T, A>

Returns (self.x, self.y, self.y).

pub fn xyz(self) -> Vector<3, T, A>

Returns (self.x, self.y, self.z).

pub fn xyw(self) -> Vector<3, T, A>

Returns (self.x, self.y, self.w).

pub fn xzx(self) -> Vector<3, T, A>

Returns (self.x, self.z, self.x).

pub fn xzy(self) -> Vector<3, T, A>

Returns (self.x, self.z, self.y).

pub fn xzz(self) -> Vector<3, T, A>

Returns (self.x, self.z, self.z).

pub fn xzw(self) -> Vector<3, T, A>

Returns (self.x, self.z, self.w).

pub fn xwx(self) -> Vector<3, T, A>

Returns (self.x, self.w, self.x).

pub fn xwy(self) -> Vector<3, T, A>

Returns (self.x, self.w, self.y).

pub fn xwz(self) -> Vector<3, T, A>

Returns (self.x, self.w, self.z).

pub fn xww(self) -> Vector<3, T, A>

Returns (self.x, self.w, self.w).

pub fn yxx(self) -> Vector<3, T, A>

Returns (self.y, self.x, self.x).

pub fn yxy(self) -> Vector<3, T, A>

Returns (self.y, self.x, self.y).

pub fn yxz(self) -> Vector<3, T, A>

Returns (self.y, self.x, self.z).

pub fn yxw(self) -> Vector<3, T, A>

Returns (self.y, self.x, self.w).

pub fn yyx(self) -> Vector<3, T, A>

Returns (self.y, self.y, self.x).

pub fn yyy(self) -> Vector<3, T, A>

Returns (self.y, self.y, self.y).

pub fn yyz(self) -> Vector<3, T, A>

Returns (self.y, self.y, self.z).

pub fn yyw(self) -> Vector<3, T, A>

Returns (self.y, self.y, self.w).

pub fn yzx(self) -> Vector<3, T, A>

Returns (self.y, self.z, self.x).

pub fn yzy(self) -> Vector<3, T, A>

Returns (self.y, self.z, self.y).

pub fn yzz(self) -> Vector<3, T, A>

Returns (self.y, self.z, self.z).

pub fn yzw(self) -> Vector<3, T, A>

Returns (self.y, self.z, self.w).

pub fn ywx(self) -> Vector<3, T, A>

Returns (self.y, self.w, self.x).

pub fn ywy(self) -> Vector<3, T, A>

Returns (self.y, self.w, self.y).

pub fn ywz(self) -> Vector<3, T, A>

Returns (self.y, self.w, self.z).

pub fn yww(self) -> Vector<3, T, A>

Returns (self.y, self.w, self.w).

pub fn zxx(self) -> Vector<3, T, A>

Returns (self.z, self.x, self.x).

pub fn zxy(self) -> Vector<3, T, A>

Returns (self.z, self.x, self.y).

pub fn zxz(self) -> Vector<3, T, A>

Returns (self.z, self.x, self.z).

pub fn zxw(self) -> Vector<3, T, A>

Returns (self.z, self.x, self.w).

pub fn zyx(self) -> Vector<3, T, A>

Returns (self.z, self.y, self.x).

pub fn zyy(self) -> Vector<3, T, A>

Returns (self.z, self.y, self.y).

pub fn zyz(self) -> Vector<3, T, A>

Returns (self.z, self.y, self.z).

pub fn zyw(self) -> Vector<3, T, A>

Returns (self.z, self.y, self.w).

pub fn zzx(self) -> Vector<3, T, A>

Returns (self.z, self.z, self.x).

pub fn zzy(self) -> Vector<3, T, A>

Returns (self.z, self.z, self.y).

pub fn zzz(self) -> Vector<3, T, A>

Returns (self.z, self.z, self.z).

pub fn zzw(self) -> Vector<3, T, A>

Returns (self.z, self.z, self.w).

pub fn zwx(self) -> Vector<3, T, A>

Returns (self.z, self.w, self.x).

pub fn zwy(self) -> Vector<3, T, A>

Returns (self.z, self.w, self.y).

pub fn zwz(self) -> Vector<3, T, A>

Returns (self.z, self.w, self.z).

pub fn zww(self) -> Vector<3, T, A>

Returns (self.z, self.w, self.w).

pub fn wxx(self) -> Vector<3, T, A>

Returns (self.w, self.x, self.x).

pub fn wxy(self) -> Vector<3, T, A>

Returns (self.w, self.x, self.y).

pub fn wxz(self) -> Vector<3, T, A>

Returns (self.w, self.x, self.z).

pub fn wxw(self) -> Vector<3, T, A>

Returns (self.w, self.x, self.w).

pub fn wyx(self) -> Vector<3, T, A>

Returns (self.w, self.y, self.x).

pub fn wyy(self) -> Vector<3, T, A>

Returns (self.w, self.y, self.y).

pub fn wyz(self) -> Vector<3, T, A>

Returns (self.w, self.y, self.z).

pub fn wyw(self) -> Vector<3, T, A>

Returns (self.w, self.y, self.w).

pub fn wzx(self) -> Vector<3, T, A>

Returns (self.w, self.z, self.x).

pub fn wzy(self) -> Vector<3, T, A>

Returns (self.w, self.z, self.y).

pub fn wzz(self) -> Vector<3, T, A>

Returns (self.w, self.z, self.z).

pub fn wzw(self) -> Vector<3, T, A>

Returns (self.w, self.z, self.w).

pub fn wwx(self) -> Vector<3, T, A>

Returns (self.w, self.w, self.x).

pub fn wwy(self) -> Vector<3, T, A>

Returns (self.w, self.w, self.y).

pub fn wwz(self) -> Vector<3, T, A>

Returns (self.w, self.w, self.z).

pub fn www(self) -> Vector<3, T, A>

Returns (self.w, self.w, self.w).

pub fn xxxx(self) -> Vector<4, T, A>

Returns (self.x, self.x, self.x, self.x).

pub fn xxxy(self) -> Vector<4, T, A>

Returns (self.x, self.x, self.x, self.y).

pub fn xxxz(self) -> Vector<4, T, A>

Returns (self.x, self.x, self.x, self.z).

pub fn xxxw(self) -> Vector<4, T, A>

Returns (self.x, self.x, self.x, self.w).

pub fn xxyx(self) -> Vector<4, T, A>

Returns (self.x, self.x, self.y, self.x).

pub fn xxyy(self) -> Vector<4, T, A>

Returns (self.x, self.x, self.y, self.y).

pub fn xxyz(self) -> Vector<4, T, A>

Returns (self.x, self.x, self.y, self.z).

pub fn xxyw(self) -> Vector<4, T, A>

Returns (self.x, self.x, self.y, self.w).

pub fn xxzx(self) -> Vector<4, T, A>

Returns (self.x, self.x, self.z, self.x).

pub fn xxzy(self) -> Vector<4, T, A>

Returns (self.x, self.x, self.z, self.y).

pub fn xxzz(self) -> Vector<4, T, A>

Returns (self.x, self.x, self.z, self.z).

pub fn xxzw(self) -> Vector<4, T, A>

Returns (self.x, self.x, self.z, self.w).

pub fn xxwx(self) -> Vector<4, T, A>

Returns (self.x, self.x, self.w, self.x).

pub fn xxwy(self) -> Vector<4, T, A>

Returns (self.x, self.x, self.w, self.y).

pub fn xxwz(self) -> Vector<4, T, A>

Returns (self.x, self.x, self.w, self.z).

pub fn xxww(self) -> Vector<4, T, A>

Returns (self.x, self.x, self.w, self.w).

pub fn xyxx(self) -> Vector<4, T, A>

Returns (self.x, self.y, self.x, self.x).

pub fn xyxy(self) -> Vector<4, T, A>

Returns (self.x, self.y, self.x, self.y).

pub fn xyxz(self) -> Vector<4, T, A>

Returns (self.x, self.y, self.x, self.z).

pub fn xyxw(self) -> Vector<4, T, A>

Returns (self.x, self.y, self.x, self.w).

pub fn xyyx(self) -> Vector<4, T, A>

Returns (self.x, self.y, self.y, self.x).

pub fn xyyy(self) -> Vector<4, T, A>

Returns (self.x, self.y, self.y, self.y).

pub fn xyyz(self) -> Vector<4, T, A>

Returns (self.x, self.y, self.y, self.z).

pub fn xyyw(self) -> Vector<4, T, A>

Returns (self.x, self.y, self.y, self.w).

pub fn xyzx(self) -> Vector<4, T, A>

Returns (self.x, self.y, self.z, self.x).

pub fn xyzy(self) -> Vector<4, T, A>

Returns (self.x, self.y, self.z, self.y).

pub fn xyzz(self) -> Vector<4, T, A>

Returns (self.x, self.y, self.z, self.z).

pub fn xyzw(self) -> Vector<4, T, A>

Returns (self.x, self.y, self.z, self.w).

pub fn xywx(self) -> Vector<4, T, A>

Returns (self.x, self.y, self.w, self.x).

pub fn xywy(self) -> Vector<4, T, A>

Returns (self.x, self.y, self.w, self.y).

pub fn xywz(self) -> Vector<4, T, A>

Returns (self.x, self.y, self.w, self.z).

pub fn xyww(self) -> Vector<4, T, A>

Returns (self.x, self.y, self.w, self.w).

pub fn xzxx(self) -> Vector<4, T, A>

Returns (self.x, self.z, self.x, self.x).

pub fn xzxy(self) -> Vector<4, T, A>

Returns (self.x, self.z, self.x, self.y).

pub fn xzxz(self) -> Vector<4, T, A>

Returns (self.x, self.z, self.x, self.z).

pub fn xzxw(self) -> Vector<4, T, A>

Returns (self.x, self.z, self.x, self.w).

pub fn xzyx(self) -> Vector<4, T, A>

Returns (self.x, self.z, self.y, self.x).

pub fn xzyy(self) -> Vector<4, T, A>

Returns (self.x, self.z, self.y, self.y).

pub fn xzyz(self) -> Vector<4, T, A>

Returns (self.x, self.z, self.y, self.z).

pub fn xzyw(self) -> Vector<4, T, A>

Returns (self.x, self.z, self.y, self.w).

pub fn xzzx(self) -> Vector<4, T, A>

Returns (self.x, self.z, self.z, self.x).

pub fn xzzy(self) -> Vector<4, T, A>

Returns (self.x, self.z, self.z, self.y).

pub fn xzzz(self) -> Vector<4, T, A>

Returns (self.x, self.z, self.z, self.z).

pub fn xzzw(self) -> Vector<4, T, A>

Returns (self.x, self.z, self.z, self.w).

pub fn xzwx(self) -> Vector<4, T, A>

Returns (self.x, self.z, self.w, self.x).

pub fn xzwy(self) -> Vector<4, T, A>

Returns (self.x, self.z, self.w, self.y).

pub fn xzwz(self) -> Vector<4, T, A>

Returns (self.x, self.z, self.w, self.z).

pub fn xzww(self) -> Vector<4, T, A>

Returns (self.x, self.z, self.w, self.w).

pub fn xwxx(self) -> Vector<4, T, A>

Returns (self.x, self.w, self.x, self.x).

pub fn xwxy(self) -> Vector<4, T, A>

Returns (self.x, self.w, self.x, self.y).

pub fn xwxz(self) -> Vector<4, T, A>

Returns (self.x, self.w, self.x, self.z).

pub fn xwxw(self) -> Vector<4, T, A>

Returns (self.x, self.w, self.x, self.w).

pub fn xwyx(self) -> Vector<4, T, A>

Returns (self.x, self.w, self.y, self.x).

pub fn xwyy(self) -> Vector<4, T, A>

Returns (self.x, self.w, self.y, self.y).

pub fn xwyz(self) -> Vector<4, T, A>

Returns (self.x, self.w, self.y, self.z).

pub fn xwyw(self) -> Vector<4, T, A>

Returns (self.x, self.w, self.y, self.w).

pub fn xwzx(self) -> Vector<4, T, A>

Returns (self.x, self.w, self.z, self.x).

pub fn xwzy(self) -> Vector<4, T, A>

Returns (self.x, self.w, self.z, self.y).

pub fn xwzz(self) -> Vector<4, T, A>

Returns (self.x, self.w, self.z, self.z).

pub fn xwzw(self) -> Vector<4, T, A>

Returns (self.x, self.w, self.z, self.w).

pub fn xwwx(self) -> Vector<4, T, A>

Returns (self.x, self.w, self.w, self.x).

pub fn xwwy(self) -> Vector<4, T, A>

Returns (self.x, self.w, self.w, self.y).

pub fn xwwz(self) -> Vector<4, T, A>

Returns (self.x, self.w, self.w, self.z).

pub fn xwww(self) -> Vector<4, T, A>

Returns (self.x, self.w, self.w, self.w).

pub fn yxxx(self) -> Vector<4, T, A>

Returns (self.y, self.x, self.x, self.x).

pub fn yxxy(self) -> Vector<4, T, A>

Returns (self.y, self.x, self.x, self.y).

pub fn yxxz(self) -> Vector<4, T, A>

Returns (self.y, self.x, self.x, self.z).

pub fn yxxw(self) -> Vector<4, T, A>

Returns (self.y, self.x, self.x, self.w).

pub fn yxyx(self) -> Vector<4, T, A>

Returns (self.y, self.x, self.y, self.x).

pub fn yxyy(self) -> Vector<4, T, A>

Returns (self.y, self.x, self.y, self.y).

pub fn yxyz(self) -> Vector<4, T, A>

Returns (self.y, self.x, self.y, self.z).

pub fn yxyw(self) -> Vector<4, T, A>

Returns (self.y, self.x, self.y, self.w).

pub fn yxzx(self) -> Vector<4, T, A>

Returns (self.y, self.x, self.z, self.x).

pub fn yxzy(self) -> Vector<4, T, A>

Returns (self.y, self.x, self.z, self.y).

pub fn yxzz(self) -> Vector<4, T, A>

Returns (self.y, self.x, self.z, self.z).

pub fn yxzw(self) -> Vector<4, T, A>

Returns (self.y, self.x, self.z, self.w).

pub fn yxwx(self) -> Vector<4, T, A>

Returns (self.y, self.x, self.w, self.x).

pub fn yxwy(self) -> Vector<4, T, A>

Returns (self.y, self.x, self.w, self.y).

pub fn yxwz(self) -> Vector<4, T, A>

Returns (self.y, self.x, self.w, self.z).

pub fn yxww(self) -> Vector<4, T, A>

Returns (self.y, self.x, self.w, self.w).

pub fn yyxx(self) -> Vector<4, T, A>

Returns (self.y, self.y, self.x, self.x).

pub fn yyxy(self) -> Vector<4, T, A>

Returns (self.y, self.y, self.x, self.y).

pub fn yyxz(self) -> Vector<4, T, A>

Returns (self.y, self.y, self.x, self.z).

pub fn yyxw(self) -> Vector<4, T, A>

Returns (self.y, self.y, self.x, self.w).

pub fn yyyx(self) -> Vector<4, T, A>

Returns (self.y, self.y, self.y, self.x).

pub fn yyyy(self) -> Vector<4, T, A>

Returns (self.y, self.y, self.y, self.y).

pub fn yyyz(self) -> Vector<4, T, A>

Returns (self.y, self.y, self.y, self.z).

pub fn yyyw(self) -> Vector<4, T, A>

Returns (self.y, self.y, self.y, self.w).

pub fn yyzx(self) -> Vector<4, T, A>

Returns (self.y, self.y, self.z, self.x).

pub fn yyzy(self) -> Vector<4, T, A>

Returns (self.y, self.y, self.z, self.y).

pub fn yyzz(self) -> Vector<4, T, A>

Returns (self.y, self.y, self.z, self.z).

pub fn yyzw(self) -> Vector<4, T, A>

Returns (self.y, self.y, self.z, self.w).

pub fn yywx(self) -> Vector<4, T, A>

Returns (self.y, self.y, self.w, self.x).

pub fn yywy(self) -> Vector<4, T, A>

Returns (self.y, self.y, self.w, self.y).

pub fn yywz(self) -> Vector<4, T, A>

Returns (self.y, self.y, self.w, self.z).

pub fn yyww(self) -> Vector<4, T, A>

Returns (self.y, self.y, self.w, self.w).

pub fn yzxx(self) -> Vector<4, T, A>

Returns (self.y, self.z, self.x, self.x).

pub fn yzxy(self) -> Vector<4, T, A>

Returns (self.y, self.z, self.x, self.y).

pub fn yzxz(self) -> Vector<4, T, A>

Returns (self.y, self.z, self.x, self.z).

pub fn yzxw(self) -> Vector<4, T, A>

Returns (self.y, self.z, self.x, self.w).

pub fn yzyx(self) -> Vector<4, T, A>

Returns (self.y, self.z, self.y, self.x).

pub fn yzyy(self) -> Vector<4, T, A>

Returns (self.y, self.z, self.y, self.y).

pub fn yzyz(self) -> Vector<4, T, A>

Returns (self.y, self.z, self.y, self.z).

pub fn yzyw(self) -> Vector<4, T, A>

Returns (self.y, self.z, self.y, self.w).

pub fn yzzx(self) -> Vector<4, T, A>

Returns (self.y, self.z, self.z, self.x).

pub fn yzzy(self) -> Vector<4, T, A>

Returns (self.y, self.z, self.z, self.y).

pub fn yzzz(self) -> Vector<4, T, A>

Returns (self.y, self.z, self.z, self.z).

pub fn yzzw(self) -> Vector<4, T, A>

Returns (self.y, self.z, self.z, self.w).

pub fn yzwx(self) -> Vector<4, T, A>

Returns (self.y, self.z, self.w, self.x).

pub fn yzwy(self) -> Vector<4, T, A>

Returns (self.y, self.z, self.w, self.y).

pub fn yzwz(self) -> Vector<4, T, A>

Returns (self.y, self.z, self.w, self.z).

pub fn yzww(self) -> Vector<4, T, A>

Returns (self.y, self.z, self.w, self.w).

pub fn ywxx(self) -> Vector<4, T, A>

Returns (self.y, self.w, self.x, self.x).

pub fn ywxy(self) -> Vector<4, T, A>

Returns (self.y, self.w, self.x, self.y).

pub fn ywxz(self) -> Vector<4, T, A>

Returns (self.y, self.w, self.x, self.z).

pub fn ywxw(self) -> Vector<4, T, A>

Returns (self.y, self.w, self.x, self.w).

pub fn ywyx(self) -> Vector<4, T, A>

Returns (self.y, self.w, self.y, self.x).

pub fn ywyy(self) -> Vector<4, T, A>

Returns (self.y, self.w, self.y, self.y).

pub fn ywyz(self) -> Vector<4, T, A>

Returns (self.y, self.w, self.y, self.z).

pub fn ywyw(self) -> Vector<4, T, A>

Returns (self.y, self.w, self.y, self.w).

pub fn ywzx(self) -> Vector<4, T, A>

Returns (self.y, self.w, self.z, self.x).

pub fn ywzy(self) -> Vector<4, T, A>

Returns (self.y, self.w, self.z, self.y).

pub fn ywzz(self) -> Vector<4, T, A>

Returns (self.y, self.w, self.z, self.z).

pub fn ywzw(self) -> Vector<4, T, A>

Returns (self.y, self.w, self.z, self.w).

pub fn ywwx(self) -> Vector<4, T, A>

Returns (self.y, self.w, self.w, self.x).

pub fn ywwy(self) -> Vector<4, T, A>

Returns (self.y, self.w, self.w, self.y).

pub fn ywwz(self) -> Vector<4, T, A>

Returns (self.y, self.w, self.w, self.z).

pub fn ywww(self) -> Vector<4, T, A>

Returns (self.y, self.w, self.w, self.w).

pub fn zxxx(self) -> Vector<4, T, A>

Returns (self.z, self.x, self.x, self.x).

pub fn zxxy(self) -> Vector<4, T, A>

Returns (self.z, self.x, self.x, self.y).

pub fn zxxz(self) -> Vector<4, T, A>

Returns (self.z, self.x, self.x, self.z).

pub fn zxxw(self) -> Vector<4, T, A>

Returns (self.z, self.x, self.x, self.w).

pub fn zxyx(self) -> Vector<4, T, A>

Returns (self.z, self.x, self.y, self.x).

pub fn zxyy(self) -> Vector<4, T, A>

Returns (self.z, self.x, self.y, self.y).

pub fn zxyz(self) -> Vector<4, T, A>

Returns (self.z, self.x, self.y, self.z).

pub fn zxyw(self) -> Vector<4, T, A>

Returns (self.z, self.x, self.y, self.w).

pub fn zxzx(self) -> Vector<4, T, A>

Returns (self.z, self.x, self.z, self.x).

pub fn zxzy(self) -> Vector<4, T, A>

Returns (self.z, self.x, self.z, self.y).

pub fn zxzz(self) -> Vector<4, T, A>

Returns (self.z, self.x, self.z, self.z).

pub fn zxzw(self) -> Vector<4, T, A>

Returns (self.z, self.x, self.z, self.w).

pub fn zxwx(self) -> Vector<4, T, A>

Returns (self.z, self.x, self.w, self.x).

pub fn zxwy(self) -> Vector<4, T, A>

Returns (self.z, self.x, self.w, self.y).

pub fn zxwz(self) -> Vector<4, T, A>

Returns (self.z, self.x, self.w, self.z).

pub fn zxww(self) -> Vector<4, T, A>

Returns (self.z, self.x, self.w, self.w).

pub fn zyxx(self) -> Vector<4, T, A>

Returns (self.z, self.y, self.x, self.x).

pub fn zyxy(self) -> Vector<4, T, A>

Returns (self.z, self.y, self.x, self.y).

pub fn zyxz(self) -> Vector<4, T, A>

Returns (self.z, self.y, self.x, self.z).

pub fn zyxw(self) -> Vector<4, T, A>

Returns (self.z, self.y, self.x, self.w).

pub fn zyyx(self) -> Vector<4, T, A>

Returns (self.z, self.y, self.y, self.x).

pub fn zyyy(self) -> Vector<4, T, A>

Returns (self.z, self.y, self.y, self.y).

pub fn zyyz(self) -> Vector<4, T, A>

Returns (self.z, self.y, self.y, self.z).

pub fn zyyw(self) -> Vector<4, T, A>

Returns (self.z, self.y, self.y, self.w).

pub fn zyzx(self) -> Vector<4, T, A>

Returns (self.z, self.y, self.z, self.x).

pub fn zyzy(self) -> Vector<4, T, A>

Returns (self.z, self.y, self.z, self.y).

pub fn zyzz(self) -> Vector<4, T, A>

Returns (self.z, self.y, self.z, self.z).

pub fn zyzw(self) -> Vector<4, T, A>

Returns (self.z, self.y, self.z, self.w).

pub fn zywx(self) -> Vector<4, T, A>

Returns (self.z, self.y, self.w, self.x).

pub fn zywy(self) -> Vector<4, T, A>

Returns (self.z, self.y, self.w, self.y).

pub fn zywz(self) -> Vector<4, T, A>

Returns (self.z, self.y, self.w, self.z).

pub fn zyww(self) -> Vector<4, T, A>

Returns (self.z, self.y, self.w, self.w).

pub fn zzxx(self) -> Vector<4, T, A>

Returns (self.z, self.z, self.x, self.x).

pub fn zzxy(self) -> Vector<4, T, A>

Returns (self.z, self.z, self.x, self.y).

pub fn zzxz(self) -> Vector<4, T, A>

Returns (self.z, self.z, self.x, self.z).

pub fn zzxw(self) -> Vector<4, T, A>

Returns (self.z, self.z, self.x, self.w).

pub fn zzyx(self) -> Vector<4, T, A>

Returns (self.z, self.z, self.y, self.x).

pub fn zzyy(self) -> Vector<4, T, A>

Returns (self.z, self.z, self.y, self.y).

pub fn zzyz(self) -> Vector<4, T, A>

Returns (self.z, self.z, self.y, self.z).

pub fn zzyw(self) -> Vector<4, T, A>

Returns (self.z, self.z, self.y, self.w).

pub fn zzzx(self) -> Vector<4, T, A>

Returns (self.z, self.z, self.z, self.x).

pub fn zzzy(self) -> Vector<4, T, A>

Returns (self.z, self.z, self.z, self.y).

pub fn zzzz(self) -> Vector<4, T, A>

Returns (self.z, self.z, self.z, self.z).

pub fn zzzw(self) -> Vector<4, T, A>

Returns (self.z, self.z, self.z, self.w).

pub fn zzwx(self) -> Vector<4, T, A>

Returns (self.z, self.z, self.w, self.x).

pub fn zzwy(self) -> Vector<4, T, A>

Returns (self.z, self.z, self.w, self.y).

pub fn zzwz(self) -> Vector<4, T, A>

Returns (self.z, self.z, self.w, self.z).

pub fn zzww(self) -> Vector<4, T, A>

Returns (self.z, self.z, self.w, self.w).

pub fn zwxx(self) -> Vector<4, T, A>

Returns (self.z, self.w, self.x, self.x).

pub fn zwxy(self) -> Vector<4, T, A>

Returns (self.z, self.w, self.x, self.y).

pub fn zwxz(self) -> Vector<4, T, A>

Returns (self.z, self.w, self.x, self.z).

pub fn zwxw(self) -> Vector<4, T, A>

Returns (self.z, self.w, self.x, self.w).

pub fn zwyx(self) -> Vector<4, T, A>

Returns (self.z, self.w, self.y, self.x).

pub fn zwyy(self) -> Vector<4, T, A>

Returns (self.z, self.w, self.y, self.y).

pub fn zwyz(self) -> Vector<4, T, A>

Returns (self.z, self.w, self.y, self.z).

pub fn zwyw(self) -> Vector<4, T, A>

Returns (self.z, self.w, self.y, self.w).

pub fn zwzx(self) -> Vector<4, T, A>

Returns (self.z, self.w, self.z, self.x).

pub fn zwzy(self) -> Vector<4, T, A>

Returns (self.z, self.w, self.z, self.y).

pub fn zwzz(self) -> Vector<4, T, A>

Returns (self.z, self.w, self.z, self.z).

pub fn zwzw(self) -> Vector<4, T, A>

Returns (self.z, self.w, self.z, self.w).

pub fn zwwx(self) -> Vector<4, T, A>

Returns (self.z, self.w, self.w, self.x).

pub fn zwwy(self) -> Vector<4, T, A>

Returns (self.z, self.w, self.w, self.y).

pub fn zwwz(self) -> Vector<4, T, A>

Returns (self.z, self.w, self.w, self.z).

pub fn zwww(self) -> Vector<4, T, A>

Returns (self.z, self.w, self.w, self.w).

pub fn wxxx(self) -> Vector<4, T, A>

Returns (self.w, self.x, self.x, self.x).

pub fn wxxy(self) -> Vector<4, T, A>

Returns (self.w, self.x, self.x, self.y).

pub fn wxxz(self) -> Vector<4, T, A>

Returns (self.w, self.x, self.x, self.z).

pub fn wxxw(self) -> Vector<4, T, A>

Returns (self.w, self.x, self.x, self.w).

pub fn wxyx(self) -> Vector<4, T, A>

Returns (self.w, self.x, self.y, self.x).

pub fn wxyy(self) -> Vector<4, T, A>

Returns (self.w, self.x, self.y, self.y).

pub fn wxyz(self) -> Vector<4, T, A>

Returns (self.w, self.x, self.y, self.z).

pub fn wxyw(self) -> Vector<4, T, A>

Returns (self.w, self.x, self.y, self.w).

pub fn wxzx(self) -> Vector<4, T, A>

Returns (self.w, self.x, self.z, self.x).

pub fn wxzy(self) -> Vector<4, T, A>

Returns (self.w, self.x, self.z, self.y).

pub fn wxzz(self) -> Vector<4, T, A>

Returns (self.w, self.x, self.z, self.z).

pub fn wxzw(self) -> Vector<4, T, A>

Returns (self.w, self.x, self.z, self.w).

pub fn wxwx(self) -> Vector<4, T, A>

Returns (self.w, self.x, self.w, self.x).

pub fn wxwy(self) -> Vector<4, T, A>

Returns (self.w, self.x, self.w, self.y).

pub fn wxwz(self) -> Vector<4, T, A>

Returns (self.w, self.x, self.w, self.z).

pub fn wxww(self) -> Vector<4, T, A>

Returns (self.w, self.x, self.w, self.w).

pub fn wyxx(self) -> Vector<4, T, A>

Returns (self.w, self.y, self.x, self.x).

pub fn wyxy(self) -> Vector<4, T, A>

Returns (self.w, self.y, self.x, self.y).

pub fn wyxz(self) -> Vector<4, T, A>

Returns (self.w, self.y, self.x, self.z).

pub fn wyxw(self) -> Vector<4, T, A>

Returns (self.w, self.y, self.x, self.w).

pub fn wyyx(self) -> Vector<4, T, A>

Returns (self.w, self.y, self.y, self.x).

pub fn wyyy(self) -> Vector<4, T, A>

Returns (self.w, self.y, self.y, self.y).

pub fn wyyz(self) -> Vector<4, T, A>

Returns (self.w, self.y, self.y, self.z).

pub fn wyyw(self) -> Vector<4, T, A>

Returns (self.w, self.y, self.y, self.w).

pub fn wyzx(self) -> Vector<4, T, A>

Returns (self.w, self.y, self.z, self.x).

pub fn wyzy(self) -> Vector<4, T, A>

Returns (self.w, self.y, self.z, self.y).

pub fn wyzz(self) -> Vector<4, T, A>

Returns (self.w, self.y, self.z, self.z).

pub fn wyzw(self) -> Vector<4, T, A>

Returns (self.w, self.y, self.z, self.w).

pub fn wywx(self) -> Vector<4, T, A>

Returns (self.w, self.y, self.w, self.x).

pub fn wywy(self) -> Vector<4, T, A>

Returns (self.w, self.y, self.w, self.y).

pub fn wywz(self) -> Vector<4, T, A>

Returns (self.w, self.y, self.w, self.z).

pub fn wyww(self) -> Vector<4, T, A>

Returns (self.w, self.y, self.w, self.w).

pub fn wzxx(self) -> Vector<4, T, A>

Returns (self.w, self.z, self.x, self.x).

pub fn wzxy(self) -> Vector<4, T, A>

Returns (self.w, self.z, self.x, self.y).

pub fn wzxz(self) -> Vector<4, T, A>

Returns (self.w, self.z, self.x, self.z).

pub fn wzxw(self) -> Vector<4, T, A>

Returns (self.w, self.z, self.x, self.w).

pub fn wzyx(self) -> Vector<4, T, A>

Returns (self.w, self.z, self.y, self.x).

pub fn wzyy(self) -> Vector<4, T, A>

Returns (self.w, self.z, self.y, self.y).

pub fn wzyz(self) -> Vector<4, T, A>

Returns (self.w, self.z, self.y, self.z).

pub fn wzyw(self) -> Vector<4, T, A>

Returns (self.w, self.z, self.y, self.w).

pub fn wzzx(self) -> Vector<4, T, A>

Returns (self.w, self.z, self.z, self.x).

pub fn wzzy(self) -> Vector<4, T, A>

Returns (self.w, self.z, self.z, self.y).

pub fn wzzz(self) -> Vector<4, T, A>

Returns (self.w, self.z, self.z, self.z).

pub fn wzzw(self) -> Vector<4, T, A>

Returns (self.w, self.z, self.z, self.w).

pub fn wzwx(self) -> Vector<4, T, A>

Returns (self.w, self.z, self.w, self.x).

pub fn wzwy(self) -> Vector<4, T, A>

Returns (self.w, self.z, self.w, self.y).

pub fn wzwz(self) -> Vector<4, T, A>

Returns (self.w, self.z, self.w, self.z).

pub fn wzww(self) -> Vector<4, T, A>

Returns (self.w, self.z, self.w, self.w).

pub fn wwxx(self) -> Vector<4, T, A>

Returns (self.w, self.w, self.x, self.x).

pub fn wwxy(self) -> Vector<4, T, A>

Returns (self.w, self.w, self.x, self.y).

pub fn wwxz(self) -> Vector<4, T, A>

Returns (self.w, self.w, self.x, self.z).

pub fn wwxw(self) -> Vector<4, T, A>

Returns (self.w, self.w, self.x, self.w).

pub fn wwyx(self) -> Vector<4, T, A>

Returns (self.w, self.w, self.y, self.x).

pub fn wwyy(self) -> Vector<4, T, A>

Returns (self.w, self.w, self.y, self.y).

pub fn wwyz(self) -> Vector<4, T, A>

Returns (self.w, self.w, self.y, self.z).

pub fn wwyw(self) -> Vector<4, T, A>

Returns (self.w, self.w, self.y, self.w).

pub fn wwzx(self) -> Vector<4, T, A>

Returns (self.w, self.w, self.z, self.x).

pub fn wwzy(self) -> Vector<4, T, A>

Returns (self.w, self.w, self.z, self.y).

pub fn wwzz(self) -> Vector<4, T, A>

Returns (self.w, self.w, self.z, self.z).

pub fn wwzw(self) -> Vector<4, T, A>

Returns (self.w, self.w, self.z, self.w).

pub fn wwwx(self) -> Vector<4, T, A>

Returns (self.w, self.w, self.w, self.x).

pub fn wwwy(self) -> Vector<4, T, A>

Returns (self.w, self.w, self.w, self.y).

pub fn wwwz(self) -> Vector<4, T, A>

Returns (self.w, self.w, self.w, self.z).

pub fn wwww(self) -> Vector<4, T, A>

Returns (self.w, self.w, self.w, self.w).

pub fn with_x(self, value: T) -> Self

Returns the vector with the x component set to the given value.

pub fn with_y(self, value: T) -> Self

Returns the vector with the y component set to the given value.

pub fn with_z(self, value: T) -> Self

Returns the vector with the z component set to the given value.

pub fn with_w(self, value: T) -> Self

Returns the vector with the w component set to the given value.

pub fn with_xy(self, value: Vector<2, T, A>) -> Self

Returns the vector with the x and y components set to the given values.

pub fn with_xz(self, value: Vector<2, T, A>) -> Self

Returns the vector with the x and z components set to the given values.

pub fn with_xw(self, value: Vector<2, T, A>) -> Self

Returns the vector with the x and w components set to the given values.

pub fn with_yx(self, value: Vector<2, T, A>) -> Self

Returns the vector with the y and x components set to the given values.

pub fn with_yz(self, value: Vector<2, T, A>) -> Self

Returns the vector with the y and z components set to the given values.

pub fn with_yw(self, value: Vector<2, T, A>) -> Self

Returns the vector with the y and w components set to the given values.

pub fn with_zx(self, value: Vector<2, T, A>) -> Self

Returns the vector with the z and x components set to the given values.

pub fn with_zy(self, value: Vector<2, T, A>) -> Self

Returns the vector with the z and y components set to the given values.

pub fn with_zw(self, value: Vector<2, T, A>) -> Self

Returns the vector with the z and w components set to the given values.

pub fn with_wx(self, value: Vector<2, T, A>) -> Self

Returns the vector with the w and x components set to the given values.

pub fn with_wy(self, value: Vector<2, T, A>) -> Self

Returns the vector with the w and y components set to the given values.

pub fn with_wz(self, value: Vector<2, T, A>) -> Self

Returns the vector with the w and z components set to the given values.

pub fn with_xyz(self, value: Vector<3, T, A>) -> Self

Returns the vector with the x, y and z components set to the given values.

pub fn with_xyw(self, value: Vector<3, T, A>) -> Self

Returns the vector with the x, y and w components set to the given values.

pub fn with_xzy(self, value: Vector<3, T, A>) -> Self

Returns the vector with the x, z and y components set to the given values.

pub fn with_xzw(self, value: Vector<3, T, A>) -> Self

Returns the vector with the x, z and w components set to the given values.

pub fn with_xwy(self, value: Vector<3, T, A>) -> Self

Returns the vector with the x, w and y components set to the given values.

pub fn with_xwz(self, value: Vector<3, T, A>) -> Self

Returns the vector with the x, w and z components set to the given values.

pub fn with_yxz(self, value: Vector<3, T, A>) -> Self

Returns the vector with the y, x and z components set to the given values.

pub fn with_yxw(self, value: Vector<3, T, A>) -> Self

Returns the vector with the y, x and w components set to the given values.

pub fn with_yzx(self, value: Vector<3, T, A>) -> Self

Returns the vector with the y, z and x components set to the given values.

pub fn with_yzw(self, value: Vector<3, T, A>) -> Self

Returns the vector with the y, z and w components set to the given values.

pub fn with_ywx(self, value: Vector<3, T, A>) -> Self

Returns the vector with the y, w and x components set to the given values.

pub fn with_ywz(self, value: Vector<3, T, A>) -> Self

Returns the vector with the y, w and z components set to the given values.

pub fn with_zxy(self, value: Vector<3, T, A>) -> Self

Returns the vector with the z, x and y components set to the given values.

pub fn with_zxw(self, value: Vector<3, T, A>) -> Self

Returns the vector with the z, x and w components set to the given values.

pub fn with_zyx(self, value: Vector<3, T, A>) -> Self

Returns the vector with the z, y and x components set to the given values.

pub fn with_zyw(self, value: Vector<3, T, A>) -> Self

Returns the vector with the z, y and w components set to the given values.

pub fn with_zwx(self, value: Vector<3, T, A>) -> Self

Returns the vector with the z, w and x components set to the given values.

pub fn with_zwy(self, value: Vector<3, T, A>) -> Self

Returns the vector with the z, w and y components set to the given values.

pub fn with_wxy(self, value: Vector<3, T, A>) -> Self

Returns the vector with the w, x and y components set to the given values.

pub fn with_wxz(self, value: Vector<3, T, A>) -> Self

Returns the vector with the w, x and z components set to the given values.

pub fn with_wyx(self, value: Vector<3, T, A>) -> Self

Returns the vector with the w, y and x components set to the given values.

pub fn with_wyz(self, value: Vector<3, T, A>) -> Self

Returns the vector with the w, y and z components set to the given values.

pub fn with_wzx(self, value: Vector<3, T, A>) -> Self

Returns the vector with the w, z and x components set to the given values.

pub fn with_wzy(self, value: Vector<3, T, A>) -> Self

Returns the vector with the w, z and y components set to the given values.

pub fn with_xyzw(self, value: Vector<4, T, A>) -> Self

Returns the vector with the x, y, z and w components set to the given values.

pub fn with_xywz(self, value: Vector<4, T, A>) -> Self

Returns the vector with the x, y, w and z components set to the given values.

pub fn with_xzyw(self, value: Vector<4, T, A>) -> Self

Returns the vector with the x, z, y and w components set to the given values.

pub fn with_xzwy(self, value: Vector<4, T, A>) -> Self

Returns the vector with the x, z, w and y components set to the given values.

pub fn with_xwyz(self, value: Vector<4, T, A>) -> Self

Returns the vector with the x, w, y and z components set to the given values.

pub fn with_xwzy(self, value: Vector<4, T, A>) -> Self

Returns the vector with the x, w, z and y components set to the given values.

pub fn with_yxzw(self, value: Vector<4, T, A>) -> Self

Returns the vector with the y, x, z and w components set to the given values.

pub fn with_yxwz(self, value: Vector<4, T, A>) -> Self

Returns the vector with the y, x, w and z components set to the given values.

pub fn with_yzxw(self, value: Vector<4, T, A>) -> Self

Returns the vector with the y, z, x and w components set to the given values.

pub fn with_yzwx(self, value: Vector<4, T, A>) -> Self

Returns the vector with the y, z, w and x components set to the given values.

pub fn with_ywxz(self, value: Vector<4, T, A>) -> Self

Returns the vector with the y, w, x and z components set to the given values.

pub fn with_ywzx(self, value: Vector<4, T, A>) -> Self

Returns the vector with the y, w, z and x components set to the given values.

pub fn with_zxyw(self, value: Vector<4, T, A>) -> Self

Returns the vector with the z, x, y and w components set to the given values.

pub fn with_zxwy(self, value: Vector<4, T, A>) -> Self

Returns the vector with the z, x, w and y components set to the given values.

pub fn with_zyxw(self, value: Vector<4, T, A>) -> Self

Returns the vector with the z, y, x and w components set to the given values.

pub fn with_zywx(self, value: Vector<4, T, A>) -> Self

Returns the vector with the z, y, w and x components set to the given values.

pub fn with_zwxy(self, value: Vector<4, T, A>) -> Self

Returns the vector with the z, w, x and y components set to the given values.

pub fn with_zwyx(self, value: Vector<4, T, A>) -> Self

Returns the vector with the z, w, y and x components set to the given values.

pub fn with_wxyz(self, value: Vector<4, T, A>) -> Self

Returns the vector with the w, x, y and z components set to the given values.

pub fn with_wxzy(self, value: Vector<4, T, A>) -> Self

Returns the vector with the w, x, z and y components set to the given values.

pub fn with_wyxz(self, value: Vector<4, T, A>) -> Self

Returns the vector with the w, y, x and z components set to the given values.

pub fn with_wyzx(self, value: Vector<4, T, A>) -> Self

Returns the vector with the w, y, z and x components set to the given values.

pub fn with_wzxy(self, value: Vector<4, T, A>) -> Self

Returns the vector with the w, z, x and y components set to the given values.

pub fn with_wzyx(self, value: Vector<4, T, A>) -> Self

Returns the vector with the w, z, y and x components set to the given values.

Trait Implementations

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

where T: Scalar + Add<Output = T>, Length<N>: SupportedLength,

type Output = Vector<N, T, A>

The resulting type after applying the + operator.

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

Performs the + operation.

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

where T: Scalar + Add<Output = T>, Length<N>: SupportedLength,

type Output = Vector<N, T, A>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<const N: usize, T, A: Alignment> AddAssign<T> for Vector<N, T, A>

where T: Scalar + Add<Output = T>, Length<N>: SupportedLength,

fn add_assign(&mut self, rhs: T)

Performs the += operation.

impl<const N: usize, T, A: Alignment> AddAssign for Vector<N, T, A>

where T: Scalar + Add<Output = T>, Length<N>: SupportedLength,

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

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

where T: Scalar + BitAnd<Output = T>, Length<N>: SupportedLength,

type Output = Vector<N, T, A>

The resulting type after applying the & operator.

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

Performs the & operation.

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

where T: Scalar + BitAnd<Output = T>, Length<N>: SupportedLength,

type Output = Vector<N, T, A>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<const N: usize, T, A: Alignment> BitAndAssign<T> for Vector<N, T, A>

where T: Scalar + BitAnd<Output = T>, Length<N>: SupportedLength,

fn bitand_assign(&mut self, rhs: T)

Performs the &= operation.

impl<const N: usize, T, A: Alignment> BitAndAssign for Vector<N, T, A>

where T: Scalar + BitAnd<Output = T>, Length<N>: SupportedLength,

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

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

where T: Scalar + BitOr<Output = T>, Length<N>: SupportedLength,

type Output = Vector<N, T, A>

The resulting type after applying the | operator.

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

Performs the | operation.

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

where T: Scalar + BitOr<Output = T>, Length<N>: SupportedLength,

type Output = Vector<N, T, A>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<const N: usize, T, A: Alignment> BitOrAssign<T> for Vector<N, T, A>

where T: Scalar + BitOr<Output = T>, Length<N>: SupportedLength,

fn bitor_assign(&mut self, rhs: T)

Performs the |= operation.

impl<const N: usize, T, A: Alignment> BitOrAssign for Vector<N, T, A>

where T: Scalar + BitOr<Output = T>, Length<N>: SupportedLength,

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

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

where T: Scalar + BitXor<Output = T>, Length<N>: SupportedLength,

type Output = Vector<N, T, A>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

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

where T: Scalar + BitXor<Output = T>, Length<N>: SupportedLength,

type Output = Vector<N, T, A>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<const N: usize, T, A: Alignment> BitXorAssign<T> for Vector<N, T, A>

where T: Scalar + BitXor<Output = T>, Length<N>: SupportedLength,

fn bitxor_assign(&mut self, rhs: T)

Performs the ^= operation.

impl<const N: usize, T, A: Alignment> BitXorAssign for Vector<N, T, A>

where T: Scalar + BitXor<Output = T>, Length<N>: SupportedLength,

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

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

where T: Scalar, Length<N>: SupportedLength,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

where T: Scalar + Debug, Length<N>: SupportedLength,

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

Formats the value using the given formatter.

impl<const N: usize, T, A: Alignment> Default for Vector<N, T, A>

where T: Scalar + Default, Length<N>: SupportedLength,

fn default() -> Self

Returns the “default value” for a type.

impl<T, A: Alignment> Deref for Vector<2, T, A>

where T: Scalar,

type Target = Xy<T>

The resulting type after dereferencing.

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

Dereferences the value.

impl<T, A: Alignment> Deref for Vector<3, T, A>

where T: Scalar,

type Target = Xyz<T>

The resulting type after dereferencing.

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

Dereferences the value.

impl<T, A: Alignment> Deref for Vector<4, T, A>

where T: Scalar,

type Target = Xyzw<T>

The resulting type after dereferencing.

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

Dereferences the value.

impl<T, A: Alignment> DerefMut for Vector<2, T, A>

where T: Scalar,

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

Mutably dereferences the value.

impl<T, A: Alignment> DerefMut for Vector<3, T, A>

where T: Scalar,

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

Mutably dereferences the value.

impl<T, A: Alignment> DerefMut for Vector<4, T, A>

where T: Scalar,

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

Mutably dereferences the value.

impl<const N: usize, T, A: Alignment> Display for Vector<N, T, A>

where T: Scalar + Display, Length<N>: SupportedLength,

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

Formats the value using the given formatter.

impl<const N: usize, T, A: Alignment> Div<T> for Vector<N, T, A>

where T: Scalar + Div<Output = T>, Length<N>: SupportedLength,

type Output = Vector<N, T, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const N: usize, T, A: Alignment> Div for Vector<N, T, A>

where T: Scalar + Div<Output = T>, Length<N>: SupportedLength,

type Output = Vector<N, T, A>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<const N: usize, T, A: Alignment> DivAssign<T> for Vector<N, T, A>

where T: Scalar + Div<Output = T>, Length<N>: SupportedLength,

fn div_assign(&mut self, rhs: T)

Performs the /= operation.

impl<const N: usize, T, A: Alignment> DivAssign for Vector<N, T, A>

where T: Scalar + Div<Output = T>, Length<N>: SupportedLength,

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

impl<T, A: Alignment> From<(T,)> for Vector<2, T, A>

where T: Scalar,

fn from(value: (T,)) -> Self

Converts to this type from the input type.

impl<T, A: Alignment> From<(T,)> for Vector<3, T, A>

where T: Scalar,

fn from(value: (T,)) -> Self

Converts to this type from the input type.

impl<T, A: Alignment> From<(T,)> for Vector<4, T, A>

where T: Scalar,

fn from(value: (T,)) -> Self

Converts to this type from the input type.

impl<T, A: Alignment> From<(T, T)> for Vector<2, T, A>

where T: Scalar,

fn from(value: (T, T)) -> Self

Converts to this type from the input type.

impl<T, A: Alignment> From<(T, T, T)> for Vector<3, T, A>

where T: Scalar,

fn from(value: (T, T, T)) -> Self

Converts to this type from the input type.

impl<T, A: Alignment> From<(T, T, T, T)> for Vector<4, T, A>

where T: Scalar,

fn from(value: (T, T, T, T)) -> Self

Converts to this type from the input type.

impl<T, A: Alignment> From<(T, T, Vector<2, T, A>)> for Vector<4, T, A>

where T: Scalar,

fn from(value: (T, T, Vector<2, T, A>)) -> Self

Converts to this type from the input type.

impl<T, A: Alignment> From<(T, Vector<2, T, A>)> for Vector<3, T, A>

where T: Scalar,

fn from(value: (T, Vector<2, T, A>)) -> Self

Converts to this type from the input type.

impl<T, A: Alignment> From<(T, Vector<2, T, A>, T)> for Vector<4, T, A>

where T: Scalar,

fn from(value: (T, Vector<2, T, A>, T)) -> Self

Converts to this type from the input type.

impl<T, A: Alignment> From<(T, Vector<3, T, A>)> for Vector<4, T, A>

where T: Scalar,

fn from(value: (T, Vector<3, T, A>)) -> Self

Converts to this type from the input type.

impl<T, A: Alignment> From<(Vector<2, T, A>,)> for Vector<2, T, A>

where T: Scalar,

fn from(value: (Vector<2, T, A>,)) -> Self

Converts to this type from the input type.

impl<T, A: Alignment> From<(Vector<2, T, A>, T)> for Vector<3, T, A>

where T: Scalar,

fn from(value: (Vector<2, T, A>, T)) -> Self

Converts to this type from the input type.

impl<T, A: Alignment> From<(Vector<2, T, A>, T, T)> for Vector<4, T, A>

where T: Scalar,

fn from(value: (Vector<2, T, A>, T, T)) -> Self

Converts to this type from the input type.

impl<T, A: Alignment> From<(Vector<2, T, A>, Vector<2, T, A>)> for Vector<4, T, A>

where T: Scalar,

fn from(value: (Vector<2, T, A>, Vector<2, T, A>)) -> Self

Converts to this type from the input type.

impl<T, A: Alignment> From<(Vector<3, T, A>,)> for Vector<3, T, A>

where T: Scalar,

fn from(value: (Vector<3, T, A>,)) -> Self

Converts to this type from the input type.

impl<T, A: Alignment> From<(Vector<3, T, A>, T)> for Vector<4, T, A>

where T: Scalar,

fn from(value: (Vector<3, T, A>, T)) -> Self

Converts to this type from the input type.

impl<T, A: Alignment> From<(Vector<4, T, A>,)> for Vector<4, T, A>

where T: Scalar,

fn from(value: (Vector<4, T, A>,)) -> Self

Converts to this type from the input type.

impl<const N: usize, T, A: Alignment> Hash for Vector<N, T, A>

where T: Scalar + Hash, Length<N>: SupportedLength,

fn hash<H: Hasher>(&self, state: &mut H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<const N: usize, T, A: Alignment> Index<usize> for Vector<N, T, A>

where T: Scalar, Length<N>: SupportedLength,

type Output = T

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<const N: usize, T, A: Alignment> IndexMut<usize> for Vector<N, T, A>

where T: Scalar, Length<N>: SupportedLength,

fn index_mut(&mut self, index: usize) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<const N: usize, T, A: Alignment> IntoIterator for &Vector<N, T, A>

where T: Scalar, Length<N>: SupportedLength,

type Item = T

The type of the elements being iterated over.

type IntoIter = <[T; N] as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, const N: usize, T, A: Alignment> IntoIterator for &'a mut Vector<N, T, A>

where T: Scalar, Length<N>: SupportedLength,

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = <&'a mut [T; N] as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<const N: usize, T, A: Alignment> IntoIterator for Vector<N, T, A>

where T: Scalar, Length<N>: SupportedLength,

type Item = T

The type of the elements being iterated over.

type IntoIter = <[T; N] as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

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

where T: Scalar + Mul<Output = T>, Length<N>: SupportedLength,

type Output = Vector<N, T, A>

The resulting type after applying the * operator.

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

Performs the * operation.

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

where T: Scalar + Mul<Output = T>, Length<N>: SupportedLength,

type Output = Vector<N, T, A>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<const N: usize, T, A: Alignment> MulAssign<T> for Vector<N, T, A>

where T: Scalar + Mul<Output = T>, Length<N>: SupportedLength,

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl<const N: usize, T, A: Alignment> MulAssign for Vector<N, T, A>

where T: Scalar + Mul<Output = T>, Length<N>: SupportedLength,

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<const N: usize, T, A: Alignment> Neg for Vector<N, T, A>

where T: Scalar + Neg<Output = T>, Length<N>: SupportedLength,

type Output = Vector<N, T, A>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

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

where T: Scalar + Not<Output = T>, Length<N>: SupportedLength,

type Output = Vector<N, T, A>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<const N: usize, T, A: Alignment> PartialEq for Vector<N, T, A>

where T: Scalar + PartialEq, Length<N>: SupportedLength,

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Self) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<const N: usize, T, A: Alignment> Rem<T> for Vector<N, T, A>

where T: Scalar + Rem<Output = T>, Length<N>: SupportedLength,

type Output = Vector<N, T, A>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<const N: usize, T, A: Alignment> Rem for Vector<N, T, A>

where T: Scalar + Rem<Output = T>, Length<N>: SupportedLength,

type Output = Vector<N, T, A>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<const N: usize, T, A: Alignment> RemAssign<T> for Vector<N, T, A>

where T: Scalar + Rem<Output = T>, Length<N>: SupportedLength,

fn rem_assign(&mut self, rhs: T)

Performs the %= operation.

impl<const N: usize, T, A: Alignment> RemAssign for Vector<N, T, A>

where T: Scalar + Rem<Output = T>, Length<N>: SupportedLength,

fn rem_assign(&mut self, rhs: Self)

Performs the %= operation.

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

where T: Scalar + Shl<Output = T>, Length<N>: SupportedLength,

type Output = Vector<N, T, A>

The resulting type after applying the << operator.

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

Performs the << operation.

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

where T: Scalar + Shl<Output = T>, Length<N>: SupportedLength,

type Output = Vector<N, T, A>

The resulting type after applying the << operator.

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

Performs the << operation.

impl<const N: usize, T, A: Alignment> ShlAssign<T> for Vector<N, T, A>

where T: Scalar + Shl<Output = T>, Length<N>: SupportedLength,

fn shl_assign(&mut self, rhs: T)

Performs the <<= operation.

impl<const N: usize, T, A: Alignment> ShlAssign for Vector<N, T, A>

where T: Scalar + Shl<Output = T>, Length<N>: SupportedLength,

fn shl_assign(&mut self, rhs: Self)

Performs the <<= operation.

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

where T: Scalar + Shr<Output = T>, Length<N>: SupportedLength,

type Output = Vector<N, T, A>

The resulting type after applying the >> operator.

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

Performs the >> operation.

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

where T: Scalar + Shr<Output = T>, Length<N>: SupportedLength,

type Output = Vector<N, T, A>

The resulting type after applying the >> operator.

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

Performs the >> operation.

impl<const N: usize, T, A: Alignment> ShrAssign<T> for Vector<N, T, A>

where T: Scalar + Shr<Output = T>, Length<N>: SupportedLength,

fn shr_assign(&mut self, rhs: T)

Performs the >>= operation.

impl<const N: usize, T, A: Alignment> ShrAssign for Vector<N, T, A>

where T: Scalar + Shr<Output = T>, Length<N>: SupportedLength,

fn shr_assign(&mut self, rhs: Self)

Performs the >>= operation.

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

where T: Scalar + Sub<Output = T>, Length<N>: SupportedLength,

type Output = Vector<N, T, A>

The resulting type after applying the - operator.

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

Performs the - operation.

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

where T: Scalar + Sub<Output = T>, Length<N>: SupportedLength,

type Output = Vector<N, T, A>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<const N: usize, T, A: Alignment> SubAssign<T> for Vector<N, T, A>

where T: Scalar + Sub<Output = T>, Length<N>: SupportedLength,

fn sub_assign(&mut self, rhs: T)

Performs the -= operation.

impl<const N: usize, T, A: Alignment> SubAssign for Vector<N, T, A>

where T: Scalar + Sub<Output = T>, Length<N>: SupportedLength,

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

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

where T: Scalar, Length<N>: SupportedLength,

impl<const N: usize, T, A: Alignment> Eq for Vector<N, T, A>

where T: Scalar + Eq, Length<N>: SupportedLength,

impl<const N: usize, T, A: Alignment> RefUnwindSafe for Vector<N, T, A>

where T: Scalar + RefUnwindSafe, Length<N>: SupportedLength,

impl<const N: usize, T, A: Alignment> Send for Vector<N, T, A>

where T: Scalar + Send, Length<N>: SupportedLength,

impl<const N: usize, T, A: Alignment> Sync for Vector<N, T, A>

where T: Scalar + Sync, Length<N>: SupportedLength,

impl<const N: usize, T, A: Alignment> Unpin for Vector<N, T, A>

where T: Scalar + Unpin, Length<N>: SupportedLength,

impl<const N: usize, T, A: Alignment> UnwindSafe for Vector<N, T, A>

where T: Scalar + UnwindSafe, Length<N>: SupportedLength,