Struct Vector

Source

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

Expand description

An N-dimensional vector of type T.

A controls SIMD alignment and is either Unaligned or Aligned. See Alignment for more details.

§Type aliases

Vec2<T> for Vector<2, T, Unaligned>.
Vec3<T> for Vector<3, T, Unaligned>.
Vec4<T> for Vector<4, T, Unaligned>.
Vec2A<T> for Vector<2, T, Aligned>.
Vec3A<T> for Vector<3, T, Aligned>.
Vec4A<T> for Vector<4, T, Aligned>.

§Fields

x: T (the first element of the vector, exists for lengths 2, 3, 4)
y: T (the second element of the vector, exists for lengths 2, 3, 4)
z: T (the third element of the vector, exists for lengths 3, 4)
w: T (the fourth element of the vector, exists for length 4)

Note that these fields are only exposed by implementing Deref and DerefMut.

§Memory layout

Vector<N, T, A> contains N consecutive values of T followed by optional padding.

Vector<N, T, Unaligned> has the alignment of T and has no padding. Vector<N, T, Aligned> may have higher alignment than T. Vec2A<T> and Vec4A<T> have no padding. Vec3A<T> may have one padding element.

Padding is fully initialized and accepts all bit patterns. Unless T accepts all bit patterns, it is not sound to assume padding contains valid values of T.

Implementations§

Source §

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

Source

pub const FALSE: Self

A vector with all elements set to false.

A vector with all elements set to MAX.

Source

pub const NAN: Self

A vector with all elements set to NaN (Not a Number).

Source

pub const INFINITY: Self

A vector with all elements set to INFINITY.

Source

pub const NEG_INFINITY: Self

A vector with all elements set to NEG_INFINITY.

Source

pub fn is_nan(self) -> bool

Returns true if any element is NaN.

§Examples

let nan = Vec3::new(1.0, 2.0, f32::NAN);
let f = Vec3::new(1.0, 2.0, 3.0);

assert!(nan.is_nan());
assert!(!f.is_nan());

Source

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

Returns a vector mask where each element is true if the corresponding element of self is NaN.

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

§Examples

let vector = Vec3::new(1.0, 2.0, f32::NAN);
let mask = vector.nan_mask();

assert_eq!(mask, Mask3::new(false, false, true));

Source

pub fn is_finite(self) -> bool

Returns true if all elements are neither infinite nor NaN.

§Examples

let f = Vec3::new(1.0, 2.0, 3.0);
let inf = Vec3::new(1.0, f32::INFINITY, 3.0);
let neg_inf = Vec3::new(1.0, f32::NEG_INFINITY, 3.0);
let nan = Vec3::new(1.0, f32::NEG_INFINITY, 3.0);

assert!(f.is_finite());
assert!(!inf.is_finite());
assert!(!neg_inf.is_finite());
assert!(!nan.is_finite());

Source

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

Returns a vector mask where each element is true if the corresponding element of self is neither infinite nor NaN.

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

§Examples

let vector = Vec3::new(1.0, f32::INFINITY, f32::NAN);
let mask = vector.finite_mask();

assert_eq!(mask, Mask3::new(true, false, false));

Source

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

Returns a vector mask where each element is true if the corresponding element of self has a positive sign, including +0.0, NaNs with positive sign bit and positive infinity.

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

§Examples

let vector = Vec4::new(1.0, -2.0, -3.0, f32::INFINITY);
let mask = vector.sign_positive_mask();

assert_eq!(mask, Mask4::new(true, false, false, true));

Source

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

Returns a vector mask where each element is true if the corresponding element of self has a negative sign, including -0.0, NaNs with negative sign bit and negative infinity.

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

§Examples

let vector = Vec4::new(1.0, -2.0, 3.0, f32::NEG_INFINITY);
let mask = vector.sign_negative_mask();

assert_eq!(mask, Mask4::new(false, true, false, true));

Source

pub fn recip(self) -> Self

Returns the element-wise reciprocal (inverse) of a vector, 1 / self.

§Examples

let vector = Vec3::new(2.0, 3.0, 4.0);
let recip = vector.recip();
let div = Vec3::ONE / vector;

assert_eq!(recip, div);

Source

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

Returns the maximum elements between self and other.

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

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

§Panics

When debug assertions are enabled:

Panics if any element is NaN.

§Examples

let a = Vec4::new(1.0, 5.0, 3.0, 0.0);
let b = Vec4::new(3.0, 2.0, 7.0, -1.0);
let max = a.max(b);

assert_eq!(max, Vec4::new(3.0, 5.0, 7.0, 0.0));

Source

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

Returns the minimum elements between self and other.

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

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

§Panics

When debug assertions are enabled:

Panics if any element is NaN.

§Examples

let a = Vec4::new(1.0, 5.0, 3.0, 0.0);
let b = Vec4::new(3.0, 2.0, 7.0, -1.0);
let min = a.min(b);

assert_eq!(min, Vec4::new(1.0, 2.0, 3.0, -1.0));

Source

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

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

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

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

§Panics

When debug assertions are enabled:

Panics if any element is NaN, or if any element of min is greater than the corresponding element of max.

§Examples

let vector = Vec4::new(1.0, 2.0, 3.0, 0.0);
let min = Vec4::new(0.0, 5.0, 1.0, -2.0);
let max = Vec4::new(3.0, 6.0, 2.0, -1.0);
let clamp = vector.clamp(min, max);

assert_eq!(clamp, Vec4::new(1.0, 5.0, 2.0, -1.0));

Source

pub fn max_element(self) -> T

Returns the maximum between the elements of self.

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

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

§Panics

When debug assertions are enabled:

Panics if any element is NaN.

§Examples

let vector = Vec3::new(-1.0, 7.0, 3.0);

assert_eq!(vector.max_element(), 7.0);

Source

pub fn min_element(self) -> T

Returns the minimum between the elements of self.

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

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

§Panics

When debug assertions are enabled:

Panics if any element is NaN.

§Examples

let vector = Vec3::new(7.0, -1.0, 3.0);

assert_eq!(vector.min_element(), -1.0);

Source

pub fn abs(self) -> Self

Returns the absolute values of elements of self.

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

§Examples

let vector = Vec3::new(7.0, -1.0, -3.0);

assert_eq!(vector.abs(), Vec3::new(7.0, 1.0, 3.0));

Source

pub fn signum(self) -> Self

Returns the signum of the elements of self.

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

For each element:

1.0 if the element is positive, +0.0 or INFINITY
-1.0 if the element is negative, -0.0 or NEG_INFINITY
NaN if the element is NaN

§Examples

let vector = Vec4::new(7.0, -1.0, -3.0, f32::NAN);

assert_eq!(vector.signum().x, 1.0);
assert_eq!(vector.signum().y, -1.0);
assert_eq!(vector.signum().z, -1.0);
assert!(vector.signum().w.is_nan());

Source

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

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

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

§Examples

let vector = Vec3::new(7.0, -1.0, -3.0);
let sign = Vec3::new(-5.0, -2.0, 1.0);
let copysign = vector.copysign(sign);

assert_eq!(copysign, Vec3::new(-7.0, -1.0, 3.0));

Source

pub fn floor(self) -> Self

Returns the largest integers less than or equal to the elements of self.

This always returns the precise result.

§Examples

let vector = Vec3::new(3.7, 3.0, -3.7);

assert_eq!(vector.floor(), Vec3::new(3.0, 3.0, -4.0));

Source

pub fn ceil(self) -> Self

Returns the smallest integers greater than or equal to the elements of self.

This always returns the precise result.

§Examples

let vector = Vec3::new(3.01, 4.0, -4.99);

assert_eq!(vector.ceil(), Vec3::new(4.0, 4.0, -4.0));

Source

pub fn round(self) -> Self

Returns the nearest integers to the elements of self.

This always returns the precise result. If a value is half-way between two integers, round away from 0.0.

§Examples

let vector = Vec3::new(3.3, -3.3, 3.5);

assert_eq!(vector.round(), Vec3::new(3.0, -3.0, 4.0));

Source

pub fn trunc(self) -> Self

Returns the integer part of the elements of self. This means that non-integer numbers are always truncated towards zero.

This always returns the precise result.

§Examples

let vector = Vec3::new(3.7, 3.0, -3.7);

assert_eq!(vector.trunc(), Vec3::new(3.0, 3.0, -3.0));

Source

pub fn fract(self) -> Self

Returns the fractional part of self. Equivalent to self - self.trunc().

This always returns the precise result.

§Examples

let vector = Vec2::new(3.25, -3.25);

assert_eq!(vector.fract(), Vec2::new(0.25, -0.25));

Source

Computes x^n for the elements of self.

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

Computes the base 2 logarithm for the elements of self.

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

§Examples

let vector = Vec3::new(2.0, 4.0, 8.0);

assert_eq!(vector.log2(), Vec3::new(1.0, 2.0, 3.0));

Source

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

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

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

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.

let vector = Vec3::new(2.0, 0.0, 0.0);
let target = Vec3::new(5.0, 0.0, 0.0);
let max_delta = 1.0;
let move_towards = vector.move_towards(target, max_delta);

assert_eq!(move_towards, Vec3::new(3.0, 0.0, 0.0));

Source

pub fn slerp(self, other: Self, t: T) -> Self

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

When t is 0, the result is self. When t is 1, the result is other. When t is outside of the range 0..=1, the result is spherically linearly extrapolated.

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

§Panics

When debug assertions are enabled:

Panics if self or other are zero vectors.

Source

pub fn rotate_towards(self, target: Self, max_angle: T) -> Self

Rotates self towards target by at most max_angle (in radians).

When max_angle is 0, the result is self. When max_angle is equal to or greater than self.angle_between(target), the result is target. When max_angle is negative, this rotates towards -target.

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

§Panics

When debug assertions are enabled:

When debug assertions are enabled:

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

§Examples

let vector = Vec3::new(1.0, 2.0, 3.0);

assert_eq!(vector.normalize(), vector / vector.length());

Source

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

Returns normalize, or None if self is zero or if the result is non finite or zero.

§Examples

let non_zero = Vec3::new(1.0, 2.0, 3.0);
let zero = Vec3::new(0.0, 0.0, 0.0);

assert_eq!(non_zero.try_normalize(), Some(non_zero.normalize()));
assert_eq!(zero.try_normalize(), None);

Source

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

Returns normalize, or fallback if self is zero or if the result is non finite or zero.

§Examples

let non_zero = Vec3::new(1.0, 2.0, 3.0);
let zero = Vec3::new(0.0, 0.0, 0.0);
let fallback = Vec3::new(9.0, 10.0, 21.0);

assert_eq!(non_zero.normalize_or(fallback), non_zero.normalize());
assert_eq!(zero.normalize_or(fallback), fallback);

Source

pub fn normalize_or_zero(self) -> Self

Returns normalize, or a zero vector if self is zero or if the result is non finite.

§Examples

let non_zero = Vec3::new(1.0, 2.0, 3.0);
let zero = Vec3::new(0.0, 0.0, 0.0);

assert_eq!(non_zero.normalize_or_zero(), non_zero.normalize());
assert_eq!(zero.normalize_or_zero(), zero);

Source

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

Simultaneously computes normalize and length.

If self is a zero vector, the result is length 0 and an unspecified vector. Consider manually checking for length == 0.0.

§Examples

let vector = Vec3::new(1.0, 2.0, 3.0);
let (normalize, length) = vector.normalize_and_length();

assert_eq!(normalize, vector.normalize());
assert_eq!(length, vector.length());

Source

pub fn is_normalized(self) -> bool

Returns whether the vector has the length 1.0 or not.

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

§Examples

let unit = Vec3::splat((1.0_f32 / 3.0).sqrt());
let non_unit = Vec3::splat(2.0);

assert!(unit.is_normalized());
assert!(!non_unit.is_normalized());

Source

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

Returns self with a length of no more than max.

§Panics

When debug assertions are enabled:

Panics if max is negative or self cannot be normalized.

§Examples

let a = Vec3::new(2.0, 0.0, 0.0);
let b = Vec3::new(6.0, 0.0, 0.0);
let max = 4.0;

assert_eq!(a.with_max_length(max), Vec3::new(2.0, 0.0, 0.0));
assert_eq!(b.with_max_length(max), Vec3::new(4.0, 0.0, 0.0));

Source

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

Returns self with a length of no less than min.

If min is negative, this returns self.

§Panics

When debug assertions are enabled:

Panics if self cannot be normalized.

§Examples

let a = Vec3::new(2.0, 0.0, 0.0);
let b = Vec3::new(6.0, 0.0, 0.0);
let min = 4.0;

assert_eq!(a.with_min_length(min), Vec3::new(4.0, 0.0, 0.0));
assert_eq!(b.with_min_length(min), Vec3::new(6.0, 0.0, 0.0));

Source

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

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

If min is negative it is ignored.

§Panics

When debug assertions are enabled:

Panics if min > max, max is negative or self cannot be normalized.

§Examples

let a = Vec3::new(2.0, 0.0, 0.0);
let b = Vec3::new(6.0, 0.0, 0.0);
let c = Vec3::new(10.0, 0.0, 0.0);
let min = 4.0;
let max = 8.0;

assert_eq!(a.clamp_length(min, max), Vec3::new(4.0, 0.0, 0.0));
assert_eq!(b.clamp_length(min, max), Vec3::new(6.0, 0.0, 0.0));
assert_eq!(c.clamp_length(min, max), Vec3::new(8.0, 0.0, 0.0));

Source

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

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.

§Panics

When debug assertions are enabled:

Panics if self or other are zero vectors.

§Examples

let x = Vec3::new(2.0, 0.0, 0.0);
let y = Vec3::new(0.0, 3.0, 0.0);
let angle = x.angle_between(y);

assert!((angle - 90.0_f32.to_radians()).abs() < 1e-5);

Source

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 debug assertions are enabled:

Panics if other is a zero vector.

Source

Returns the reflection of self through normal.

normal must be normalized.

§Panics

When debug assertions are enabled:

Panics if normal is not normalized.

Source

pub fn refract(self, normal: Self, eta: T) -> 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 debug assertions are enabled:

Panics if self or normal are not normalized.

Source

pub fn any_orthogonal_vector(self) -> Self

Returns some vector that is orthogonal to self.

Source

pub fn angle_to(self, other: Self) -> T

Returns the angle (in radians) that rotates self to other in the range -π..=+π.

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

Equivalent to other.angle_from(self).

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

§Panics

When debug assertions are enabled:

Panics if self or other are zero vectors.

§Examples

let x = Vec2::new(2.0, 0.0);
let y = Vec2::new(0.0, 3.0);

assert!(x.angle_to(y) > 0.0);
assert!(y.angle_to(x) < 0.0);

Source

pub fn angle_from(self, other: Self) -> T

Returns the angle (in radians) that rotates other to self in the range -π..=+π.

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

Equivalent to other.angle_to(self).

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

§Panics

When debug assertions are enabled:

Panics if self or other are zero vectors.

§Examples

let x = Vec2::new(2.0, 0.0);
let y = Vec2::new(0.0, 3.0);

assert!(x.angle_from(y) < 0.0);
assert!(y.angle_from(x) > 0.0);

Source

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

Rotates self by angle (in radians).

This rotates +X to +Y.

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

Source §

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

Source

pub fn from_homogeneous(homogeneous: Vector<4, T, A>) -> Self

Creates a 3D vector from homogeneous coordinates by performing perspective divide.

When debug assertions are enabled:

Panics if self is not normalized.

Source §

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

Source

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.

Source

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

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

Source

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

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

A vector with all elements set to MAX.

Source

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

Returns the maximum elements between self and other.

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

§Examples

let a = Vec4::<i32>::new(1, 5, 3, 0);
let b = Vec4::<i32>::new(3, 2, 7, -1);
let max = a.max(b);

assert_eq!(max, Vec4::new(3, 5, 7, 0));

Source

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

Returns the minimum elements between self and other.

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

§Examples

let a = Vec4::<i32>::new(1, 5, 3, 0);
let b = Vec4::<i32>::new(3, 2, 7, -1);
let min = a.min(b);

assert_eq!(min, Vec4::new(1, 2, 3, -1));

Source

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

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

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

§Panics

When debug assertions are enabled:

Panics if any element of min is greater than the corresponding element of max.

§Examples

let vector = Vec4::<i32>::new(1, 2, 3, 0);
let min = Vec4::new(0, 5, 1, -2);
let max = Vec4::new(3, 6, 2, -1);
let clamp = vector.clamp(min, max);

assert_eq!(clamp, Vec4::new(1, 5, 2, -1));

Source

pub fn max_element(self) -> i8

Returns the maximum between the elements of self.

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

§Examples

let vector = Vec3::<i32>::new(-1, 7, 3);
assert_eq!(vector.max_element(), 7);

Source

pub fn min_element(self) -> i8

Returns the minimum between the elements of self.

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

§Examples

let vector = Vec3::<i32>::new(7, -1, 3);
assert_eq!(vector.min_element(), -1);

Source §

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

§Examples

let vector = Vec3::<i32>::new(7, -1, 3);
assert_eq!(vector.min_element(), -1);

Source §

When debug assertions are enabled:

Panics if any element of min is greater than the corresponding element of max.

§Examples

let vector = Vec4::<i32>::new(1, 2, 3, 0);
let min = Vec4::new(0, 5, 1, -2);
let max = Vec4::new(3, 6, 2, -1);
let clamp = vector.clamp(min, max);

assert_eq!(clamp, Vec4::new(1, 5, 2, -1));

Source

pub fn max_element(self) -> i64

Returns the maximum between the elements of self.

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

§Examples

let vector = Vec3::<i32>::new(-1, 7, 3);
assert_eq!(vector.max_element(), 7);

Source

pub fn min_element(self) -> i64

Returns the minimum between the elements of self.

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

§Examples

let vector = Vec3::<i32>::new(7, -1, 3);
assert_eq!(vector.min_element(), -1);

Source §

When debug assertions are enabled:

Panics if any element of min is greater than the corresponding element of max.

§Examples

let vector = Vec4::<i32>::new(1, 2, 3, 0);
let min = Vec4::new(0, 5, 1, -2);
let max = Vec4::new(3, 6, 2, -1);
let clamp = vector.clamp(min, max);

assert_eq!(clamp, Vec4::new(1, 5, 2, -1));

Source

pub fn max_element(self) -> i128

Returns the maximum between the elements of self.

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

§Examples

let vector = Vec3::<i32>::new(-1, 7, 3);
assert_eq!(vector.max_element(), 7);

Source

pub fn min_element(self) -> i128

Returns the minimum between the elements of self.

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

§Examples

let vector = Vec3::<i32>::new(7, -1, 3);
assert_eq!(vector.min_element(), -1);

Source §

When debug assertions are enabled:

Panics if any element of min is greater than the corresponding element of max.

§Examples

let vector = Vec4::<i32>::new(1, 2, 3, 0);
let min = Vec4::new(0, 5, 1, -2);
let max = Vec4::new(3, 6, 2, -1);
let clamp = vector.clamp(min, max);

assert_eq!(clamp, Vec4::new(1, 5, 2, -1));

Source

pub fn max_element(self) -> isize

Returns the maximum between the elements of self.

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

§Examples

let vector = Vec3::<i32>::new(-1, 7, 3);
assert_eq!(vector.max_element(), 7);

Source

pub fn min_element(self) -> isize

Returns the minimum between the elements of self.

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

§Examples

let vector = Vec3::<i32>::new(7, -1, 3);
assert_eq!(vector.min_element(), -1);

Source §

When debug assertions are enabled:

Panics if any element of min is greater than the corresponding element of max.

§Examples

let vector = Vec4::<i32>::new(1, 2, 3, 0);
let min = Vec4::new(0, 5, 1, -2);
let max = Vec4::new(3, 6, 2, -1);
let clamp = vector.clamp(min, max);

assert_eq!(clamp, Vec4::new(1, 5, 2, -1));

Source

pub fn max_element(self) -> u8

Returns the maximum between the elements of self.

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

§Examples

let vector = Vec3::<i32>::new(-1, 7, 3);
assert_eq!(vector.max_element(), 7);

Source

pub fn min_element(self) -> u8

Returns the minimum between the elements of self.

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

§Examples

let vector = Vec3::<i32>::new(7, -1, 3);
assert_eq!(vector.min_element(), -1);

Source §

When debug assertions are enabled:

Panics if any element of min is greater than the corresponding element of max.

§Examples

let vector = Vec4::<i32>::new(1, 2, 3, 0);
let min = Vec4::new(0, 5, 1, -2);
let max = Vec4::new(3, 6, 2, -1);
let clamp = vector.clamp(min, max);

assert_eq!(clamp, Vec4::new(1, 5, 2, -1));

Source

pub fn max_element(self) -> u16

Returns the maximum between the elements of self.

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

§Examples

let vector = Vec3::<i32>::new(-1, 7, 3);
assert_eq!(vector.max_element(), 7);

Source

pub fn min_element(self) -> u16

Returns the minimum between the elements of self.

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

§Examples

let vector = Vec3::<i32>::new(7, -1, 3);
assert_eq!(vector.min_element(), -1);

Source §

When debug assertions are enabled:

Panics if any element of min is greater than the corresponding element of max.

§Examples

let vector = Vec4::<i32>::new(1, 2, 3, 0);
let min = Vec4::new(0, 5, 1, -2);
let max = Vec4::new(3, 6, 2, -1);
let clamp = vector.clamp(min, max);

assert_eq!(clamp, Vec4::new(1, 5, 2, -1));

Source

pub fn max_element(self) -> u32

Returns the maximum between the elements of self.

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

§Examples

let vector = Vec3::<i32>::new(-1, 7, 3);
assert_eq!(vector.max_element(), 7);

Source

pub fn min_element(self) -> u32

Returns the minimum between the elements of self.

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

§Examples

let vector = Vec3::<i32>::new(7, -1, 3);
assert_eq!(vector.min_element(), -1);

Source §

When debug assertions are enabled:

Panics if any element of min is greater than the corresponding element of max.

§Examples

let vector = Vec4::<i32>::new(1, 2, 3, 0);
let min = Vec4::new(0, 5, 1, -2);
let max = Vec4::new(3, 6, 2, -1);
let clamp = vector.clamp(min, max);

assert_eq!(clamp, Vec4::new(1, 5, 2, -1));

Source

pub fn max_element(self) -> u64

Returns the maximum between the elements of self.

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

§Examples

let vector = Vec3::<i32>::new(-1, 7, 3);
assert_eq!(vector.max_element(), 7);

Source

pub fn min_element(self) -> u64

Returns the minimum between the elements of self.

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

§Examples

let vector = Vec3::<i32>::new(7, -1, 3);
assert_eq!(vector.min_element(), -1);

Source §

When debug assertions are enabled:

Panics if any element of min is greater than the corresponding element of max.

§Examples

let vector = Vec4::<i32>::new(1, 2, 3, 0);
let min = Vec4::new(0, 5, 1, -2);
let max = Vec4::new(3, 6, 2, -1);
let clamp = vector.clamp(min, max);

assert_eq!(clamp, Vec4::new(1, 5, 2, -1));

Source

pub fn max_element(self) -> u128

Returns the maximum between the elements of self.

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

§Examples

let vector = Vec3::<i32>::new(-1, 7, 3);
assert_eq!(vector.max_element(), 7);

Source

pub fn min_element(self) -> u128

Returns the minimum between the elements of self.

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

§Examples

let vector = Vec3::<i32>::new(7, -1, 3);
assert_eq!(vector.min_element(), -1);

Source §

When debug assertions are enabled:

Panics if any element of min is greater than the corresponding element of max.

§Examples

let vector = Vec4::<i32>::new(1, 2, 3, 0);
let min = Vec4::new(0, 5, 1, -2);
let max = Vec4::new(3, 6, 2, -1);
let clamp = vector.clamp(min, max);

assert_eq!(clamp, Vec4::new(1, 5, 2, -1));

Source

pub fn max_element(self) -> usize

Returns the maximum between the elements of self.

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

§Examples

let vector = Vec3::<i32>::new(-1, 7, 3);
assert_eq!(vector.max_element(), 7);

Source

pub fn min_element(self) -> usize

Returns the minimum between the elements of self.

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

§Examples

let vector = Vec3::<i32>::new(7, -1, 3);
assert_eq!(vector.min_element(), -1);

Source §

impl<const N: usize, T, A: Alignment> Vector<N, T, A>
where Length<N>: SupportedLength, T: PrimitiveSigned,

Source

pub fn positive_mask(self) -> Mask<N, T, A>

Returns a vector mask where each element is true if the corresponding element of self is positive, and false if it is zero or negative.

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

§Examples

let vector = Vec4::new(1, -2, -3, 4);
let mask = vector.positive_mask();

assert_eq!(mask, Mask4::new(true, false, false, true));

Source

pub fn negative_mask(self) -> Mask<N, T, A>

Returns a vector mask where each element is true if the corresponding element of self is negative, and false if it is zero or positive.

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

§Examples

let vector = Vec4::new(1, -2, -3, 4);
let mask = vector.negative_mask();

assert_eq!(mask, Mask4::new(false, true, true, false));

Source

pub const fn cast_unsigned( self, ) -> Vector<N, <T as PrimitiveSigned>::Unsigned, A>

Returns the bit patterns of self reinterpreted as unsigned integers of the same size.

This produces the same result as as conversions, but ensures that the bit-width remains the same.

Source §

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

Source

pub fn abs(self) -> Self

Returns the absolute values of the elements of self.

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

§Panics

When debug assertions or overflow checks are enabled:

Panics if any component is MIN.

§Examples

let vector = Vec3::<i32>::new(7, -1, -3);
assert_eq!(vector.abs(), Vec3::new(7, 1, 3));

Source

pub fn signum(self) -> Self

Returns the signum of the elements of self.

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

For each element:

0 if the element is zero
1 if the element is positive
-1 if the element is negative

§Examples

let vector = Vec4::<i32>::new(7, -1, -3, 0);
assert_eq!(vector.signum(), Vec4::new(1, -1, -1, 0));

Source §

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

Source

pub fn abs(self) -> Self

Returns the absolute values of the elements of self.

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

§Panics

When debug assertions or overflow checks are enabled:

Panics if any component is MIN.

§Examples

let vector = Vec3::<i32>::new(7, -1, -3);
assert_eq!(vector.abs(), Vec3::new(7, 1, 3));

Source

pub fn signum(self) -> Self

Returns the signum of the elements of self.

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

For each element:

0 if the element is zero
1 if the element is positive
-1 if the element is negative

§Examples

let vector = Vec4::<i32>::new(7, -1, -3, 0);
assert_eq!(vector.signum(), Vec4::new(1, -1, -1, 0));

Source §

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

Source

pub fn abs(self) -> Self

Returns the absolute values of the elements of self.

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

§Panics

When debug assertions or overflow checks are enabled:

Panics if any component is MIN.

§Examples

let vector = Vec3::<i32>::new(7, -1, -3);
assert_eq!(vector.abs(), Vec3::new(7, 1, 3));

Source

pub fn signum(self) -> Self

Returns the signum of the elements of self.

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

For each element:

0 if the element is zero
1 if the element is positive
-1 if the element is negative

§Examples

let vector = Vec4::<i32>::new(7, -1, -3, 0);
assert_eq!(vector.signum(), Vec4::new(1, -1, -1, 0));

Source §

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

Source

pub fn abs(self) -> Self

Returns the absolute values of the elements of self.

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

§Panics

When debug assertions or overflow checks are enabled:

Panics if any component is MIN.

§Examples

let vector = Vec3::<i32>::new(7, -1, -3);
assert_eq!(vector.abs(), Vec3::new(7, 1, 3));

Source

pub fn signum(self) -> Self

Returns the signum of the elements of self.

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

For each element:

0 if the element is zero
1 if the element is positive
-1 if the element is negative

§Examples

let vector = Vec4::<i32>::new(7, -1, -3, 0);
assert_eq!(vector.signum(), Vec4::new(1, -1, -1, 0));

Source §

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

Source

pub fn abs(self) -> Self

Returns the absolute values of the elements of self.

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

§Panics

When debug assertions or overflow checks are enabled:

Panics if any component is MIN.

§Examples

let vector = Vec3::<i32>::new(7, -1, -3);
assert_eq!(vector.abs(), Vec3::new(7, 1, 3));

Source

pub fn signum(self) -> Self

Returns the signum of the elements of self.

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

For each element:

0 if the element is zero
1 if the element is positive
-1 if the element is negative

§Examples

let vector = Vec4::<i32>::new(7, -1, -3, 0);
assert_eq!(vector.signum(), Vec4::new(1, -1, -1, 0));

Source §

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

Source

pub fn abs(self) -> Self

Returns the absolute values of the elements of self.

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

§Panics

When debug assertions or overflow checks are enabled:

Panics if any component is MIN.

§Examples

let vector = Vec3::<i32>::new(7, -1, -3);
assert_eq!(vector.abs(), Vec3::new(7, 1, 3));

Source

pub fn signum(self) -> Self

Returns the signum of the elements of self.

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

For each element:

0 if the element is zero
1 if the element is positive
-1 if the element is negative

§Examples

let vector = Vec4::<i32>::new(7, -1, -3, 0);
assert_eq!(vector.signum(), Vec4::new(1, -1, -1, 0));

Source §

Returns self with the elements x and y replaced by value.x and value.y.

Source §

Returns self with the elements x, y and z replaced by value.x, value.y and value.z.

Source §

Returns self with the elements x, y, z and w replaced by value.x, value.y, value.z and value.w.

Source §

impl<const N: usize, T, A: Alignment> Vector<N, T, A>
where Length<N>: SupportedLength, T: PrimitiveUnsigned,

Source

pub const fn cast_signed(self) -> Vector<N, <T as PrimitiveUnsigned>::Signed, A>

Returns the bit patterns of self reinterpreted as signed integers of the same size.

let vector = Vec3::splat(5);
assert_eq!(vector, Vec3::new(5, 5, 5));

Source

pub fn from_fn<F>(f: F) -> Self
where F: FnMut(usize) -> T,

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

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

§Examples

let indices = Vec3::from_fn(|i| i);
assert_eq!(indices, Vec3::new(0, 1, 2));

let vector = Vec3::from_fn(|i| i % 2);
assert_eq!(vector, Vec3::new(0, 1, 0));

Source

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

Conversion between Aligned and Unaligned storage.

See align and unalign for scenarios where the output alignment is known.

See Alignment for more details.

§Examples

let unaligned = Vec3::new(1, 2, 3);
let aligned = unaligned.to_alignment::<Aligned>();
assert_eq!(aligned, Vec3A::new(1, 2, 3));

let aligned = Vec3A::new(1, 2, 3);
let unaligned = aligned.to_alignment::<Unaligned>();
assert_eq!(unaligned, Vec3::new(1, 2, 3));

Source

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

Conversion to Aligned storage.

See Alignment for more information.

§Examples

let unaligned = Vec3::new(1, 2, 3);
let aligned = unaligned.align();
assert_eq!(aligned, Vec3A::new(1, 2, 3));

Source

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

Conversion to Unaligned storage.

See Alignment for more information.

§Examples

let aligned = Vec3A::new(1, 2, 3);
let unaligned = aligned.unalign();
assert_eq!(unaligned, Vec3::new(1, 2, 3));

§Examples

let vector = Vec3::new(1, 2, 3).reverse();
assert_eq!(vector, Vec3::new(3, 2, 1));

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

§Examples

let vector = Vec3::new(1, 2, 3);
let mask = vector.ne_mask(Vec3::new(0, 2, 5));
assert_eq!(mask, Mask3::new(true, false, true));

Source

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

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

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

§Examples

let vector = Vec3::new(1, 2, 3);
let mask = vector.lt_mask(Vec3::new(0, 2, 5));
assert_eq!(mask, Mask3::new(false, false, true));

Source

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

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

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

§Examples

let vector = Vec3::new(1, 2, 3);
let mask = vector.gt_mask(Vec3::new(0, 2, 5));
assert_eq!(mask, Mask3::new(true, false, false));

Source

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

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

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

§Examples

let vector = Vec3::new(1, 2, 3);
let mask = vector.le_mask(Vec3::new(0, 2, 5));
assert_eq!(mask, Mask3::new(false, true, true));

Source

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

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

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

§Examples

let vector = Vec3::new(1, 2, 3);
let mask = vector.ge_mask(Vec3::new(0, 2, 5));
assert_eq!(mask, Mask3::new(true, true, false));

Source

pub fn dot(self, rhs: Self) -> T
where T: Add<Output = T> + Mul<Output = T>,

Computes the dot product of self and rhs.

§Panics

When debug assertions or overflow checks are enabled:

For integers this panics if an overflow occurs.

§Examples

let x = Vec3::new(2, 0, 0);
let y = Vec3::new(0, 3, 0);

assert_eq!(x.dot(y), 0);
assert_eq!(x.dot(x), 4);
assert_eq!(y.dot(y), 9);

Source

pub fn length_squared(self) -> T
where T: Add<Output = T> + Mul<Output = T>,

Computes the squared length/magnitude of self.

§Panics

When debug assertions or overflow checks are enabled:

For integers this panics if an overflow occurs.

§Examples

let vector = Vec2::new(1, 2);
assert_eq!(vector.length_squared(), 5);

Source

pub fn distance_squared(self, other: Self) -> T
where T: Neg<Output = T> + Add<Output = T> + Sub<Output = T> + Mul<Output = T>,

Computes the squared Euclidean distance between self and other.

§Panics

When debug assertions or overflow checks are enabled:

For integers this panics if an overflow occurs.

§Examples

let x = Vec3::<i32>::new(2, 0, 0);
let y = Vec3::<i32>::new(0, 3, 0);

assert_eq!(x.distance_squared(y), 13);
assert_eq!(x.distance_squared(x), 0);
assert_eq!(y.distance_squared(y), 0);

Source

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

👎Deprecated since 0.17.1:

renamed to as_array

Returns a reference to the vector’s elements.

This function has been renamed to as_array.

Source

pub const fn new(x: T, y: T) -> Self

Creates a 2-dimensional vector.

Source

pub fn extend(self, value: T) -> Vector<3, T, A>

Returns a 3-dimensional vector containing the elements of self then the scalar value.

Equivalent to (self, value).

Source

pub fn perp(self) -> Self
where T: Neg<Output = T>,

Returns self rotated by 90 degrees.

This rotates +X to +Y.

§Examples

let x = Vec2::new(1, 0);
let y = Vec2::new(0, 1);

assert_eq!(x.perp(), y);
assert_eq!(y.perp(), -x);
assert_eq!((-x).perp(), -y);
assert_eq!((-y).perp(), x);

Source

pub fn wedge(self, rhs: Self) -> T
where T: Neg<Output = T> + Add<Output = T> + Sub<Output = T> + Mul<Output = T>,

Computes the wedge product of self and rhs.

Also reffered to as the 2D cross product, the determinant and the signed area.

§Examples

let x = Vec2::new(1, 0);
let y = Vec2::new(0, 1);

assert_eq!(x.wedge(y), 1);
assert_eq!(y.wedge(x), -1);

Source §

impl<T, A: Alignment> Vector<3, T, A>
where T: Scalar + Zero + One,

Source

pub const X: Self

(1, 0, 0).

Source

pub const Y: Self

(0, 1, 0).

Source

pub const Z: Self

(0, 0, 1).

Source §

impl<T, A: Alignment> Vector<3, T, A>
where T: Scalar + Zero + NegOne,

Source

pub const NEG_X: Self

(-1, 0, 0).

Source

pub const NEG_Y: Self

(0, -1, 0).

Source

pub const NEG_Z: Self

(0, 0, -1).

Source §

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

Source

Computes the cross product of self and rhs.

§Examples

let x = Vec3::new(1, 0, 0);
let y = Vec3::new(0, 1, 0);

assert_eq!(x.cross(y), Vec3::new(0, 0, 1));
assert_eq!(y.cross(x), Vec3::new(0, 0, -1));

Source §

impl<T, A: Alignment> Vector<4, T, A>
where T: Scalar + Zero + One,

Source

pub const X: Self

(1, 0, 0, 0).

Source

pub const Y: Self

(0, 1, 0, 0).

Source

pub const Z: Self

(0, 0, 1, 0).

Source

pub const W: Self

(0, 0, 0, 1).

Source §

impl<T, A: Alignment> Vector<4, T, A>
where T: Scalar + Zero + NegOne,

Source

pub const NEG_X: Self

(-1, 0, 0, 0).

Source

pub const NEG_Y: Self

(0, -1, 0, 0).

Source

pub const NEG_Z: Self

(0, 0, -1, 0).

Source

pub const NEG_W: Self

Performs the + operation for each vector element.

§Examples

let a = Vec3::new(1, 2, 3);
let b = a + Vec3::new(4, 5, 6);
assert_eq!(b, Vec3::new(1 + 4, 2 + 5, 3 + 6));

§Consistency

For primitive types this operation is fully consistent with the scalar operation, including floating-point precision and integer panics.

Source §

type Output = Vector<N, T, A>

The resulting type after applying the + operator.

The resulting type after applying the + operator.

The resulting type after applying the + operator.

Source §

impl<const N: usize, T, A: Alignment> Add<&Vector<N, T, A>> for Vector<N, T, A>
where Length<N>: SupportedLength, T: Scalar + Add<Output = T>,

Source §

fn add(self, rhs: &Vector<N, T, A>) -> Self::Output

Performs the + operation for each vector element.

§Examples

let a = Vec3::new(1, 2, 3);
let b = a + Vec3::new(4, 5, 6);
assert_eq!(b, Vec3::new(1 + 4, 2 + 5, 3 + 6));

§Consistency

For primitive types this operation is fully consistent with the scalar operation, including floating-point precision and integer panics.

Source §

type Output = Vector<N, T, A>

The resulting type after applying the + operator.

Source §

impl<const N: usize, T, A: Alignment> Add<&Vector<N, T, A>> for &Vector<N, T, A>
where Length<N>: SupportedLength, T: Scalar + Add<Output = T>,

Source §

fn add(self, rhs: &Vector<N, T, A>) -> Self::Output

Performs the + operation for each vector element.

§Examples

let a = Vec3::new(1, 2, 3);
let b = a + Vec3::new(4, 5, 6);
assert_eq!(b, Vec3::new(1 + 4, 2 + 5, 3 + 6));

§Consistency

For primitive types this operation is fully consistent with the scalar operation, including floating-point precision and integer panics.

Source §

type Output = Vector<N, T, A>

The resulting type after applying the + operator.

The resulting type after applying the + operator.

The resulting type after applying the + operator.

Source §

impl<const N: usize, T, A: Alignment> Add<Vector<N, T, A>> for &Vector<N, T, A>
where Length<N>: SupportedLength, T: Scalar + Add<Output = T>,

Source §

fn add(self, rhs: Vector<N, T, A>) -> Self::Output

Performs the + operation for each vector element.

§Examples

let a = Vec3::new(1, 2, 3);
let b = a + Vec3::new(4, 5, 6);
assert_eq!(b, Vec3::new(1 + 4, 2 + 5, 3 + 6));

§Consistency

For primitive types this operation is fully consistent with the scalar operation, including floating-point precision and integer panics.

Source §

type Output = Vector<N, T, A>

The resulting type after applying the + operator.

let mut vector = Vec3::new(1, 2, 3);
vector += 4;
assert_eq!(vector, Vec3::new(1 + 4, 2 + 4, 3 + 4));

§Consistency

For primitive types this operation is fully consistent with the scalar operation, including floating-point precision and integer panics.

This operation is fully consistent with vector + vector.

let mut vector = Vec3::new(1, 2, 3);
vector += 4;
assert_eq!(vector, Vec3::new(1 + 4, 2 + 4, 3 + 4));

§Consistency

For primitive types this operation is fully consistent with the scalar operation, including floating-point precision and integer panics.

This operation is fully consistent with vector + vector.

Source §

impl<const N: usize, T, A: Alignment> BitAnd for Vector<N, T, A>
where Length<N>: SupportedLength, T: Scalar + BitAnd<Output = T>,

Source §

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

Performs the & operation for each vector element.

§Examples

let a = Vec3::new(1, 2, 3);
let b = a & Vec3::new(4, 5, 6);
assert_eq!(b, Vec3::new(1 & 4, 2 & 5, 3 & 6));

Source §

type Output = Vector<N, T, A>

The resulting type after applying the & operator.

Source §

impl<const N: usize, T, A: Alignment> BitAnd<&T> for Vector<N, T, A>
where Length<N>: SupportedLength, T: Scalar + BitAnd<Output = T>,

Source §

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

Performs the & operation for each vector element and the scalar rhs.

§Examples

let a = Vec3::new(1, 2, 3);
let b = a & 4;
assert_eq!(b, Vec3::new(1 & 4, 2 & 4, 3 & 4));

§Consistency

This operation is fully consistent with vector & splat(scalar).

Source §

type Output = Vector<N, T, A>

The resulting type after applying the & operator.

Source §

impl<const N: usize, T, A: Alignment> BitAnd<&T> for &Vector<N, T, A>
where Length<N>: SupportedLength, T: Scalar + BitAnd<Output = T>,

Source §

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

Performs the & operation for each vector element and the scalar rhs.

§Examples

let a = Vec3::new(1, 2, 3);
let b = a & 4;
assert_eq!(b, Vec3::new(1 & 4, 2 & 4, 3 & 4));

§Examples

let a = Vec3::new(1, 2, 3);
let b = a & 4;
assert_eq!(b, Vec3::new(1 & 4, 2 & 4, 3 & 4));

§Consistency

This operation is fully consistent with vector & splat(scalar).

Source §

type Output = Vector<N, T, A>

The resulting type after applying the & operator.

Source §

impl<const N: usize, T, A: Alignment> BitAnd<T> for &Vector<N, T, A>
where Length<N>: SupportedLength, T: Scalar + BitAnd<Output = T>,

Source §

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

Performs the & operation for each vector element and the scalar rhs.

§Examples

let a = Vec3::new(1, 2, 3);
let b = a & 4;
assert_eq!(b, Vec3::new(1 & 4, 2 & 4, 3 & 4));

§Consistency

This operation is fully consistent with vector & splat(scalar).

Source §

type Output = Vector<N, T, A>

The resulting type after applying the & operator.

Source §

impl<const N: usize, T, A: Alignment> BitAnd<Vector<N, T, A>> for &Vector<N, T, A>
where Length<N>: SupportedLength, T: Scalar + BitAnd<Output = T>,

Source §

fn bitand(self, rhs: Vector<N, T, A>) -> Self::Output

Performs the & operation for each vector element.

§Examples

let a = Vec3::new(1, 2, 3);
let b = a & Vec3::new(4, 5, 6);
assert_eq!(b, Vec3::new(1 & 4, 2 & 5, 3 & 6));

let a = Vec3::new(1, 2, 3);
let b = a | Vec3::new(4, 5, 6);
assert_eq!(b, Vec3::new(1 | 4, 2 | 5, 3 | 6));

Source §

type Output = Vector<N, T, A>

The resulting type after applying the | operator.

Source §

impl<const N: usize, T, A: Alignment> BitOr<&T> for Vector<N, T, A>
where Length<N>: SupportedLength, T: Scalar + BitOr<Output = T>,

Source §

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

Performs the | operation for each vector element and the scalar rhs.

§Examples

let a = Vec3::new(1, 2, 3);
let b = a | 4;
assert_eq!(b, Vec3::new(1 | 4, 2 | 4, 3 | 4));

§Consistency

This operation is fully consistent with vector | splat(scalar).

Source §

type Output = Vector<N, T, A>

The resulting type after applying the | operator.

Source §

impl<const N: usize, T, A: Alignment> BitOr<&T> for &Vector<N, T, A>
where Length<N>: SupportedLength, T: Scalar + BitOr<Output = T>,

Source §

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

Performs the | operation for each vector element and the scalar rhs.

§Examples

let a = Vec3::new(1, 2, 3);
let b = a | 4;
assert_eq!(b, Vec3::new(1 | 4, 2 | 4, 3 | 4));

§Examples

let a = Vec3::new(1, 2, 3);
let b = a | 4;
assert_eq!(b, Vec3::new(1 | 4, 2 | 4, 3 | 4));

§Consistency

This operation is fully consistent with vector | splat(scalar).

Source §

type Output = Vector<N, T, A>

The resulting type after applying the | operator.

Source §

impl<const N: usize, T, A: Alignment> BitOr<T> for &Vector<N, T, A>
where Length<N>: SupportedLength, T: Scalar + BitOr<Output = T>,

Source §

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

Performs the | operation for each vector element and the scalar rhs.

§Examples

let a = Vec3::new(1, 2, 3);
let b = a | 4;
assert_eq!(b, Vec3::new(1 | 4, 2 | 4, 3 | 4));

§Consistency

This operation is fully consistent with vector | splat(scalar).

Source §

type Output = Vector<N, T, A>

The resulting type after applying the | operator.

Source §

impl<const N: usize, T, A: Alignment> BitOr<Vector<N, T, A>> for &Vector<N, T, A>
where Length<N>: SupportedLength, T: Scalar + BitOr<Output = T>,

Source §

fn bitor(self, rhs: Vector<N, T, A>) -> Self::Output

Performs the | operation for each vector element.

§Examples

let a = Vec3::new(1, 2, 3);
let b = a | Vec3::new(4, 5, 6);
assert_eq!(b, Vec3::new(1 | 4, 2 | 5, 3 | 6));

let a = Vec3::new(1, 2, 3);
let b = a ^ Vec3::new(4, 5, 6);
assert_eq!(b, Vec3::new(1 ^ 4, 2 ^ 5, 3 ^ 6));

Source §

type Output = Vector<N, T, A>

The resulting type after applying the ^ operator.

Source §

impl<const N: usize, T, A: Alignment> BitXor<&T> for Vector<N, T, A>
where Length<N>: SupportedLength, T: Scalar + BitXor<Output = T>,

Source §

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

Performs the ^ operation for each vector element and the scalar rhs.

§Examples

let a = Vec3::new(1, 2, 3);
let b = a ^ 4;
assert_eq!(b, Vec3::new(1 ^ 4, 2 ^ 4, 3 ^ 4));

§Consistency

This operation is fully consistent with vector ^ splat(scalar).

Source §

type Output = Vector<N, T, A>

The resulting type after applying the ^ operator.

Source §

impl<const N: usize, T, A: Alignment> BitXor<&T> for &Vector<N, T, A>
where Length<N>: SupportedLength, T: Scalar + BitXor<Output = T>,

Source §

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

Performs the ^ operation for each vector element and the scalar rhs.

§Examples

let a = Vec3::new(1, 2, 3);
let b = a ^ 4;
assert_eq!(b, Vec3::new(1 ^ 4, 2 ^ 4, 3 ^ 4));

§Examples

let a = Vec3::new(1, 2, 3);
let b = a ^ 4;
assert_eq!(b, Vec3::new(1 ^ 4, 2 ^ 4, 3 ^ 4));

§Consistency

This operation is fully consistent with vector ^ splat(scalar).

Source §

type Output = Vector<N, T, A>

The resulting type after applying the ^ operator.

Source §

impl<const N: usize, T, A: Alignment> BitXor<T> for &Vector<N, T, A>
where Length<N>: SupportedLength, T: Scalar + BitXor<Output = T>,

Source §

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

Performs the ^ operation for each vector element and the scalar rhs.

§Examples

let a = Vec3::new(1, 2, 3);
let b = a ^ 4;
assert_eq!(b, Vec3::new(1 ^ 4, 2 ^ 4, 3 ^ 4));

§Consistency

This operation is fully consistent with vector ^ splat(scalar).

Source §

type Output = Vector<N, T, A>

The resulting type after applying the ^ operator.

Source §

impl<const N: usize, T, A: Alignment> BitXor<Vector<N, T, A>> for &Vector<N, T, A>
where Length<N>: SupportedLength, T: Scalar + BitXor<Output = T>,

Source §

fn bitxor(self, rhs: Vector<N, T, A>) -> Self::Output

Performs the ^ operation for each vector element.

§Examples

let a = Vec3::new(1, 2, 3);
let b = a ^ Vec3::new(4, 5, 6);
assert_eq!(b, Vec3::new(1 ^ 4, 2 ^ 5, 3 ^ 6));

let mut vector = Vec3::new(1, 2, 3);
vector ^= 4;
assert_eq!(vector, Vec3::new(1 ^ 4, 2 ^ 4, 3 ^ 4));

§Consistency

impl<T, A: Alignment> Deref for Vector<3, T, A>
where T: Scalar,

Source §

type Target = Vec3Fields<T>

The resulting type after dereferencing.

Source §

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

Dereferences the value.

Source §

impl<T, A: Alignment> Deref for Vector<4, T, A>
where T: Scalar,

Source §

type Target = Vec4Fields<T>

The resulting type after dereferencing.

Source §

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

Performs the / operation for each vector element.

§Examples

let a = Vec3::new(8, 10, 12);
let b = a / Vec3::new(2, 5, 3);
assert_eq!(b, Vec3::new(8 / 2, 10 / 5, 12 / 3));

§Consistency

For primitive types this operation is fully consistent with the scalar operation, including floating-point precision and integer panics.

Source §

type Output = Vector<N, T, A>

The resulting type after applying the / operator.

The resulting type after applying the / operator.

The resulting type after applying the / operator.

Source §

impl<const N: usize, T, A: Alignment> Div<&Vector<N, T, A>> for Vector<N, T, A>
where Length<N>: SupportedLength, T: Scalar + Div<Output = T>,

Source §

fn div(self, rhs: &Vector<N, T, A>) -> Self::Output

Performs the / operation for each vector element.

§Examples

let a = Vec3::new(8, 10, 12);
let b = a / Vec3::new(2, 5, 3);
assert_eq!(b, Vec3::new(8 / 2, 10 / 5, 12 / 3));

§Consistency

For primitive types this operation is fully consistent with the scalar operation, including floating-point precision and integer panics.

Source §

type Output = Vector<N, T, A>

The resulting type after applying the / operator.

Source §

impl<const N: usize, T, A: Alignment> Div<&Vector<N, T, A>> for &Vector<N, T, A>
where Length<N>: SupportedLength, T: Scalar + Div<Output = T>,

Source §

fn div(self, rhs: &Vector<N, T, A>) -> Self::Output

Performs the / operation for each vector element.

§Examples

let a = Vec3::new(8, 10, 12);
let b = a / Vec3::new(2, 5, 3);
assert_eq!(b, Vec3::new(8 / 2, 10 / 5, 12 / 3));

§Consistency

For primitive types this operation is fully consistent with the scalar operation, including floating-point precision and integer panics.

Source §

type Output = Vector<N, T, A>

The resulting type after applying the / operator.

The resulting type after applying the / operator.

The resulting type after applying the / operator.

Source §

impl<const N: usize, T, A: Alignment> Div<Vector<N, T, A>> for &Vector<N, T, A>
where Length<N>: SupportedLength, T: Scalar + Div<Output = T>,

Source §

fn div(self, rhs: Vector<N, T, A>) -> Self::Output

Performs the / operation for each vector element.

§Examples

let a = Vec3::new(8, 10, 12);
let b = a / Vec3::new(2, 5, 3);
assert_eq!(b, Vec3::new(8 / 2, 10 / 5, 12 / 3));

§Consistency

For primitive types this operation is fully consistent with the scalar operation, including floating-point precision and integer panics.

Source §

type Output = Vector<N, T, A>

The resulting type after applying the / operator.

let mut vector = Vec3::new(8, 10, 12);
vector /= 2;
assert_eq!(vector, Vec3::new(8 / 2, 10 / 2, 12 / 2));

§Consistency

For primitive types this operation is fully consistent with the scalar operation, including floating-point precision and integer panics.

This operation is fully consistent with vector / vector.

let mut vector = Vec3::new(8, 10, 12);
vector /= 2;
assert_eq!(vector, Vec3::new(8 / 2, 10 / 2, 12 / 2));

§Consistency

For primitive types this operation is fully consistent with the scalar operation, including floating-point precision and integer panics.

This operation is fully consistent with vector / vector.

Source §

Feeds this value into the given Hasher. Read more

1.3.0 · Source§

fn hash_slice<H>(data: &[Self], state: &mut H)
where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher. Read more

Source §

impl<const N: usize, T, A: Alignment> Index<usize> for Vector<N, T, A>
where Length<N>: SupportedLength, T: Scalar,

Source §

type Output = T

The returned type after indexing.

Which kind of iterator are we turning this into?

Source §

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value. Read more

Source §

impl<const N: usize, T, A: Alignment> IntoIterator for &Vector<N, T, A>
where Length<N>: SupportedLength, T: Scalar,

Source §

type Item = T

The type of the elements being iterated over.

Source §

type IntoIter = <[T; N] as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

Source §

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value. Read more

Source §

impl<'a, const N: usize, T, A: Alignment> IntoIterator for &'a mut Vector<N, T, A>
where Length<N>: SupportedLength, T: Scalar,

Source §

type Item = &'a mut T

The type of the elements being iterated over.

Source §

type IntoIter = <&'a mut [T; N] as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

Source §

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value. Read more

Source §

impl<const N: usize, T, A: Alignment> Mul for Vector<N, T, A>
where Length<N>: SupportedLength, T: Scalar + Mul<Output = T>,

Source §

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

Performs the * operation for each vector element.

§Examples

let a = Vec3::new(1, 2, 3);
let b = a * Vec3::new(4, 5, 6);
assert_eq!(b, Vec3::new(1 * 4, 2 * 5, 3 * 6));

§Consistency

For primitive types this operation is fully consistent with the scalar operation, including floating-point precision and integer panics.

Source §

type Output = Vector<N, T, A>

The resulting type after applying the * operator.

Source §

impl<const N: usize, T, A: Alignment> Mul<&Matrix<N, T, A>> for Vector<N, T, A>
where Length<N>: SupportedLength, T: Scalar + Add<Output = T> + Mul<Output = T>,

Source §

fn mul(self, rhs: &Matrix<N, T, A>) -> Self::Output

Vector-matrix multiplication.

Because vectors are treated as row matrices, they always go on the left-hand side.

Equivalent to self.x * rhs.x_axis + self.y * rhs.y_axis + ....

§Consistency

For primitive types this operation is cross-platform deterministic and fully consistent with scalar addition and multiplication, including floating-point precision and integer panics.

Source §

type Output = Vector<N, T, A>

The resulting type after applying the * operator.

Source §

impl<const N: usize, T, A: Alignment> Mul<&Matrix<N, T, A>> for &Vector<N, T, A>
where Length<N>: SupportedLength, T: Scalar + Add<Output = T> + Mul<Output = T>,

Source §

fn mul(self, rhs: &Matrix<N, T, A>) -> Self::Output

Vector-matrix multiplication.

Because vectors are treated as row matrices, they always go on the left-hand side.

Equivalent to self.x * rhs.x_axis + self.y * rhs.y_axis + ....

§Consistency

For primitive types this operation is cross-platform deterministic and fully consistent with scalar addition and multiplication, including floating-point precision and integer panics.

Source §

type Output = Vector<N, T, A>

The resulting type after applying the * operator.

The resulting type after applying the * operator.

The resulting type after applying the * operator.

Source §

impl<const N: usize, T, A: Alignment> Mul<&Vector<N, T, A>> for Vector<N, T, A>
where Length<N>: SupportedLength, T: Scalar + Mul<Output = T>,

Source §

fn mul(self, rhs: &Vector<N, T, A>) -> Self::Output

Performs the * operation for each vector element.

§Examples

let a = Vec3::new(1, 2, 3);
let b = a * Vec3::new(4, 5, 6);
assert_eq!(b, Vec3::new(1 * 4, 2 * 5, 3 * 6));

§Consistency

For primitive types this operation is fully consistent with the scalar operation, including floating-point precision and integer panics.

Source §

type Output = Vector<N, T, A>

The resulting type after applying the * operator.

Source §

impl<const N: usize, T, A: Alignment> Mul<&Vector<N, T, A>> for &Vector<N, T, A>
where Length<N>: SupportedLength, T: Scalar + Mul<Output = T>,

Source §

fn mul(self, rhs: &Vector<N, T, A>) -> Self::Output

Performs the * operation for each vector element.

§Examples

let a = Vec3::new(1, 2, 3);
let b = a * Vec3::new(4, 5, 6);
assert_eq!(b, Vec3::new(1 * 4, 2 * 5, 3 * 6));

The resulting type after applying the * operator.

The resulting type after applying the * operator.

The resulting type after applying the * operator.

Source §

impl<const N: usize, T, A: Alignment> Mul<Vector<N, T, A>> for &Vector<N, T, A>
where Length<N>: SupportedLength, T: Scalar + Mul<Output = T>,

Source §

fn mul(self, rhs: Vector<N, T, A>) -> Self::Output

Performs the * operation for each vector element.

§Examples

let a = Vec3::new(1, 2, 3);
let b = a * Vec3::new(4, 5, 6);
assert_eq!(b, Vec3::new(1 * 4, 2 * 5, 3 * 6));

§Consistency

For primitive types this operation is fully consistent with the scalar operation, including floating-point precision and integer panics.

Source §

type Output = Vector<N, T, A>

The resulting type after applying the * operator.

impl<const N: usize, T, A: Alignment> MulAssign<&T> for Vector<N, T, A>
where Length<N>: SupportedLength, T: Scalar + Mul<Output = T>,

Source §

fn mul_assign(&mut self, rhs: &T)

Performs the *= operation for each vector element and the scalar rhs.

§Examples

let mut vector = Vec3::new(1, 2, 3);
vector *= 4;
assert_eq!(vector, Vec3::new(1 * 4, 2 * 4, 3 * 4));

§Consistency

For primitive types this operation is fully consistent with the scalar operation, including floating-point precision and integer panics.

This operation is fully consistent with vector * vector.

Source §

impl<const N: usize, T, A: Alignment> MulAssign<&Vector<N, T, A>> for Vector<N, T, A>
where Length<N>: SupportedLength, T: Scalar + Mul<Output = T>,

Source §

fn mul_assign(&mut self, rhs: &Vector<N, T, A>)

Performs the *= operation for each vector element.

§Examples

let mut vector = Vec3::new(1, 2, 3);
vector *= Vec3::new(4, 5, 6);
assert_eq!(vector, Vec3::new(1 * 4, 2 * 5, 3 * 6));

§Consistency

For primitive types this operation is fully consistent with the scalar operation, including floating-point precision and integer panics.

This operation is fully consistent with vector * vector.

Source §

impl<const N: usize, T, A: Alignment> MulAssign<Matrix<N, T, A>> for Vector<N, T, A>
where Length<N>: SupportedLength, T: Scalar + Add<Output = T> + Mul<Output = T>,

Source §

fn mul_assign(&mut self, rhs: Matrix<N, T, A>)

Vector-matrix multiplication.

Because vectors are treated as row matrices, they always go on the left-hand side.

Equivalent to self.x * rhs.x_axis + self.y * rhs.y_axis + ....

§Consistency

For primitive types this operation is cross-platform deterministic and fully consistent with scalar addition and multiplication, including floating-point precision and integer panics.

Source §

impl<T, A: Alignment> MulAssign<Quaternion<T, A>> for Vector<3, T, A>
where T: Scalar + Neg<Output = T> + Add<Output = T> + Sub<Output = T> + Mul<Output = T>,

Source §

fn mul_assign(&mut self, rhs: Quaternion<T, A>)

3D vector quaternion multiplication. Returns the rotated vector.

let vector = -Vec3::new(1, 2, 3);
assert_eq!(vector, Vec3::new(-1, -2, -3));

§Consistency

For primitive types this operation is fully consistent with the scalar operation, including integer panics.

Source §

type Output = Vector<N, T, A>

The resulting type after applying the - operator.

Source §

impl<const N: usize, T, A: Alignment> Neg for &Vector<N, T, A>
where Length<N>: SupportedLength, T: Scalar + Neg<Output = T>,

Source §

fn neg(self) -> Self::Output

Performs the unary - operation for each vector element.

§Examples

let vector = -Vec3::new(1, 2, 3);
assert_eq!(vector, Vec3::new(-1, -2, -3));

Source §

fn ne(&self, other: &Self) -> bool

Inequality operator !=. Read more

Source §

type Output = Vector<N, T, A>

The resulting type after applying the % operator.

Source §

impl<const N: usize, T, A: Alignment> Rem<&T> for Vector<N, T, A>
where Length<N>: SupportedLength, T: Scalar + Rem<Output = T>,

Source §

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

Performs the % operation for each vector element and the scalar rhs.

§Examples

let a = Vec3::new(5, 7, 9);
let b = a % 2;
assert_eq!(b, Vec3::new(5 % 2, 7 % 2, 9 % 2));

§Consistency

For integers this operation is fully consistent with the scalar operation, including panics.

For floats this operation may be inconsistent with the scalar operation, regarding precision and NaN propagation.

This operation is fully consistent with vector % splat(scalar).

Source §

type Output = Vector<N, T, A>

The resulting type after applying the % operator.

Source §

impl<const N: usize, T, A: Alignment> Rem<&T> for &Vector<N, T, A>
where Length<N>: SupportedLength, T: Scalar + Rem<Output = T>,

Source §

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

Performs the % operation for each vector element and the scalar rhs.

§Examples

let a = Vec3::new(5, 7, 9);
let b = a % 2;
assert_eq!(b, Vec3::new(5 % 2, 7 % 2, 9 % 2));

§Consistency

For integers this operation is fully consistent with the scalar operation, including panics.

For floats this operation may be inconsistent with the scalar operation, regarding precision and NaN propagation.

This operation is fully consistent with vector % splat(scalar).

Source §

type Output = Vector<N, T, A>

The resulting type after applying the % operator.

The resulting type after applying the % operator.

The resulting type after applying the % operator.

Source §

impl<const N: usize, T, A: Alignment> Rem<T> for Vector<N, T, A>
where Length<N>: SupportedLength, T: Scalar + Rem<Output = T>,

Source §

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

Performs the % operation for each vector element and the scalar rhs.

§Examples

let a = Vec3::new(5, 7, 9);
let b = a % 2;
assert_eq!(b, Vec3::new(5 % 2, 7 % 2, 9 % 2));

§Consistency

For integers this operation is fully consistent with the scalar operation, including panics.

For floats this operation may be inconsistent with the scalar operation, regarding precision and NaN propagation.

This operation is fully consistent with vector % splat(scalar).

Source §

type Output = Vector<N, T, A>

The resulting type after applying the % operator.

Source §

impl<const N: usize, T, A: Alignment> Rem<T> for &Vector<N, T, A>
where Length<N>: SupportedLength, T: Scalar + Rem<Output = T>,

Source §

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

Performs the % operation for each vector element and the scalar rhs.

§Examples

let a = Vec3::new(5, 7, 9);
let b = a % 2;
assert_eq!(b, Vec3::new(5 % 2, 7 % 2, 9 % 2));

§Consistency

For integers this operation is fully consistent with the scalar operation, including panics.

For floats this operation may be inconsistent with the scalar operation, regarding precision and NaN propagation.

This operation is fully consistent with vector % splat(scalar).

Source §

type Output = Vector<N, T, A>

The resulting type after applying the % operator.

The resulting type after applying the % operator.

Source §

impl<const N: usize, T, A: Alignment> RemAssign for Vector<N, T, A>
where Length<N>: SupportedLength, T: Scalar + Rem<Output = T>,

Source §

fn rem_assign(&mut self, rhs: Self)

Performs the %= operation for each vector element.

§Examples

let mut vector = Vec3::new(5, 7, 9);
vector %= Vec3::new(2, 3, 4);
assert_eq!(vector, Vec3::new(5 % 2, 7 % 3, 9 % 4));

§Consistency

For integers this operation is fully consistent with the scalar operation, including panics.

For floats this operation may be inconsistent with the scalar operation, regarding precision and NaN propagation.

This operation is fully consistent with vector % vector.

Source §

impl<const N: usize, T, A: Alignment> RemAssign<&T> for Vector<N, T, A>
where Length<N>: SupportedLength, T: Scalar + Rem<Output = T>,

Source §

fn rem_assign(&mut self, rhs: &T)

Performs the %= operation for each vector element and the scalar rhs.

§Examples

let mut vector = Vec3::new(5, 7, 9);
vector %= 2;
assert_eq!(vector, Vec3::new(5 % 2, 7 % 2, 9 % 2));

§Consistency

For integers this operation is fully consistent with the scalar operation, including panics.

For floats this operation may be inconsistent with the scalar operation, regarding precision and NaN propagation.

This operation is fully consistent with vector % vector.

Source §

impl<const N: usize, T, A: Alignment> RemAssign<&Vector<N, T, A>> for Vector<N, T, A>
where Length<N>: SupportedLength, T: Scalar + Rem<Output = T>,

Source §

fn rem_assign(&mut self, rhs: &Vector<N, T, A>)

Performs the %= operation for each vector element.

§Examples

let mut vector = Vec3::new(5, 7, 9);
vector %= Vec3::new(2, 3, 4);
assert_eq!(vector, Vec3::new(5 % 2, 7 % 3, 9 % 4));

§Consistency

For integers this operation is fully consistent with the scalar operation, including panics.

For floats this operation may be inconsistent with the scalar operation, regarding precision and NaN propagation.

This operation is fully consistent with vector % vector.

Source §

impl<const N: usize, T, A: Alignment> RemAssign<T> for Vector<N, T, A>
where Length<N>: SupportedLength, T: Scalar + Rem<Output = T>,

Source §

fn rem_assign(&mut self, rhs: T)

Performs the %= operation for each vector element and the scalar rhs.

§Examples

let mut vector = Vec3::new(5, 7, 9);
vector %= 2;
assert_eq!(vector, Vec3::new(5 % 2, 7 % 2, 9 % 2));

§Consistency

For integers this operation is fully consistent with the scalar operation, including panics.

For floats this operation may be inconsistent with the scalar operation, regarding precision and NaN propagation.

This operation is fully consistent with vector % vector.

Source §

impl<const N: usize, T, A: Alignment> Send for Vector<N, T, A>
where Length<N>: SupportedLength, T: Scalar + Send,

Source §

impl<const N: usize, T, A: Alignment> Shl for Vector<N, T, A>
where Length<N>: SupportedLength, T: Scalar + Shl<Output = T>,

Source §

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

Performs the << operation for each vector element.

§Examples

let a = Vec3::new(1, 2, 3);
let b = a << Vec3::new(1, 2, 3);
assert_eq!(b, Vec3::new(1 << 1, 2 << 2, 3 << 3));

§Consistency

For primitive types this operation is fully consistent with the scalar operation, including integer panics.

Source §

type Output = Vector<N, T, A>

The resulting type after applying the << operator.

The resulting type after applying the << operator.

The resulting type after applying the << operator.

Source §

impl<const N: usize, T, A: Alignment> Shl<&Vector<N, T, A>> for Vector<N, T, A>
where Length<N>: SupportedLength, T: Scalar + Shl<Output = T>,

Source §

fn shl(self, rhs: &Vector<N, T, A>) -> Self::Output

Performs the << operation for each vector element.

§Examples

let a = Vec3::new(1, 2, 3);
let b = a << Vec3::new(1, 2, 3);
assert_eq!(b, Vec3::new(1 << 1, 2 << 2, 3 << 3));

§Consistency

For primitive types this operation is fully consistent with the scalar operation, including integer panics.

Source §

type Output = Vector<N, T, A>

The resulting type after applying the << operator.

Source §

impl<const N: usize, T, A: Alignment> Shl<&Vector<N, T, A>> for &Vector<N, T, A>
where Length<N>: SupportedLength, T: Scalar + Shl<Output = T>,

Source §

fn shl(self, rhs: &Vector<N, T, A>) -> Self::Output

Performs the << operation for each vector element.

§Examples

let a = Vec3::new(1, 2, 3);
let b = a << Vec3::new(1, 2, 3);
assert_eq!(b, Vec3::new(1 << 1, 2 << 2, 3 << 3));

§Consistency

For primitive types this operation is fully consistent with the scalar operation, including integer panics.

Source §

type Output = Vector<N, T, A>

The resulting type after applying the << operator.

The resulting type after applying the << operator.

The resulting type after applying the << operator.

Source §

impl<const N: usize, T, A: Alignment> Shl<Vector<N, T, A>> for &Vector<N, T, A>
where Length<N>: SupportedLength, T: Scalar + Shl<Output = T>,

Source §

fn shl(self, rhs: Vector<N, T, A>) -> Self::Output

Performs the << operation for each vector element.

§Examples

let a = Vec3::new(1, 2, 3);
let b = a << Vec3::new(1, 2, 3);
assert_eq!(b, Vec3::new(1 << 1, 2 << 2, 3 << 3));

§Consistency

For primitive types this operation is fully consistent with the scalar operation, including integer panics.

Source §

type Output = Vector<N, T, A>

The resulting type after applying the << operator.

let mut vector = Vec3::new(1, 2, 3);
vector <<= 1;
assert_eq!(vector, Vec3::new(1 << 1, 2 << 1, 3 << 1));

§Consistency

For primitive types this operation is fully consistent with the scalar operation, including integer panics.

This operation is fully consistent with vector << vector.

let mut vector = Vec3::new(1, 2, 3);
vector <<= 1;
assert_eq!(vector, Vec3::new(1 << 1, 2 << 1, 3 << 1));

§Consistency

For primitive types this operation is fully consistent with the scalar operation, including integer panics.

This operation is fully consistent with vector << vector.

Source §

impl<const N: usize, T, A: Alignment> Shr for Vector<N, T, A>
where Length<N>: SupportedLength, T: Scalar + Shr<Output = T>,

Source §

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

Performs the >> operation for each vector element.

§Examples

let a = Vec3::new(8, 16, 32);
let b = a >> Vec3::new(1, 2, 3);
assert_eq!(b, Vec3::new(8 >> 1, 16 >> 2, 32 >> 3));

§Consistency

For primitive types this operation is fully consistent with the scalar operation, including integer panics.

Source §

type Output = Vector<N, T, A>

The resulting type after applying the >> operator.

The resulting type after applying the >> operator.

The resulting type after applying the >> operator.

Source §

impl<const N: usize, T, A: Alignment> Shr<&Vector<N, T, A>> for Vector<N, T, A>
where Length<N>: SupportedLength, T: Scalar + Shr<Output = T>,

Source §

fn shr(self, rhs: &Vector<N, T, A>) -> Self::Output

Performs the >> operation for each vector element.

§Examples

let a = Vec3::new(8, 16, 32);
let b = a >> Vec3::new(1, 2, 3);
assert_eq!(b, Vec3::new(8 >> 1, 16 >> 2, 32 >> 3));

§Consistency

For primitive types this operation is fully consistent with the scalar operation, including integer panics.

Source §

type Output = Vector<N, T, A>

The resulting type after applying the >> operator.

Source §

impl<const N: usize, T, A: Alignment> Shr<&Vector<N, T, A>> for &Vector<N, T, A>
where Length<N>: SupportedLength, T: Scalar + Shr<Output = T>,

Source §

fn shr(self, rhs: &Vector<N, T, A>) -> Self::Output

Performs the >> operation for each vector element.

§Examples

let a = Vec3::new(8, 16, 32);
let b = a >> Vec3::new(1, 2, 3);
assert_eq!(b, Vec3::new(8 >> 1, 16 >> 2, 32 >> 3));

§Consistency

For primitive types this operation is fully consistent with the scalar operation, including integer panics.

Source §

type Output = Vector<N, T, A>

The resulting type after applying the >> operator.

The resulting type after applying the >> operator.

The resulting type after applying the >> operator.

Source §

impl<const N: usize, T, A: Alignment> Shr<Vector<N, T, A>> for &Vector<N, T, A>
where Length<N>: SupportedLength, T: Scalar + Shr<Output = T>,

Source §

fn shr(self, rhs: Vector<N, T, A>) -> Self::Output

Performs the >> operation for each vector element.

§Examples

let a = Vec3::new(8, 16, 32);
let b = a >> Vec3::new(1, 2, 3);
assert_eq!(b, Vec3::new(8 >> 1, 16 >> 2, 32 >> 3));

§Consistency

For primitive types this operation is fully consistent with the scalar operation, including integer panics.

Source §

type Output = Vector<N, T, A>

The resulting type after applying the >> operator.

let mut vector = Vec3::new(8, 16, 32);
vector >>= 1;
assert_eq!(vector, Vec3::new(8 >> 1, 16 >> 1, 32 >> 1));

§Consistency

For primitive types this operation is fully consistent with the scalar operation, including integer panics.

This operation is fully consistent with vector >> vector.

let mut vector = Vec3::new(8, 16, 32);
vector >>= 1;
assert_eq!(vector, Vec3::new(8 >> 1, 16 >> 1, 32 >> 1));

§Consistency

For primitive types this operation is fully consistent with the scalar operation, including integer panics.

This operation is fully consistent with vector >> vector.

Source §

impl<const N: usize, T, A: Alignment> Sub for Vector<N, T, A>
where Length<N>: SupportedLength, T: Scalar + Sub<Output = T>,

Source §

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

Performs the - operation for each vector element.

§Examples

let a = Vec3::new(1, 2, 3);
let b = a - Vec3::new(4, 5, 6);
assert_eq!(b, Vec3::new(1 - 4, 2 - 5, 3 - 6));

§Consistency

For primitive types this operation is fully consistent with the scalar operation, including floating-point precision and integer panics.

Source §

type Output = Vector<N, T, A>

The resulting type after applying the - operator.

The resulting type after applying the - operator.

The resulting type after applying the - operator.

Source §

impl<const N: usize, T, A: Alignment> Sub<&Vector<N, T, A>> for Vector<N, T, A>
where Length<N>: SupportedLength, T: Scalar + Sub<Output = T>,

Source §

fn sub(self, rhs: &Vector<N, T, A>) -> Self::Output

Performs the - operation for each vector element.

§Examples

let a = Vec3::new(1, 2, 3);
let b = a - Vec3::new(4, 5, 6);
assert_eq!(b, Vec3::new(1 - 4, 2 - 5, 3 - 6));

§Consistency

For primitive types this operation is fully consistent with the scalar operation, including floating-point precision and integer panics.

Source §

type Output = Vector<N, T, A>

The resulting type after applying the - operator.

Source §

impl<const N: usize, T, A: Alignment> Sub<&Vector<N, T, A>> for &Vector<N, T, A>
where Length<N>: SupportedLength, T: Scalar + Sub<Output = T>,

Source §

fn sub(self, rhs: &Vector<N, T, A>) -> Self::Output

Performs the - operation for each vector element.

§Examples

let a = Vec3::new(1, 2, 3);
let b = a - Vec3::new(4, 5, 6);
assert_eq!(b, Vec3::new(1 - 4, 2 - 5, 3 - 6));

§Consistency

For primitive types this operation is fully consistent with the scalar operation, including floating-point precision and integer panics.

Source §

type Output = Vector<N, T, A>

The resulting type after applying the - operator.

The resulting type after applying the - operator.

The resulting type after applying the - operator.

Source §

impl<const N: usize, T, A: Alignment> Sub<Vector<N, T, A>> for &Vector<N, T, A>
where Length<N>: SupportedLength, T: Scalar + Sub<Output = T>,

Source §

fn sub(self, rhs: Vector<N, T, A>) -> Self::Output

Performs the - operation for each vector element.

§Examples

let a = Vec3::new(1, 2, 3);
let b = a - Vec3::new(4, 5, 6);
assert_eq!(b, Vec3::new(1 - 4, 2 - 5, 3 - 6));

§Consistency

For primitive types this operation is fully consistent with the scalar operation, including floating-point precision and integer panics.

Source §

type Output = Vector<N, T, A>

The resulting type after applying the - operator.

let mut vector = Vec3::new(5, 7, 9);
vector -= 2;
assert_eq!(vector, Vec3::new(5 - 2, 7 - 2, 9 - 2));

§Consistency

For primitive types this operation is fully consistent with the scalar operation, including floating-point precision and integer panics.

This operation is fully consistent with vector - vector.

let mut vector = Vec3::new(5, 7, 9);
vector -= 2;
assert_eq!(vector, Vec3::new(5 - 2, 7 - 2, 9 - 2));

§Consistency

For primitive types this operation is fully consistent with the scalar operation, including floating-point precision and integer panics.

Source §

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

Performs the conversion.

Source §

impl<T, U> TryInto for T
where U: TryFrom<T>,

Source §

type Error = >::Error

The type returned in the event of a conversion error.

Source §

fn try_into(self) -> Result<U, >::Error>

Performs the conversion.

Struct Vector Copy item path

§Type aliases

§Fields

§Memory layout

Implementations§

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

pub const FALSE: Self

pub const TRUE: Self

pub fn all(self) -> bool

§Examples

pub fn any(self) -> bool

§Examples

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

§Examples

impl<const N: usize, T, A: Alignment> Vector<N, T, A>where Length<N>: SupportedLength, T: PrimitiveFloat,

pub const MIN: Self

pub const MAX: Self

pub const NAN: Self

pub const INFINITY: Self

pub const NEG_INFINITY: Self

pub fn is_nan(self) -> bool

§Examples

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

§Examples

pub fn is_finite(self) -> bool

§Examples

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

§Examples

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

§Examples

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

§Examples

pub fn recip(self) -> Self

§Examples

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

§Panics

§Examples

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

§Panics

§Examples

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

§Panics

§Examples

pub fn max_element(self) -> T

§Panics

§Examples

pub fn min_element(self) -> T

§Panics

§Examples

pub fn abs(self) -> Self

§Examples

pub fn signum(self) -> Self

§Examples

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

§Examples

pub fn floor(self) -> Self

§Examples

pub fn ceil(self) -> Self

§Examples

pub fn round(self) -> Self

§Examples

pub fn trunc(self) -> Self

§Examples

pub fn fract(self) -> Self

§Examples

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

§Precision

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

§Precision

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

§Precision

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

§Unspecified precision

pub fn sqrt(self) -> Self

§Precision

§Examples

pub fn exp(self) -> Self

§Unspecified precision

pub fn exp2(self) -> Self

§Unspecified precision

Struct Vector

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

impl<const N: usize, T, A: Alignment> Vector<N, T, A>
where Length<N>: SupportedLength, T: PrimitiveFloat,