Struct Vector 

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

A generic vector type.

Vector is the generic form of:

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

Vector is generic over:

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

To initialize vectors, use the macros vec2, vec3, vec4. To initialize a vector of an unknown length, use Vector::from_array.

Guarantees

Vector<N, T, A> represents N consecutive values of T followed by optional padding due to alignment.

Padding bytes are initialized and accept any bit-pattern. It is sound to store any bit-pattern in padding, and it is unsound to assume that padding contains valid values of T unless T accepts all bit-patterns.

• Vector<N, T, Unaligned>: has no padding, has no additional alignment.

• Vector<2, T, Aligned>: has no padding, may have additional alignment.

• Vector<3, T, Aligned>: may have one padding element, may have additional alignment.

• Vector<4, T, Aligned>: has no padding, may have additional alignment.

Vectors of scalar types with the same Scalar::Repr are guaranteed to have compatible memory layouts, unless Repr = (). They are guaranteed to have the same size and element positions, but their alignment may differ.

Types containing Vector are not guaranteed to have the same memory layout as types containing equivalent arrays. For example, even though Vec2U<T> and [T; 2] have the same memory layout, Option<Vec2U<T>> and Option<[T; 2]> may not.

Implementations

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

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

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

Creates a vector from an array.

The preferable way to create vectors is using the macros vec2, vec3, vec4.

Vector::from_array should only be used when the length of the vector is unknown or when directly converting from an array.

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

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

pub fn from_fn<F>(f: F) -> Self

where F: FnMut(usize) -> T,

Creates a vector by calling function f for each component 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.

See Alignment for more information.

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

Converts the vector to Aligned alignment.

See Alignment for more information.

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

Converts the vector to Unaligned alignment.

See Alignment for more information.

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 components.

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

Returns a mutable reference to the vector’s components.

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

Returns an iterator over the vector’s components.

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 components.

pub fn map<T2, F>(self, f: F) -> Vector<N, T2, A>

where T2: Scalar, F: Fn(T) -> T2,

Creates a vector by calling function f for each component of the input vector.

Equivalent to (f(vec.x), f(vec.y), f(vec.z), ...).

Example

use ggmath::{Vec3, vec3};

let vec: Vec3<f32> = vec3!(1.0, 2.0, 3.0);

assert_eq!(vec.map(|x| x * 2.0), vec3!(2.0, 4.0, 6.0));

assert_eq!(vec.map(|x| x.is_sign_negative()), vec3!(false, false, false));

pub fn reverse(self) -> Self

Returns the vector’s components in reverse order.

Example

use ggmath::{Vec3, vec3};

let vec: Vec3<f32> = vec3!(1.0, 2.0, 3.0);

assert_eq!(vec.reverse(), vec3!(3.0, 2.0, 1.0));

pub fn eq_mask(self, other: Self) -> Mask<N, T, A>

where T: PartialEq,

Returns a mask where each component is true if the corresponding components of self and other are equal.

Equivalent to (self.x == other.x, self.y == other.y, ...).

pub fn ne_mask(self, other: Self) -> Mask<N, T, A>

where T: PartialEq,

Returns a mask where each component is true if the corresponding components of self and other are not equal.

Equivalent to (self.x != other.x, self.y != other.y, ...).

pub fn lt_mask(self, other: Self) -> Mask<N, T, A>

where T: PartialOrd,

Returns a mask where each component is true if the corresponding component of self is less than the corresponding component of other.

Equivalent to (self.x < other.x, self.y < other.y, ...).

pub fn gt_mask(self, other: Self) -> Mask<N, T, A>

where T: PartialOrd,

Returns a mask where each component is true if the corresponding component of self is greater than the corresponding component of other.

Equivalent to (self.x > other.x, self.y > other.y, ...).

pub fn le_mask(self, other: Self) -> Mask<N, T, A>

where T: PartialOrd,

Returns a mask where each component is true if the corresponding component of self is less than or equal to the corresponding component of other.

Equivalent to (self.x <= other.x, self.y <= other.y, ...).

pub fn ge_mask(self, other: Self) -> Mask<N, T, A>

where T: PartialOrd,

Returns a mask where each component is true if the corresponding component of self is greater than or equal to the corresponding component of other.

Equivalent to (self.x >= other.x, self.y >= other.y, ...).

pub const unsafe fn to_repr<T2>(self) -> Vector<N, T2, A>

where T2: Scalar<Repr = T::Repr>, T::Repr: SignedInteger,

Reinterprets the bits of the vector to a different scalar type.

The two scalar types must have compatible memory layouts. This is enforced via trait bounds in this function’s signature.

This function is used to make SIMD optimizations in implementations of Scalar.

Safety

The components of the input must be valid for the output vector type.

For example, when converting vectors from u8 to bool the input components must be either 0 or 1.

The optional padding does not need to be a valid value of T2.

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

where Length<N>: SupportedLength,

pub fn is_nan(self) -> bool

Returns true if any of the vector’s components are NaN.

pub fn nan_mask(self) -> Mask<N, f32, A>

Returns a mask where each component is true if the corresponding component of self is NaN (Not a Number).

Equivalent to (self.x.is_nan(), self.y.is_nan(), ...).

pub fn is_finite(self) -> bool

Returns true if all of the vector’s components are finite.

Finite corresponds to not NaN and not positive/negative infinity.

pub fn finite_mask(self) -> Mask<N, f32, A>

Returns a mask where each component is true if the corresponding component of self is finite.

Finite corresponds to not NaN and not positive/negative infinity.

Equivalent to (self.x.is_finite(), self.y.is_finite(), ...).

pub fn sign_positive_mask(self) -> Mask<N, f32, A>

Returns a mask where each component is true if the corresponding component of self has a positive sign.

Equivalent to (self.x.is_sign_positive(), self.y.is_sign_positive(), ...).

pub fn sign_negative_mask(self) -> Mask<N, f32, A>

Returns a mask where each component is true if the corresponding component of self has a negative sign.

Equivalent to (self.x.is_sign_negative(), self.y.is_sign_negative(), ...).

pub fn recip(self) -> Self

Computes 1.0 / self.

pub fn element_sum(self) -> f32

Computes the sum of the vector’s components.

Equivalent to self.x + self.y + ....

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 components.

Equivalent to self.x * self.y * ....

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.

Equivalent to (self.x.max(other.x), self.y.max(other.y), ...).

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

Panics

When assertions are enabled (see the crate documentation):

Panics if any input is NaN.

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

Returns the minimum between the components of self and other.

Equivalent to (self.x.min(other.x), self.y.min(other.y), ...).

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

Panics

When assertions are enabled (see the crate documentation):

Panics if any input is NaN.

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

Clamps the vector’s components between the components of min and max.

Equivalent to (self.x.clamp(min.x, max.x), self.y.clamp(min.y, max.y), ...).

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

Panics

When assertions are enabled (see the crate documentation):

Panics if any input is NaN, or if min > max.

pub fn max_element(self) -> f32

Returns the maximum between the vector’s components.

Equivalent to self.x.max(self.y).max(self.z)....

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

Panics

When assertions are enabled (see the crate documentation):

Panics if any input is NaN.

pub fn min_element(self) -> f32

Returns the minimum between the vector’s components.

Equivalent to self.x.min(self.y).min(self.z)....

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

Panics

When assertions are enabled (see the crate documentation):

Panics if any input is NaN.

pub fn abs(self) -> Self

Returns the absolute values of the vector’s components.

Equivalent to (self.x.abs(), self.y.abs(), ...).

pub fn signum(self) -> Self

Returns the signum of the vector’s components.

Equivalent to (self.x.signum(), self.y.signum(), ...).

For each component:

• 1.0 if the component is positive, +0.0 or INFINITY
• -1.0 if the component is negative, -0.0 or NEG_INFINITY
• 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.

Equivalent to (self.x.copysign(sign.x), self.y.copysign(sign.y), ...).

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 the vector.

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 middle point between self and other.

Equivalent to self.lerp(other, 0.5) but is cheaper to compute and may return a slightly different value.

pub fn is_normalized(self) -> bool

Returns whether the vector 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 (see the crate documentation):

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 (see the crate documentation):

Panics if other is not normalized.

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

Returns the vector rejection of self from other.

Corresponds to a vector pointing at self from the projection of self onto other, or simply self - self.project_onto(other).

other must not be a zero vector.

Panics

When assertions are enabled (see the crate documentation):

Panics if other is a zero vector.

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

Returns the vector rejection of self from other.

Corresponds to a vector pointing at self from the projection of self onto other, or simply self - self.project_onto(other).

other must be normalized.

Panics

When assertions are enabled (see the crate documentation):

Panics if other is not normalized.

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

Returns the reflection of self through normal.

normal must be normalized.

Panics

When assertions are enabled (see the crate documentation):

Panics if normal is not normalized.

Example

use ggmath::{Vec2, vec2};

let vec: Vec2<f32> = vec2!(1.0, 2.0);

assert_eq!(vec.reflect(Vec2::X), vec2!(-1.0, 2.0));

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 result 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 (see the crate documentation):

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 all orthogonal to each other and are normalized.

Panics

When assertions are enabled (see the crate documentation):

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 vector’s components down.

pub fn ceil(self) -> Self

Rounds the vector’s components up.

pub fn round(self) -> Self

Rounds the vector’s components to the nearest integer.

pub fn trunc(self) -> Self

Rounds the vector’s components towards zero.

pub fn fract(self) -> Self

Returns the fractional part of the vector.

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, yielding a more accurate result than an unfused multiply-add.

Using mul_add is slower than an unfused multiply-add on most target architectures.

Precision

The result of this operation is guaranteed to be the rounded infinite-precision result. It is specified by IEEE 754 as fusedMultiplyAdd and guaranteed not to change.

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

Euclidiean Division.

Equivalent to (self.x.div_euclid(rhs.x), self.y.div_euclid(rhs.y), ...).

Precision

The result of this operation is guaranteed to be the rounded infinite-precision result.

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

Euclidiean Remainder.

Equivalent to (self.x.rem_euclid(rhs.x), self.y.rem_euclid(rhs.y), ...).

Precision

The result of this operation is guaranteed to be the rounded infinite-precision result.

pub fn sqrt(self) -> Self

Returns the square root of the vector’s components.

Equivalent to (self.x.sqrt(), self.y.sqrt(), ...).

Precision

The result of this operation is guaranteed to be the rounded infinite-precision result. It is specified by IEEE 754 as squareRoot and guaranteed not to change.

pub fn sin(self) -> Self

Computes the sine of the vector’s components.

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

pub fn cos(self) -> Self

Computes the cosine of the vector’s components.

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

pub fn tan(self) -> Self

Computes the tangent of the vector’s components.

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

pub fn asin(self) -> Self

Computes the arcsine of the vector’s components.

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

pub fn acos(self) -> Self

Computes the arccosine of the vector’s components.

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

pub fn atan(self) -> Self

Computes the arctangent of the vector’s components.

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

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

Simultaneously computes the sine and cosine of the vector’s components.

Equivalent to (self.sin(), self.cos()) but may be more performant and might return a slightly different value.

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

pub fn length(self) -> f32

Returns the length/magnitude of the vector.

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 at most 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 (see the crate documentation):

Panics if the input is a zero vector, or if the result is non finite or zero.

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

Returns Self::normalize, or None if the input is zero or if the result is non finite or zero.

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

Returns Self::normalize, or fallback if the input is zero or if the result is non finite or zero.

pub fn normalize_or_zero(self) -> Self

Returns Self::normalize, or a zero vector if the input is zero or if the result is non finite.

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

Simultaneously computes Self::normalize and Self::length.

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

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

Returns the input vector but with a length of no more than max.

Panics

When assertions are enabled (see the crate documentation):

Panics if max is negative.

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

Returns the input vector but with a length of no less than min.

Panics

When assertions are enabled (see the crate documentation):

Panics if min is negative.

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

Returns the input vector buth with a length of no less than min and no more than max.

Panics

When assertions are enabled (see the crate documentation):

Panics if min > max, or if min or max are negative.

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

Returns the angle (in radians) between self and other in the range [0, +π].

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

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

pub fn exp(self) -> Self

Computes the exponential function e^self for the vector’s components.

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

pub fn exp2(self) -> Self

Computes 2^self for the vector’s components.

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

pub fn ln(self) -> Self

Computes the natural logarithm for the vector’s components.

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

pub fn log2(self) -> Self

Computes the base 2 logarithm for the vector’s components.

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

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

Computes self^n for the vector’s components.

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

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

Returns the vector refraction of self through normal and eta.

eta is the incident refraction-index divided by the transmitted refraction-index.

When total internal reflection occurs, the result is a zero vector.

self and normal must be normalized.

Panics

When assertions are enabled (see the crate documentation):

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).

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

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).

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

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

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

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

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

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

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

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

where Length<N>: SupportedLength,

pub fn is_nan(self) -> bool

Returns true if any of the vector’s components are NaN.

pub fn nan_mask(self) -> Mask<N, f64, A>

Returns a mask where each component is true if the corresponding component of self is NaN (Not a Number).

Equivalent to (self.x.is_nan(), self.y.is_nan(), ...).

pub fn is_finite(self) -> bool

Returns true if all of the vector’s components are finite.

Finite corresponds to not NaN and not positive/negative infinity.

pub fn finite_mask(self) -> Mask<N, f64, A>

Returns a mask where each component is true if the corresponding component of self is finite.

Finite corresponds to not NaN and not positive/negative infinity.

Equivalent to (self.x.is_finite(), self.y.is_finite(), ...).

pub fn sign_positive_mask(self) -> Mask<N, f64, A>

Returns a mask where each component is true if the corresponding component of self has a positive sign.

Equivalent to (self.x.is_sign_positive(), self.y.is_sign_positive(), ...).

pub fn sign_negative_mask(self) -> Mask<N, f64, A>

Returns a mask where each component is true if the corresponding component of self has a negative sign.

Equivalent to (self.x.is_sign_negative(), self.y.is_sign_negative(), ...).

pub fn recip(self) -> Self

Computes 1.0 / self.

pub fn element_sum(self) -> f64

Computes the sum of the vector’s components.

Equivalent to self.x + self.y + ....

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 components.

Equivalent to self.x * self.y * ....

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.

Equivalent to (self.x.max(other.x), self.y.max(other.y), ...).

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

Panics

When assertions are enabled (see the crate documentation):

Panics if any input is NaN.

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

Returns the minimum between the components of self and other.

Equivalent to (self.x.min(other.x), self.y.min(other.y), ...).

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

Panics

When assertions are enabled (see the crate documentation):

Panics if any input is NaN.

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

Clamps the vector’s components between the components of min and max.

Equivalent to (self.x.clamp(min.x, max.x), self.y.clamp(min.y, max.y), ...).

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

Panics

When assertions are enabled (see the crate documentation):

Panics if any input is NaN, or if min > max.

pub fn max_element(self) -> f64

Returns the maximum between the vector’s components.

Equivalent to self.x.max(self.y).max(self.z)....

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

Panics

When assertions are enabled (see the crate documentation):

Panics if any input is NaN.

pub fn min_element(self) -> f64

Returns the minimum between the vector’s components.

Equivalent to self.x.min(self.y).min(self.z)....

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

Panics

When assertions are enabled (see the crate documentation):

Panics if any input is NaN.

pub fn abs(self) -> Self

Returns the absolute values of the vector’s components.

Equivalent to (self.x.abs(), self.y.abs(), ...).

pub fn signum(self) -> Self

Returns the signum of the vector’s components.

Equivalent to (self.x.signum(), self.y.signum(), ...).

For each component:

• 1.0 if the component is positive, +0.0 or INFINITY
• -1.0 if the component is negative, -0.0 or NEG_INFINITY
• 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.

Equivalent to (self.x.copysign(sign.x), self.y.copysign(sign.y), ...).

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 the vector.

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 middle point between self and other.

Equivalent to self.lerp(other, 0.5) but is cheaper to compute and may return a slightly different value.

pub fn is_normalized(self) -> bool

Returns whether the vector 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 (see the crate documentation):

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 (see the crate documentation):

Panics if other is not normalized.

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

Returns the vector rejection of self from other.

Corresponds to a vector pointing at self from the projection of self onto other, or simply self - self.project_onto(other).

other must not be a zero vector.

Panics

When assertions are enabled (see the crate documentation):

Panics if other is a zero vector.

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

Returns the vector rejection of self from other.

Corresponds to a vector pointing at self from the projection of self onto other, or simply self - self.project_onto(other).

other must be normalized.

Panics

When assertions are enabled (see the crate documentation):

Panics if other is not normalized.

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

Returns the reflection of self through normal.

normal must be normalized.

Panics

When assertions are enabled (see the crate documentation):

Panics if normal is not normalized.

Example

use ggmath::{Vec2, vec2};

let vec: Vec2<f32> = vec2!(1.0, 2.0);

assert_eq!(vec.reflect(Vec2::X), vec2!(-1.0, 2.0));

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 result 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 (see the crate documentation):

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 all orthogonal to each other and are normalized.

Panics

When assertions are enabled (see the crate documentation):

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 vector’s components down.

pub fn ceil(self) -> Self

Rounds the vector’s components up.

pub fn round(self) -> Self

Rounds the vector’s components to the nearest integer.

pub fn trunc(self) -> Self

Rounds the vector’s components towards zero.

pub fn fract(self) -> Self

Returns the fractional part of the vector.

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, yielding a more accurate result than an unfused multiply-add.

Using mul_add is slower than an unfused multiply-add on most target architectures.

Precision

The result of this operation is guaranteed to be the rounded infinite-precision result. It is specified by IEEE 754 as fusedMultiplyAdd and guaranteed not to change.

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

Euclidiean Division.

Equivalent to (self.x.div_euclid(rhs.x), self.y.div_euclid(rhs.y), ...).

Precision

The result of this operation is guaranteed to be the rounded infinite-precision result.

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

Euclidiean Remainder.

Equivalent to (self.x.rem_euclid(rhs.x), self.y.rem_euclid(rhs.y), ...).

Precision

The result of this operation is guaranteed to be the rounded infinite-precision result.

pub fn sqrt(self) -> Self

Returns the square root of the vector’s components.

Equivalent to (self.x.sqrt(), self.y.sqrt(), ...).

Precision

The result of this operation is guaranteed to be the rounded infinite-precision result. It is specified by IEEE 754 as squareRoot and guaranteed not to change.

pub fn sin(self) -> Self

Computes the sine of the vector’s components.

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

pub fn cos(self) -> Self

Computes the cosine of the vector’s components.

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

pub fn tan(self) -> Self

Computes the tangent of the vector’s components.

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

pub fn asin(self) -> Self

Computes the arcsine of the vector’s components.

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

pub fn acos(self) -> Self

Computes the arccosine of the vector’s components.

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

pub fn atan(self) -> Self

Computes the arctangent of the vector’s components.

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

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

Simultaneously computes the sine and cosine of the vector’s components.

Equivalent to (self.sin(), self.cos()) but may be more performant and might return a slightly different value.

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

pub fn length(self) -> f64

Returns the length/magnitude of the vector.

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 at most 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 (see the crate documentation):

Panics if the input is a zero vector, or if the result is non finite or zero.

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

Returns Self::normalize, or None if the input is zero or if the result is non finite or zero.

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

Returns Self::normalize, or fallback if the input is zero or if the result is non finite or zero.

pub fn normalize_or_zero(self) -> Self

Returns Self::normalize, or a zero vector if the input is zero or if the result is non finite.

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

Simultaneously computes Self::normalize and Self::length.

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

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

Returns the input vector but with a length of no more than max.

Panics

When assertions are enabled (see the crate documentation):

Panics if max is negative.

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

Returns the input vector but with a length of no less than min.

Panics

When assertions are enabled (see the crate documentation):

Panics if min is negative.

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

Returns the input vector buth with a length of no less than min and no more than max.

Panics

When assertions are enabled (see the crate documentation):

Panics if min > max, or if min or max are negative.

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

Returns the angle (in radians) between self and other in the range [0, +π].

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

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

pub fn exp(self) -> Self

Computes the exponential function e^self for the vector’s components.

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

pub fn exp2(self) -> Self

Computes 2^self for the vector’s components.

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

pub fn ln(self) -> Self

Computes the natural logarithm for the vector’s components.

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

pub fn log2(self) -> Self

Computes the base 2 logarithm for the vector’s components.

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

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

Computes self^n for the vector’s components.

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

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

Returns the vector refraction of self through normal and eta.

eta is the incident refraction-index divided by the transmitted refraction-index.

When total internal reflection occurs, the result is a zero vector.

self and normal must be normalized.

Panics

When assertions are enabled (see the crate documentation):

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).

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

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).

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

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

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

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

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

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

Unspecified precision

The precision of this function is non-deterministic. This means it varies by platform, version, and can even differ within the same execution from one invocation to the next.

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 components.

Equivalent to self.x + self.y + ....

Panics

When assertions are enabled (see the crate documentation):

Panics if any addition overflows. Addition is performed in order.

pub fn element_product(self) -> i8

Computes the product of the vector’s components.

Equivalent to self.x * self.y * ....

Panics

When assertions are enabled (see the crate documentation):

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.

Equivalent to (self.x.max(other.x), self.y.max(other.y), ...).

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

Returns the minimum between the components of self and other.

Equivalent to (self.x.min(other.x), self.y.min(other.y), ...).

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

Clamps the vector’s components between the components of min and max.

Equivalent to (self.x.clamp(min.x, max.x), self.y.clamp(min.y, max.y), ...).

Panics

Panics if min > max.

pub fn max_element(self) -> i8

Returns the maximum between the vector’s components.

Equivalent to self.x.max(self.y).max(self.z)....

pub fn min_element(self) -> i8

Returns the minimum between the vector’s components.

Equivalent to self.x.min(self.y).min(self.z)....

pub fn abs(self) -> Self

Returns the absolute values of the vector’s components.

Equivalent to (self.x.abs(), self.y.abs(), ...).

Panics

When assertions are enabled (see the crate documentation) or overflow checks are enabled:

Panics if any component is $T::MIN.

pub fn signum(self) -> Self

Returns the signum of the vector’s components.

Equivalent to (self.x.signum(), self.y.signum(), ...).

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 are enabled (see the crate documentation) or overflow checks are enabled:

Panics if an overflow occurs.

pub fn length_squared(self) -> i8

Computes the squared length/magnitude of the vector.

Panics

When assertions are enabled (see the crate documentation) or overflow checks are enabled:

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 are enabled (see the crate documentation) or overflow checks are enabled:

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 overflow or division by zero occured.

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

Computes self % rhs, returning None if overflow or 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 saturating_div(self, rhs: Self) -> Self

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

Panics

Panics if any component of rhs is 0.

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

Panics if any component of rhs is 0.

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

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

Panics

Panics if any component of rhs is 0.

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 components.

Equivalent to self.x + self.y + ....

Panics

When assertions are enabled (see the crate documentation):

Panics if any addition overflows. Addition is performed in order.

pub fn element_product(self) -> i16

Computes the product of the vector’s components.

Equivalent to self.x * self.y * ....

Panics

When assertions are enabled (see the crate documentation):

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.

Equivalent to (self.x.max(other.x), self.y.max(other.y), ...).

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

Returns the minimum between the components of self and other.

Equivalent to (self.x.min(other.x), self.y.min(other.y), ...).

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

Clamps the vector’s components between the components of min and max.

Equivalent to (self.x.clamp(min.x, max.x), self.y.clamp(min.y, max.y), ...).

Panics

Panics if min > max.

pub fn max_element(self) -> i16

Returns the maximum between the vector’s components.

Equivalent to self.x.max(self.y).max(self.z)....

pub fn min_element(self) -> i16

Returns the minimum between the vector’s components.

Equivalent to self.x.min(self.y).min(self.z)....

pub fn abs(self) -> Self

Returns the absolute values of the vector’s components.

Equivalent to (self.x.abs(), self.y.abs(), ...).

Panics

When assertions are enabled (see the crate documentation) or overflow checks are enabled:

Panics if any component is $T::MIN.

pub fn signum(self) -> Self

Returns the signum of the vector’s components.

Equivalent to (self.x.signum(), self.y.signum(), ...).

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 are enabled (see the crate documentation) or overflow checks are enabled:

Panics if an overflow occurs.

pub fn length_squared(self) -> i16

Computes the squared length/magnitude of the vector.

Panics

When assertions are enabled (see the crate documentation) or overflow checks are enabled:

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 are enabled (see the crate documentation) or overflow checks are enabled:

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 overflow or division by zero occured.

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

Computes self % rhs, returning None if overflow or 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 saturating_div(self, rhs: Self) -> Self

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

Panics

Panics if any component of rhs is 0.

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

Panics if any component of rhs is 0.

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

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

Panics

Panics if any component of rhs is 0.

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 components.

Equivalent to self.x + self.y + ....

Panics

When assertions are enabled (see the crate documentation):

Panics if any addition overflows. Addition is performed in order.

pub fn element_product(self) -> i32

Computes the product of the vector’s components.

Equivalent to self.x * self.y * ....

Panics

When assertions are enabled (see the crate documentation):

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.

Equivalent to (self.x.max(other.x), self.y.max(other.y), ...).

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

Returns the minimum between the components of self and other.

Equivalent to (self.x.min(other.x), self.y.min(other.y), ...).

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

Clamps the vector’s components between the components of min and max.

Equivalent to (self.x.clamp(min.x, max.x), self.y.clamp(min.y, max.y), ...).

Panics

Panics if min > max.

pub fn max_element(self) -> i32

Returns the maximum between the vector’s components.

Equivalent to self.x.max(self.y).max(self.z)....

pub fn min_element(self) -> i32

Returns the minimum between the vector’s components.

Equivalent to self.x.min(self.y).min(self.z)....

pub fn abs(self) -> Self

Returns the absolute values of the vector’s components.

Equivalent to (self.x.abs(), self.y.abs(), ...).

Panics

When assertions are enabled (see the crate documentation) or overflow checks are enabled:

Panics if any component is $T::MIN.

pub fn signum(self) -> Self

Returns the signum of the vector’s components.

Equivalent to (self.x.signum(), self.y.signum(), ...).

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 are enabled (see the crate documentation) or overflow checks are enabled:

Panics if an overflow occurs.

pub fn length_squared(self) -> i32

Computes the squared length/magnitude of the vector.

Panics

When assertions are enabled (see the crate documentation) or overflow checks are enabled:

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 are enabled (see the crate documentation) or overflow checks are enabled:

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 overflow or division by zero occured.

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

Computes self % rhs, returning None if overflow or 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 saturating_div(self, rhs: Self) -> Self

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

Panics

Panics if any component of rhs is 0.

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

Panics if any component of rhs is 0.

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

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

Panics

Panics if any component of rhs is 0.

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 components.

Equivalent to self.x + self.y + ....

Panics

When assertions are enabled (see the crate documentation):

Panics if any addition overflows. Addition is performed in order.

pub fn element_product(self) -> i64

Computes the product of the vector’s components.

Equivalent to self.x * self.y * ....

Panics

When assertions are enabled (see the crate documentation):

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.

Equivalent to (self.x.max(other.x), self.y.max(other.y), ...).

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

Returns the minimum between the components of self and other.

Equivalent to (self.x.min(other.x), self.y.min(other.y), ...).

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

Clamps the vector’s components between the components of min and max.

Equivalent to (self.x.clamp(min.x, max.x), self.y.clamp(min.y, max.y), ...).

Panics

Panics if min > max.

pub fn max_element(self) -> i64

Returns the maximum between the vector’s components.

Equivalent to self.x.max(self.y).max(self.z)....

pub fn min_element(self) -> i64

Returns the minimum between the vector’s components.

Equivalent to self.x.min(self.y).min(self.z)....

pub fn abs(self) -> Self

Returns the absolute values of the vector’s components.

Equivalent to (self.x.abs(), self.y.abs(), ...).

Panics

When assertions are enabled (see the crate documentation) or overflow checks are enabled:

Panics if any component is $T::MIN.

pub fn signum(self) -> Self

Returns the signum of the vector’s components.

Equivalent to (self.x.signum(), self.y.signum(), ...).

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 are enabled (see the crate documentation) or overflow checks are enabled:

Panics if an overflow occurs.

pub fn length_squared(self) -> i64

Computes the squared length/magnitude of the vector.

Panics

When assertions are enabled (see the crate documentation) or overflow checks are enabled:

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 are enabled (see the crate documentation) or overflow checks are enabled:

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 overflow or division by zero occured.

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

Computes self % rhs, returning None if overflow or 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 saturating_div(self, rhs: Self) -> Self

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

Panics

Panics if any component of rhs is 0.

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

Panics if any component of rhs is 0.

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

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

Panics

Panics if any component of rhs is 0.

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 components.

Equivalent to self.x + self.y + ....

Panics

When assertions are enabled (see the crate documentation):

Panics if any addition overflows. Addition is performed in order.

pub fn element_product(self) -> i128

Computes the product of the vector’s components.

Equivalent to self.x * self.y * ....

Panics

When assertions are enabled (see the crate documentation):

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.

Equivalent to (self.x.max(other.x), self.y.max(other.y), ...).

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

Returns the minimum between the components of self and other.

Equivalent to (self.x.min(other.x), self.y.min(other.y), ...).

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

Clamps the vector’s components between the components of min and max.

Equivalent to (self.x.clamp(min.x, max.x), self.y.clamp(min.y, max.y), ...).

Panics

Panics if min > max.

pub fn max_element(self) -> i128

Returns the maximum between the vector’s components.

Equivalent to self.x.max(self.y).max(self.z)....

pub fn min_element(self) -> i128

Returns the minimum between the vector’s components.

Equivalent to self.x.min(self.y).min(self.z)....

pub fn abs(self) -> Self

Returns the absolute values of the vector’s components.

Equivalent to (self.x.abs(), self.y.abs(), ...).

Panics

When assertions are enabled (see the crate documentation) or overflow checks are enabled:

Panics if any component is $T::MIN.

pub fn signum(self) -> Self

Returns the signum of the vector’s components.

Equivalent to (self.x.signum(), self.y.signum(), ...).

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 are enabled (see the crate documentation) or overflow checks are enabled:

Panics if an overflow occurs.

pub fn length_squared(self) -> i128

Computes the squared length/magnitude of the vector.

Panics

When assertions are enabled (see the crate documentation) or overflow checks are enabled:

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 are enabled (see the crate documentation) or overflow checks are enabled:

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 overflow or division by zero occured.

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

Computes self % rhs, returning None if overflow or 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 saturating_div(self, rhs: Self) -> Self

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

Panics

Panics if any component of rhs is 0.

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

Panics if any component of rhs is 0.

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

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

Panics

Panics if any component of rhs is 0.

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 components.

Equivalent to self.x + self.y + ....

Panics

When assertions are enabled (see the crate documentation):

Panics if any addition overflows. Addition is performed in order.

pub fn element_product(self) -> isize

Computes the product of the vector’s components.

Equivalent to self.x * self.y * ....

Panics

When assertions are enabled (see the crate documentation):

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.

Equivalent to (self.x.max(other.x), self.y.max(other.y), ...).

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

Returns the minimum between the components of self and other.

Equivalent to (self.x.min(other.x), self.y.min(other.y), ...).

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

Clamps the vector’s components between the components of min and max.

Equivalent to (self.x.clamp(min.x, max.x), self.y.clamp(min.y, max.y), ...).

Panics

Panics if min > max.

pub fn max_element(self) -> isize

Returns the maximum between the vector’s components.

Equivalent to self.x.max(self.y).max(self.z)....

pub fn min_element(self) -> isize

Returns the minimum between the vector’s components.

Equivalent to self.x.min(self.y).min(self.z)....

pub fn abs(self) -> Self

Returns the absolute values of the vector’s components.

Equivalent to (self.x.abs(), self.y.abs(), ...).

Panics

When assertions are enabled (see the crate documentation) or overflow checks are enabled:

Panics if any component is $T::MIN.

pub fn signum(self) -> Self

Returns the signum of the vector’s components.

Equivalent to (self.x.signum(), self.y.signum(), ...).

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 are enabled (see the crate documentation) or overflow checks are enabled:

Panics if an overflow occurs.

pub fn length_squared(self) -> isize

Computes the squared length/magnitude of the vector.

Panics

When assertions are enabled (see the crate documentation) or overflow checks are enabled:

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 are enabled (see the crate documentation) or overflow checks are enabled:

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 overflow or division by zero occured.

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

Computes self % rhs, returning None if overflow or 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 saturating_div(self, rhs: Self) -> Self

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

Panics

Panics if any component of rhs is 0.

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

Panics if any component of rhs is 0.

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

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

Panics

Panics if any component of rhs is 0.

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 components.

Equivalent to self.x + self.y + ....

Panics

When assertions are enabled (see the crate documentation):

Panics if any addition overflows. Addition is performed in order.

pub fn element_product(self) -> u8

Computes the product of the vector’s components.

Equivalent to self.x * self.y * ....

Panics

When assertions are enabled (see the crate documentation):

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.

Equivalent to (self.x.max(other.x), self.y.max(other.y), ...).

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

Returns the minimum between the components of self and other.

Equivalent to (self.x.min(other.x), self.y.min(other.y), ...).

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

Clamps the vector’s components between the components of min and max.

Equivalent to (self.x.clamp(min.x, max.x), self.y.clamp(min.y, max.y), ...).

Panics

Panics if min > max.

pub fn max_element(self) -> u8

Returns the maximum between the vector’s components.

Equivalent to self.x.max(self.y).max(self.z)....

pub fn min_element(self) -> u8

Returns the minimum between the vector’s components.

Equivalent to self.x.min(self.y).min(self.z)....

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

Computes the dot product of self and rhs.

Panics

When assertions are enabled (see the crate documentation) or overflow checks are enabled:

Panics if an overflow occurs.

pub fn length_squared(self) -> u8

Computes the squared length/magnitude of the vector.

Panics

When assertions are enabled (see the crate documentation) or overflow checks are enabled:

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 components.

Equivalent to self.x + self.y + ....

Panics

When assertions are enabled (see the crate documentation):

Panics if any addition overflows. Addition is performed in order.

pub fn element_product(self) -> u16

Computes the product of the vector’s components.

Equivalent to self.x * self.y * ....

Panics

When assertions are enabled (see the crate documentation):

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.

Equivalent to (self.x.max(other.x), self.y.max(other.y), ...).

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

Returns the minimum between the components of self and other.

Equivalent to (self.x.min(other.x), self.y.min(other.y), ...).

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

Clamps the vector’s components between the components of min and max.

Equivalent to (self.x.clamp(min.x, max.x), self.y.clamp(min.y, max.y), ...).

Panics

Panics if min > max.

pub fn max_element(self) -> u16

Returns the maximum between the vector’s components.

Equivalent to self.x.max(self.y).max(self.z)....

pub fn min_element(self) -> u16

Returns the minimum between the vector’s components.

Equivalent to self.x.min(self.y).min(self.z)....

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

Computes the dot product of self and rhs.

Panics

When assertions are enabled (see the crate documentation) or overflow checks are enabled:

Panics if an overflow occurs.

pub fn length_squared(self) -> u16

Computes the squared length/magnitude of the vector.

Panics

When assertions are enabled (see the crate documentation) or overflow checks are enabled:

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 components.

Equivalent to self.x + self.y + ....

Panics

When assertions are enabled (see the crate documentation):

Panics if any addition overflows. Addition is performed in order.

pub fn element_product(self) -> u32

Computes the product of the vector’s components.

Equivalent to self.x * self.y * ....

Panics

When assertions are enabled (see the crate documentation):

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.

Equivalent to (self.x.max(other.x), self.y.max(other.y), ...).

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

Returns the minimum between the components of self and other.

Equivalent to (self.x.min(other.x), self.y.min(other.y), ...).

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

Clamps the vector’s components between the components of min and max.

Equivalent to (self.x.clamp(min.x, max.x), self.y.clamp(min.y, max.y), ...).

Panics

Panics if min > max.

pub fn max_element(self) -> u32

Returns the maximum between the vector’s components.

Equivalent to self.x.max(self.y).max(self.z)....

pub fn min_element(self) -> u32

Returns the minimum between the vector’s components.

Equivalent to self.x.min(self.y).min(self.z)....

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

Computes the dot product of self and rhs.

Panics

When assertions are enabled (see the crate documentation) or overflow checks are enabled:

Panics if an overflow occurs.

pub fn length_squared(self) -> u32

Computes the squared length/magnitude of the vector.

Panics

When assertions are enabled (see the crate documentation) or overflow checks are enabled:

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 components.

Equivalent to self.x + self.y + ....

Panics

When assertions are enabled (see the crate documentation):

Panics if any addition overflows. Addition is performed in order.

pub fn element_product(self) -> u64

Computes the product of the vector’s components.

Equivalent to self.x * self.y * ....

Panics

When assertions are enabled (see the crate documentation):

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.

Equivalent to (self.x.max(other.x), self.y.max(other.y), ...).

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

Returns the minimum between the components of self and other.

Equivalent to (self.x.min(other.x), self.y.min(other.y), ...).

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

Clamps the vector’s components between the components of min and max.

Equivalent to (self.x.clamp(min.x, max.x), self.y.clamp(min.y, max.y), ...).

Panics

Panics if min > max.

pub fn max_element(self) -> u64

Returns the maximum between the vector’s components.

Equivalent to self.x.max(self.y).max(self.z)....

pub fn min_element(self) -> u64

Returns the minimum between the vector’s components.

Equivalent to self.x.min(self.y).min(self.z)....

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

Computes the dot product of self and rhs.

Panics

When assertions are enabled (see the crate documentation) or overflow checks are enabled:

Panics if an overflow occurs.

pub fn length_squared(self) -> u64

Computes the squared length/magnitude of the vector.

Panics

When assertions are enabled (see the crate documentation) or overflow checks are enabled:

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 components.

Equivalent to self.x + self.y + ....

Panics

When assertions are enabled (see the crate documentation):

Panics if any addition overflows. Addition is performed in order.

pub fn element_product(self) -> u128

Computes the product of the vector’s components.

Equivalent to self.x * self.y * ....

Panics

When assertions are enabled (see the crate documentation):

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.

Equivalent to (self.x.max(other.x), self.y.max(other.y), ...).

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

Returns the minimum between the components of self and other.

Equivalent to (self.x.min(other.x), self.y.min(other.y), ...).

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

Clamps the vector’s components between the components of min and max.

Equivalent to (self.x.clamp(min.x, max.x), self.y.clamp(min.y, max.y), ...).

Panics

Panics if min > max.

pub fn max_element(self) -> u128

Returns the maximum between the vector’s components.

Equivalent to self.x.max(self.y).max(self.z)....

pub fn min_element(self) -> u128

Returns the minimum between the vector’s components.

Equivalent to self.x.min(self.y).min(self.z)....

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

Computes the dot product of self and rhs.

Panics

When assertions are enabled (see the crate documentation) or overflow checks are enabled:

Panics if an overflow occurs.

pub fn length_squared(self) -> u128

Computes the squared length/magnitude of the vector.

Panics

When assertions are enabled (see the crate documentation) or overflow checks are enabled:

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 components.

Equivalent to self.x + self.y + ....

Panics

When assertions are enabled (see the crate documentation):

Panics if any addition overflows. Addition is performed in order.

pub fn element_product(self) -> usize

Computes the product of the vector’s components.

Equivalent to self.x * self.y * ....

Panics

When assertions are enabled (see the crate documentation):

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.

Equivalent to (self.x.max(other.x), self.y.max(other.y), ...).

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

Returns the minimum between the components of self and other.

Equivalent to (self.x.min(other.x), self.y.min(other.y), ...).

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

Clamps the vector’s components between the components of min and max.

Equivalent to (self.x.clamp(min.x, max.x), self.y.clamp(min.y, max.y), ...).

Panics

Panics if min > max.

pub fn max_element(self) -> usize

Returns the maximum between the vector’s components.

Equivalent to self.x.max(self.y).max(self.z)....

pub fn min_element(self) -> usize

Returns the minimum between the vector’s components.

Equivalent to self.x.min(self.y).min(self.z)....

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

Computes the dot product of self and rhs.

Panics

When assertions are enabled (see the crate documentation) or overflow checks are enabled:

Panics if an overflow occurs.

pub fn length_squared(self) -> usize

Computes the squared length/magnitude of the vector.

Panics

When assertions are enabled (see the crate documentation) or overflow checks are enabled:

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 of the vector’s components are true.

pub fn any(self) -> bool

Returns true if any of the vector’s components are true.

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

Selects between the components of if_true and if_false based on the boolean values of the vector.

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

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

pub const ZERO: Self

All 0.

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

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

pub const ONE: Self

All 1.

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

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

pub const NEG_ONE: Self

All -1.

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

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

pub const MIN: Self

All T::MIN.

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

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

pub const MAX: Self

All T::MAX.

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

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

pub const NAN: Self

All NaN (Not a Number).

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

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

pub const INFINITY: Self

All T::INFINITY.

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

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

pub const NEG_INFINITY: Self

All T::NEG_INFINITY.

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

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

pub const TRUE: Self

All true.

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

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

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 Length<N>: SupportedLength, T: Scalar + Add<Output = T>,

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 Length<N>: SupportedLength, T: Scalar + Add<Output = T>,

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 Length<N>: SupportedLength, T: Scalar + Add<Output = T>,

fn add_assign(&mut self, rhs: T)

Performs the += operation.

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

where Length<N>: SupportedLength, T: Scalar + Add<Output = T>,

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 Length<N>: SupportedLength, T: Scalar + BitAnd<Output = T>,

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 Length<N>: SupportedLength, T: Scalar + BitAnd<Output = T>,

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 Length<N>: SupportedLength, T: Scalar + BitAnd<Output = T>,

fn bitand_assign(&mut self, rhs: T)

Performs the &= operation.

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

where Length<N>: SupportedLength, T: Scalar + BitAnd<Output = T>,

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 Length<N>: SupportedLength, T: Scalar + BitOr<Output = T>,

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 Length<N>: SupportedLength, T: Scalar + BitOr<Output = T>,

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 Length<N>: SupportedLength, T: Scalar + BitOr<Output = T>,

fn bitor_assign(&mut self, rhs: T)

Performs the |= operation.

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

where Length<N>: SupportedLength, T: Scalar + BitOr<Output = T>,

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 Length<N>: SupportedLength, T: Scalar + BitXor<Output = T>,

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 Length<N>: SupportedLength, T: Scalar + BitXor<Output = T>,

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 Length<N>: SupportedLength, T: Scalar + BitXor<Output = T>,

fn bitxor_assign(&mut self, rhs: T)

Performs the ^= operation.

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

where Length<N>: SupportedLength, T: Scalar + BitXor<Output = T>,

fn bitxor_assign(&mut self, rhs: Self)

Performs the ^= operation.

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

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

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 Length<N>: SupportedLength, T: Scalar + Debug,

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 Length<N>: SupportedLength, T: Scalar + Default,

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 Length<N>: SupportedLength, T: Scalar + Display,

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 Length<N>: SupportedLength, T: Scalar + Div<Output = T>,

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 Length<N>: SupportedLength, T: Scalar + Div<Output = T>,

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 Length<N>: SupportedLength, T: Scalar + Div<Output = T>,

fn div_assign(&mut self, rhs: T)

Performs the /= operation.

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

where Length<N>: SupportedLength, T: Scalar + Div<Output = T>,

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 Length<N>: SupportedLength, T: Scalar + Hash,

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 Length<N>: SupportedLength, T: Scalar,

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 Length<N>: SupportedLength, T: Scalar,

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 Length<N>: SupportedLength, T: Scalar,

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 Length<N>: SupportedLength, T: Scalar,

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 Length<N>: SupportedLength, T: Scalar,

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 Length<N>: SupportedLength, T: Scalar + Mul<Output = T>,

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 Length<N>: SupportedLength, T: Scalar + Mul<Output = T>,

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 Length<N>: SupportedLength, T: Scalar + Mul<Output = T>,

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

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

where Length<N>: SupportedLength, T: Scalar + Mul<Output = T>,

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

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

where Length<N>: SupportedLength, T: Scalar + Neg<Output = T>,

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 Length<N>: SupportedLength, T: Scalar + Not<Output = T>,

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 Length<N>: SupportedLength, T: Scalar + PartialEq,

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 Length<N>: SupportedLength, T: Scalar + Rem<Output = T>,

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 Length<N>: SupportedLength, T: Scalar + Rem<Output = T>,

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 Length<N>: SupportedLength, T: Scalar + Rem<Output = T>,

fn rem_assign(&mut self, rhs: T)

Performs the %= operation.

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

where Length<N>: SupportedLength, T: Scalar + Rem<Output = T>,

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 Length<N>: SupportedLength, T: Scalar + Shl<Output = T>,

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 Length<N>: SupportedLength, T: Scalar + Shl<Output = T>,

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 Length<N>: SupportedLength, T: Scalar + Shl<Output = T>,

fn shl_assign(&mut self, rhs: T)

Performs the <<= operation.

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

where Length<N>: SupportedLength, T: Scalar + Shl<Output = T>,

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 Length<N>: SupportedLength, T: Scalar + Shr<Output = T>,

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 Length<N>: SupportedLength, T: Scalar + Shr<Output = T>,

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 Length<N>: SupportedLength, T: Scalar + Shr<Output = T>,

fn shr_assign(&mut self, rhs: T)

Performs the >>= operation.

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

where Length<N>: SupportedLength, T: Scalar + Shr<Output = T>,

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 Length<N>: SupportedLength, T: Scalar + Sub<Output = T>,

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 Length<N>: SupportedLength, T: Scalar + Sub<Output = T>,

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 Length<N>: SupportedLength, T: Scalar + Sub<Output = T>,

fn sub_assign(&mut self, rhs: T)

Performs the -= operation.

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

where Length<N>: SupportedLength, T: Scalar + Sub<Output = T>,

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

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

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

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

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

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

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

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

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

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

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

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

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

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

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