Struct Vector4 

#[repr(C)]
pub struct Vector4<U: Unit = f32> {
    pub x: U::Scalar,
    pub y: U::Scalar,
    pub z: U::Scalar,
    pub w: U::Scalar,
}

4D vector.

Alignment

This is always has the same alignment as the scalar component type, and not the “normal” 128-bit alignment. This is due to limitations in the #[repr(align(...))] attribute when combined with generics.

Fields

x: U::Scalar

X coordinate

y: U::Scalar

Y coordinate

z: U::Scalar

Z coordinate

w: U::Scalar

W coordinate

Implementations

impl<T: Unit> Vector4<T>

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

New vector.

pub fn from_point(point: Point4<T>) -> Self

Instantiate from point.

pub fn to_point(self) -> Point4<T>

Convert to point.

pub fn as_point(&self) -> &Point4<T>

Reinterpret as point.

pub fn as_point_mut(&mut self) -> &mut Point4<T>

Reinterpret as point.

impl<T: Unit> Vector4<T>

pub fn splat(scalar: T::Scalar) -> Self

Set all elements to scalar.

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

Clamp all elements within min and max.

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

Return by-element minimum.

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

Return by-element maximum.

pub fn min_element(self) -> T::Scalar

Min element.

pub fn max_element(self) -> T::Scalar

Max element.

pub fn write_to_slice(self, slice: &mut [T::Scalar])

Write this vector type to a slice.

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

Replace x component.

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

Replace y component.

pub fn element_sum(self) -> T::Scalar

Sum of all elements.

pub fn element_product(self) -> T::Scalar

Product of all elements.

pub fn as_array(&self) -> &[T::Scalar; 4]

Reinterpret as array.

pub fn as_array_mut(&mut self) -> &mut [T::Scalar; 4]

Reinterpret as mutable array.

pub fn get(&self, index: usize) -> T::Scalar

Get component at index.

pub fn set(&mut self, index: usize, value: T::Scalar)

Set component at index.

pub fn const_get<const N: usize>(&self) -> T::Scalar

Get component at index N.

pub fn const_set<const N: usize>(&mut self, value: T::Scalar)

Set component at index N.

pub fn map<F: Fn(T::Scalar) -> T::Scalar>(self, f: F) -> Self

Returns a vector containing each element of self modified by a mapping function f.

pub fn from_untyped(untyped: Vector4<T::Scalar>) -> Vector4<T>

Bitcast an untyped instance to self.

pub fn to_untyped(self) -> Vector4<T::Scalar>

Bitcast self to an untyped instance.

pub fn as_untyped(&self) -> &Vector4<T::Scalar>

Reinterpret cast self as the untyped variant.

pub fn as_untyped_mut(&mut self) -> &mut Vector4<T::Scalar>

Reinterpret cast self as the untyped variant.

pub fn cast<T2>(self) -> Vector4<T2>

where T2: Unit<Scalar = T::Scalar>,

Cast to a different coordinate space with the same underlying scalar type.

pub fn cast_ref<T2>(&self) -> &Vector4<T2>

where T2: Unit<Scalar = T::Scalar>,

Cast to a different coordinate space with the same underlying scalar type.

pub fn cast_mut<T2>(&mut self) -> &mut Vector4<T2>

where T2: Unit<Scalar = T::Scalar>,

Cast to a different coordinate space with the same underlying scalar type.

pub fn as_<T2>(self) -> Vector4<T2>

where T: Unit<Scalar: AsPrimitive<T2::Scalar>>, T2: Unit,

Cast to a different coordinate space with scalar type conversion through the as operator (potentially narrowing or losing precision).

pub fn try_cast<T2>(self) -> Option<Vector4<T2>>

where T2: Unit,

Cast to a different coordinate space with scalar type conversion. Returns None if any component could not be converted to the target scalar type.

pub fn to_tuple(self) -> (T::Scalar, T::Scalar, T::Scalar, T::Scalar)

Convert this vector or point to a tuple.

pub fn from_tuple( (x, y, z, w): (T::Scalar, T::Scalar, T::Scalar, T::Scalar), ) -> Self

Create from tuple.

impl<T: FloatUnit> Vector4<T>

pub fn ceil(self) -> Self

Round all components up.

pub fn exp(self) -> Self

e^self by component

pub fn floor(self) -> Self

Round all components down.

pub fn fract(self) -> Self

See (e.g.) glam::Vec2::fract()

pub fn fract_gl(self) -> Self

See (e.g.) glam::Vec2::fract_gl()

pub fn is_finite(self) -> bool

True if all components are non-infinity and non-NaN.

pub fn is_nan(self) -> bool

True if any component is NaN.

pub fn lerp(self, rhs: Self, s: T::Scalar) -> Self

Linear interpolation.

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

self^n by component

pub fn recip(self) -> Self

1.0/self by component

pub fn round(self) -> Self

Round all components.

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

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

impl<T: SignedUnit> Vector4<T>

pub fn signum(self) -> Self

Returns a vector with elements representing the sign of self.

pub fn abs(self) -> Self

Returns a vector containing the absolute value of each element of self.

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

Returns the element-wise remainder of Euclidean division of self`` by rhs`.

Panics

This function will panic if any rhs element is 0 or the division results in overflow.

impl<T: IntUnit> Vector4<T>

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

Returns a vector containing the saturating addition of self and rhs.

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

Returns a vector containing the saturating subtraction of self and rhs.

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

Returns a vector containing the saturating multiplication of self and rhs.

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

Returns a vector containing the saturating division of self and rhs.

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

Returns a vector containing the wrapping addition of self and rhs.

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

Returns a vector containing the wrapping subtraction of self and rhs.

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

Returns a vector containing the wrapping multiplication of self and rhs.

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

Returns a vector containing the wrapping division of self and rhs.

impl<T: Unit> Vector4<T>

pub fn swizzle<const X: usize, const Y: usize, const Z: usize, const W: usize>( &self, ) -> Vector4<T>

Select components of this vector and return a new vector containing those components.

impl<T: Unit> Vector4<T>

pub const ZERO: Self

All zeroes.

pub const ONE: Self

All ones.

pub const X: Self

Unit vector in the direction of the X axis.

pub const Y: Self

Unit vector in the direction of the Y axis.

pub const Z: Self

Unit vector in the direction of the Z axis.

pub const W: Self

Unit vector in the direction of the W axis.

pub const AXES: [Self; 4]

The unit axes.

pub fn to_raw(self) -> <T::Scalar as Scalar>::Vec4

Transparently cast this type to its underlying, bitwise compatible glam type.

pub fn from_raw(vec: <T::Scalar as Scalar>::Vec4) -> Self

Convert a raw glam vector to this type. This is a zero-overhead cast.

impl<T: SignedUnit> Vector4<T>

pub const NEG_ONE: Self

All negative one.

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: FloatUnit> Vector4<T>

pub const NAN: Self

All NaN.

pub const INFINITY: Self

All positive infinity.

pub const NEG_INFINITY: Self

All negative infinity.

pub fn is_nan_mask(self) -> BVec4

Return a mask where each bit is set if the corresponding component is NaN.

pub fn is_finite_mask(self) -> BVec4

Performs is_finite on each element of self, returning a vector mask of the results.

impl<T: Unit> Vector4<T>

pub fn from_array(array: [T::Scalar; 4]) -> Self

Creates a new vector from an array.

pub fn to_array(&self) -> [T::Scalar; 4]

[x, y, z, w]

pub fn truncate(self) -> Vector3<T>

Creates a 3D vector by removing the w component.

pub fn cmpeq(self, rhs: Self) -> BVec4

Returns a vector mask containing the result of a == comparison for each element of self and rhs.

pub fn cmpne(self, rhs: Self) -> BVec4

Returns a vector mask containing the result of a != comparison for each element of self and rhs.

pub fn cmpge(self, rhs: Self) -> BVec4

Returns a vector mask containing the result of a >= comparison for each element of self and rhs.

pub fn cmpgt(self, rhs: Self) -> BVec4

Returns a vector mask containing the result of a > comparison for each element of self and rhs.

pub fn cmple(self, rhs: Self) -> BVec4

Returns a vector mask containing the result of a <= comparison for each element of self and rhs.

pub fn cmplt(self, rhs: Self) -> BVec4

Returns a vector mask containing the result of a < comparison for each element of self and rhs.

pub fn select(mask: BVec4, if_true: Self, if_false: Self) -> Self

Creates a vector from the elements in if_true and if_false, selecting which to use for each element of self.

A true element in the mask uses the corresponding element from if_true, and false uses the element from if_false.

pub fn with_z(self, z: T::Scalar) -> Self

Replace the z component.

pub fn with_w(self, w: T::Scalar) -> Self

Replace the w component.

impl<T: Unit> Vector4<T>

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

Dot product.

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

Returns a vector where every component is the dot product of self and rhs.

impl<T: SignedUnit> Vector4<T>

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

Returns the element-wise quotient of Euclidean division of self`` by rhs`.

Panics

This function will panic if any rhs element is 0 or the division results in overflow.

impl<T: FloatUnit> Vector4<T>

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

Clamp length

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

Clamp length

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

Clamp length

pub fn length(self) -> T::Scalar

Length of the vector

pub fn length_squared(self) -> T::Scalar

Squared length of the vector

pub fn length_recip(self) -> T::Scalar

Reciprocal length of the vector

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

self * a + b

pub fn normalize_or_zero(self) -> Self

Normalize the vector, returning zero if the length was already (very close to) zero.

pub fn normalize(self) -> Self

Normalize the vector. Undefined results in the vector’s length is (very close to) zero.

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

Returns self normalized to length 1.0 if possible, else returns a fallback value.

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

Normalize the vector, returning None if the length was already (very close to) zero.

pub fn is_normalized(self) -> bool

True if the vector is normalized.

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

See (e.g.) glam::Vec2::project_onto_normalized()

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

See (e.g.) glam::Vec2::project_onto()

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

See (e.g.) glam::Vec2::reject_from_normalized()

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

See (e.g.) glam::Vec2::reject_from()

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

Returns the reflection vector for a given incident vector self and surface normal normal.

normal must be normalized.

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

Returns the refraction direction for a given incident vector self, surface normal normal and ratio of indices of refraction, eta. When total internal reflection occurs, a zero vector will be returned.

self and normal must be normalized.

Trait Implementations

impl<T: FloatUnit> AbsDiffEq for Vector4<T>

type Epsilon = <<T as Unit>::Scalar as AbsDiffEq>::Epsilon

Used for specifying relative comparisons.

fn default_epsilon() -> Self::Epsilon

The default tolerance to use when testing values that are close together.

fn abs_diff_eq(&self, other: &Self, epsilon: Self::Epsilon) -> bool

A test for equality that uses the absolute difference to compute the approximate equality of two numbers.

fn abs_diff_ne(&self, other: &Self, epsilon: Self::Epsilon) -> bool

The inverse of AbsDiffEq::abs_diff_eq.

impl<T: Unit> Add<&Vector4<T>> for &Point4<T>

type Output = Point4<T>

The resulting type after applying the + operator.

fn add(self, rhs: &Vector4<T>) -> Point4<T>

Performs the + operation.

impl<T: Unit> Add<&Vector4<T>> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: &Vector4<T>) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = f32>> Add<&Vector4<T>> for &f32

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: &Vector4<T>) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = f64>> Add<&Vector4<T>> for &f64

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: &Vector4<T>) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = i16>> Add<&Vector4<T>> for &i16

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: &Vector4<T>) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = i32>> Add<&Vector4<T>> for &i32

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: &Vector4<T>) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = i64>> Add<&Vector4<T>> for &i64

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: &Vector4<T>) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = u16>> Add<&Vector4<T>> for &u16

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: &Vector4<T>) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = u32>> Add<&Vector4<T>> for &u32

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: &Vector4<T>) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = u64>> Add<&Vector4<T>> for &u64

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: &Vector4<T>) -> Vector4<T>

Performs the + operation.

impl<T: Unit> Add<&Vector4<T>> for Point4<T>

type Output = Point4<T>

The resulting type after applying the + operator.

fn add(self, rhs: &Vector4<T>) -> Point4<T>

Performs the + operation.

impl<T: Unit> Add<&Vector4<T>> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: &Vector4<T>) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = f32>> Add<&Vector4<T>> for f32

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: &Vector4<T>) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = f64>> Add<&Vector4<T>> for f64

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: &Vector4<T>) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = i16>> Add<&Vector4<T>> for i16

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: &Vector4<T>) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = i32>> Add<&Vector4<T>> for i32

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: &Vector4<T>) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = i64>> Add<&Vector4<T>> for i64

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: &Vector4<T>) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = u16>> Add<&Vector4<T>> for u16

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: &Vector4<T>) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = u32>> Add<&Vector4<T>> for u32

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: &Vector4<T>) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = u64>> Add<&Vector4<T>> for u64

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: &Vector4<T>) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = f32>> Add<&f32> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: &f32) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = f32>> Add<&f32> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: &f32) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = f64>> Add<&f64> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: &f64) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = f64>> Add<&f64> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: &f64) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = i16>> Add<&i16> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: &i16) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = i16>> Add<&i16> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: &i16) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = i32>> Add<&i32> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: &i32) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = i32>> Add<&i32> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: &i32) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = i64>> Add<&i64> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: &i64) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = i64>> Add<&i64> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: &i64) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = u16>> Add<&u16> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: &u16) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = u16>> Add<&u16> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: &u16) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = u32>> Add<&u32> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: &u32) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = u32>> Add<&u32> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: &u32) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = u64>> Add<&u64> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: &u64) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = u64>> Add<&u64> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: &u64) -> Vector4<T>

Performs the + operation.

impl<T: Unit> Add<Vector4<T>> for &Point4<T>

type Output = Point4<T>

The resulting type after applying the + operator.

fn add(self, rhs: Vector4<T>) -> Point4<T>

Performs the + operation.

impl<T: Unit> Add<Vector4<T>> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: Vector4<T>) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = f32>> Add<Vector4<T>> for &f32

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: Vector4<T>) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = f64>> Add<Vector4<T>> for &f64

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: Vector4<T>) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = i16>> Add<Vector4<T>> for &i16

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: Vector4<T>) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = i32>> Add<Vector4<T>> for &i32

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: Vector4<T>) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = i64>> Add<Vector4<T>> for &i64

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: Vector4<T>) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = u16>> Add<Vector4<T>> for &u16

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: Vector4<T>) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = u32>> Add<Vector4<T>> for &u32

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: Vector4<T>) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = u64>> Add<Vector4<T>> for &u64

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: Vector4<T>) -> Vector4<T>

Performs the + operation.

impl<T: Unit> Add<Vector4<T>> for Point4<T>

type Output = Point4<T>

The resulting type after applying the + operator.

fn add(self, rhs: Vector4<T>) -> Point4<T>

Performs the + operation.

impl<T: Unit<Scalar = f32>> Add<Vector4<T>> for f32

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: Vector4<T>) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = f64>> Add<Vector4<T>> for f64

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: Vector4<T>) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = i16>> Add<Vector4<T>> for i16

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: Vector4<T>) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = i32>> Add<Vector4<T>> for i32

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: Vector4<T>) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = i64>> Add<Vector4<T>> for i64

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: Vector4<T>) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = u16>> Add<Vector4<T>> for u16

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: Vector4<T>) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = u32>> Add<Vector4<T>> for u32

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: Vector4<T>) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = u64>> Add<Vector4<T>> for u64

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: Vector4<T>) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = f32>> Add<f32> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: f32) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = f32>> Add<f32> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: f32) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = f64>> Add<f64> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: f64) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = f64>> Add<f64> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: f64) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = i16>> Add<i16> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: i16) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = i16>> Add<i16> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: i16) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = i32>> Add<i32> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: i32) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = i32>> Add<i32> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: i32) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = i64>> Add<i64> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: i64) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = i64>> Add<i64> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: i64) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = u16>> Add<u16> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: u16) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = u16>> Add<u16> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: u16) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = u32>> Add<u32> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: u32) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = u32>> Add<u32> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: u32) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = u64>> Add<u64> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: u64) -> Vector4<T>

Performs the + operation.

impl<T: Unit<Scalar = u64>> Add<u64> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: u64) -> Vector4<T>

Performs the + operation.

impl<T: Unit> Add for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the + operator.

fn add(self, rhs: Vector4<T>) -> Vector4<T>

Performs the + operation.

impl<T: Unit> AddAssign<&Vector4<T>> for Point4<T>

fn add_assign(&mut self, rhs: &Vector4<T>)

Performs the += operation.

impl<T: Unit> AddAssign<&Vector4<T>> for Vector4<T>

fn add_assign(&mut self, rhs: &Vector4<T>)

Performs the += operation.

impl<T: Unit<Scalar = f32>> AddAssign<&f32> for Vector4<T>

fn add_assign(&mut self, rhs: &f32)

Performs the += operation.

impl<T: Unit<Scalar = f64>> AddAssign<&f64> for Vector4<T>

fn add_assign(&mut self, rhs: &f64)

Performs the += operation.

impl<T: Unit<Scalar = i16>> AddAssign<&i16> for Vector4<T>

fn add_assign(&mut self, rhs: &i16)

Performs the += operation.

impl<T: Unit<Scalar = i32>> AddAssign<&i32> for Vector4<T>

fn add_assign(&mut self, rhs: &i32)

Performs the += operation.

impl<T: Unit<Scalar = i64>> AddAssign<&i64> for Vector4<T>

fn add_assign(&mut self, rhs: &i64)

Performs the += operation.

impl<T: Unit<Scalar = u16>> AddAssign<&u16> for Vector4<T>

fn add_assign(&mut self, rhs: &u16)

Performs the += operation.

impl<T: Unit<Scalar = u32>> AddAssign<&u32> for Vector4<T>

fn add_assign(&mut self, rhs: &u32)

Performs the += operation.

impl<T: Unit<Scalar = u64>> AddAssign<&u64> for Vector4<T>

fn add_assign(&mut self, rhs: &u64)

Performs the += operation.

impl<T: Unit> AddAssign<Vector4<T>> for Point4<T>

fn add_assign(&mut self, rhs: Vector4<T>)

Performs the += operation.

impl<T: Unit<Scalar = f32>> AddAssign<f32> for Vector4<T>

fn add_assign(&mut self, rhs: f32)

Performs the += operation.

impl<T: Unit<Scalar = f64>> AddAssign<f64> for Vector4<T>

fn add_assign(&mut self, rhs: f64)

Performs the += operation.

impl<T: Unit<Scalar = i16>> AddAssign<i16> for Vector4<T>

fn add_assign(&mut self, rhs: i16)

Performs the += operation.

impl<T: Unit<Scalar = i32>> AddAssign<i32> for Vector4<T>

fn add_assign(&mut self, rhs: i32)

Performs the += operation.

impl<T: Unit<Scalar = i64>> AddAssign<i64> for Vector4<T>

fn add_assign(&mut self, rhs: i64)

Performs the += operation.

impl<T: Unit<Scalar = u16>> AddAssign<u16> for Vector4<T>

fn add_assign(&mut self, rhs: u16)

Performs the += operation.

impl<T: Unit<Scalar = u32>> AddAssign<u32> for Vector4<T>

fn add_assign(&mut self, rhs: u32)

Performs the += operation.

impl<T: Unit<Scalar = u64>> AddAssign<u64> for Vector4<T>

fn add_assign(&mut self, rhs: u64)

Performs the += operation.

impl<T: Unit> AddAssign for Vector4<T>

fn add_assign(&mut self, rhs: Vector4<T>)

Performs the += operation.

impl<T: Unit> AsMut<[<T as Unit>::Scalar; 4]> for Vector4<T>

fn as_mut(&mut self) -> &mut [T::Scalar; 4]

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

impl<T: Unit> AsRef<[<T as Unit>::Scalar; 4]> for Vector4<T>

fn as_ref(&self) -> &[T::Scalar; 4]

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

impl<T: Unit> Clone for Vector4<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Unit> Debug for Vector4<T>

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

Formats the value using the given formatter.

impl<T: Unit> Default for Vector4<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T: Unit> Div<&Vector4<T>> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the / operator.

fn div(self, rhs: &Vector4<T>) -> Vector4<T>

Performs the / operation.

impl<T: Unit> Div<&Vector4<T>> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the / operator.

fn div(self, rhs: &Vector4<T>) -> Vector4<T>

Performs the / operation.

impl<T: Unit<Scalar = f32>> Div<&f32> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the / operator.

fn div(self, rhs: &f32) -> Vector4<T>

Performs the / operation.

impl<T: Unit<Scalar = f32>> Div<&f32> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the / operator.

fn div(self, rhs: &f32) -> Vector4<T>

Performs the / operation.

impl<T: Unit<Scalar = f64>> Div<&f64> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the / operator.

fn div(self, rhs: &f64) -> Vector4<T>

Performs the / operation.

impl<T: Unit<Scalar = f64>> Div<&f64> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the / operator.

fn div(self, rhs: &f64) -> Vector4<T>

Performs the / operation.

impl<T: Unit<Scalar = i16>> Div<&i16> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the / operator.

fn div(self, rhs: &i16) -> Vector4<T>

Performs the / operation.

impl<T: Unit<Scalar = i16>> Div<&i16> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the / operator.

fn div(self, rhs: &i16) -> Vector4<T>

Performs the / operation.

impl<T: Unit<Scalar = i32>> Div<&i32> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the / operator.

fn div(self, rhs: &i32) -> Vector4<T>

Performs the / operation.

impl<T: Unit<Scalar = i32>> Div<&i32> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the / operator.

fn div(self, rhs: &i32) -> Vector4<T>

Performs the / operation.

impl<T: Unit<Scalar = i64>> Div<&i64> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the / operator.

fn div(self, rhs: &i64) -> Vector4<T>

Performs the / operation.

impl<T: Unit<Scalar = i64>> Div<&i64> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the / operator.

fn div(self, rhs: &i64) -> Vector4<T>

Performs the / operation.

impl<T: Unit<Scalar = u16>> Div<&u16> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the / operator.

fn div(self, rhs: &u16) -> Vector4<T>

Performs the / operation.

impl<T: Unit<Scalar = u16>> Div<&u16> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the / operator.

fn div(self, rhs: &u16) -> Vector4<T>

Performs the / operation.

impl<T: Unit<Scalar = u32>> Div<&u32> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the / operator.

fn div(self, rhs: &u32) -> Vector4<T>

Performs the / operation.

impl<T: Unit<Scalar = u32>> Div<&u32> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the / operator.

fn div(self, rhs: &u32) -> Vector4<T>

Performs the / operation.

impl<T: Unit<Scalar = u64>> Div<&u64> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the / operator.

fn div(self, rhs: &u64) -> Vector4<T>

Performs the / operation.

impl<T: Unit<Scalar = u64>> Div<&u64> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the / operator.

fn div(self, rhs: &u64) -> Vector4<T>

Performs the / operation.

impl<T: Unit> Div<Vector4<T>> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the / operator.

fn div(self, rhs: Vector4<T>) -> Vector4<T>

Performs the / operation.

impl<T: Unit<Scalar = f32>> Div<f32> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the / operator.

fn div(self, rhs: f32) -> Vector4<T>

Performs the / operation.

impl<T: Unit<Scalar = f32>> Div<f32> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the / operator.

fn div(self, rhs: f32) -> Vector4<T>

Performs the / operation.

impl<T: Unit<Scalar = f64>> Div<f64> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the / operator.

fn div(self, rhs: f64) -> Vector4<T>

Performs the / operation.

impl<T: Unit<Scalar = f64>> Div<f64> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the / operator.

fn div(self, rhs: f64) -> Vector4<T>

Performs the / operation.

impl<T: Unit<Scalar = i16>> Div<i16> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the / operator.

fn div(self, rhs: i16) -> Vector4<T>

Performs the / operation.

impl<T: Unit<Scalar = i16>> Div<i16> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the / operator.

fn div(self, rhs: i16) -> Vector4<T>

Performs the / operation.

impl<T: Unit<Scalar = i32>> Div<i32> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the / operator.

fn div(self, rhs: i32) -> Vector4<T>

Performs the / operation.

impl<T: Unit<Scalar = i32>> Div<i32> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the / operator.

fn div(self, rhs: i32) -> Vector4<T>

Performs the / operation.

impl<T: Unit<Scalar = i64>> Div<i64> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the / operator.

fn div(self, rhs: i64) -> Vector4<T>

Performs the / operation.

impl<T: Unit<Scalar = i64>> Div<i64> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the / operator.

fn div(self, rhs: i64) -> Vector4<T>

Performs the / operation.

impl<T: Unit<Scalar = u16>> Div<u16> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the / operator.

fn div(self, rhs: u16) -> Vector4<T>

Performs the / operation.

impl<T: Unit<Scalar = u16>> Div<u16> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the / operator.

fn div(self, rhs: u16) -> Vector4<T>

Performs the / operation.

impl<T: Unit<Scalar = u32>> Div<u32> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the / operator.

fn div(self, rhs: u32) -> Vector4<T>

Performs the / operation.

impl<T: Unit<Scalar = u32>> Div<u32> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the / operator.

fn div(self, rhs: u32) -> Vector4<T>

Performs the / operation.

impl<T: Unit<Scalar = u64>> Div<u64> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the / operator.

fn div(self, rhs: u64) -> Vector4<T>

Performs the / operation.

impl<T: Unit<Scalar = u64>> Div<u64> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the / operator.

fn div(self, rhs: u64) -> Vector4<T>

Performs the / operation.

impl<T: Unit> Div for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the / operator.

fn div(self, rhs: Vector4<T>) -> Vector4<T>

Performs the / operation.

impl<T: Unit> DivAssign<&Vector4<T>> for Vector4<T>

fn div_assign(&mut self, rhs: &Vector4<T>)

Performs the /= operation.

impl<T: Unit<Scalar = f32>> DivAssign<&f32> for Vector4<T>

fn div_assign(&mut self, rhs: &f32)

Performs the /= operation.

impl<T: Unit<Scalar = f64>> DivAssign<&f64> for Vector4<T>

fn div_assign(&mut self, rhs: &f64)

Performs the /= operation.

impl<T: Unit<Scalar = i16>> DivAssign<&i16> for Vector4<T>

fn div_assign(&mut self, rhs: &i16)

Performs the /= operation.

impl<T: Unit<Scalar = i32>> DivAssign<&i32> for Vector4<T>

fn div_assign(&mut self, rhs: &i32)

Performs the /= operation.

impl<T: Unit<Scalar = i64>> DivAssign<&i64> for Vector4<T>

fn div_assign(&mut self, rhs: &i64)

Performs the /= operation.

impl<T: Unit<Scalar = u16>> DivAssign<&u16> for Vector4<T>

fn div_assign(&mut self, rhs: &u16)

Performs the /= operation.

impl<T: Unit<Scalar = u32>> DivAssign<&u32> for Vector4<T>

fn div_assign(&mut self, rhs: &u32)

Performs the /= operation.

impl<T: Unit<Scalar = u64>> DivAssign<&u64> for Vector4<T>

fn div_assign(&mut self, rhs: &u64)

Performs the /= operation.

impl<T: Unit<Scalar = f32>> DivAssign<f32> for Vector4<T>

fn div_assign(&mut self, rhs: f32)

Performs the /= operation.

impl<T: Unit<Scalar = f64>> DivAssign<f64> for Vector4<T>

fn div_assign(&mut self, rhs: f64)

Performs the /= operation.

impl<T: Unit<Scalar = i16>> DivAssign<i16> for Vector4<T>

fn div_assign(&mut self, rhs: i16)

Performs the /= operation.

impl<T: Unit<Scalar = i32>> DivAssign<i32> for Vector4<T>

fn div_assign(&mut self, rhs: i32)

Performs the /= operation.

impl<T: Unit<Scalar = i64>> DivAssign<i64> for Vector4<T>

fn div_assign(&mut self, rhs: i64)

Performs the /= operation.

impl<T: Unit<Scalar = u16>> DivAssign<u16> for Vector4<T>

fn div_assign(&mut self, rhs: u16)

Performs the /= operation.

impl<T: Unit<Scalar = u32>> DivAssign<u32> for Vector4<T>

fn div_assign(&mut self, rhs: u32)

Performs the /= operation.

impl<T: Unit<Scalar = u64>> DivAssign<u64> for Vector4<T>

fn div_assign(&mut self, rhs: u64)

Performs the /= operation.

impl<T: Unit> DivAssign for Vector4<T>

fn div_assign(&mut self, rhs: Vector4<T>)

Performs the /= operation.

impl<T: Unit> From<[<T as Unit>::Scalar; 4]> for Vector4<T>

fn from(value: [T::Scalar; 4]) -> Self

Converts to this type from the input type.

impl<T: Unit> From<(<T as Unit>::Scalar, <T as Unit>::Scalar, <T as Unit>::Scalar, <T as Unit>::Scalar)> for Vector4<T>

fn from((x, y, z, w): (T::Scalar, T::Scalar, T::Scalar, T::Scalar)) -> Self

Converts to this type from the input type.

impl<T: Unit> From<BVec4> for Vector4<T>

fn from(v: BVec4) -> Self

Converts to this type from the input type.

impl<T: Unit<Scalar = f64>> From<DVec4> for Vector4<T>

fn from(value: DVec4) -> Self

Converts to this type from the input type.

impl<T: Unit<Scalar = i16>> From<I16Vec4> for Vector4<T>

fn from(value: I16Vec4) -> Self

Converts to this type from the input type.

impl<T: Unit<Scalar = i64>> From<I64Vec4> for Vector4<T>

fn from(value: I64Vec4) -> Self

Converts to this type from the input type.

impl<T: Unit<Scalar = i32>> From<IVec4> for Vector4<T>

fn from(value: IVec4) -> Self

Converts to this type from the input type.

impl<T: Unit> From<Point4<T>> for Vector4<T>

fn from(point: Point4<T>) -> Vector4<T>

Converts to this type from the input type.

impl<T: Unit<Scalar = u16>> From<U16Vec4> for Vector4<T>

fn from(value: U16Vec4) -> Self

Converts to this type from the input type.

impl<T: Unit<Scalar = u64>> From<U64Vec4> for Vector4<T>

fn from(value: U64Vec4) -> Self

Converts to this type from the input type.

impl<T: Unit<Scalar = u32>> From<UVec4> for Vector4<T>

fn from(value: UVec4) -> Self

Converts to this type from the input type.

impl<T: Unit<Scalar = f32>> From<Vec4> for Vector4<T>

fn from(value: Vec4) -> Self

Converts to this type from the input type.

impl<T: Unit> From<Vector4<T>> for [T::Scalar; 4]

fn from(value: Vector4<T>) -> [T::Scalar; 4]

Converts to this type from the input type.

impl<T: Unit> From<Vector4<T>> for (T::Scalar, T::Scalar, T::Scalar, T::Scalar)

fn from(value: Vector4<T>) -> Self

Converts to this type from the input type.

impl<T: Unit<Scalar = f64>> From<Vector4<T>> for DVec4

fn from(value: Vector4<T>) -> Self

Converts to this type from the input type.

impl<T: Unit<Scalar = i16>> From<Vector4<T>> for I16Vec4

fn from(value: Vector4<T>) -> Self

Converts to this type from the input type.

impl<T: Unit<Scalar = i64>> From<Vector4<T>> for I64Vec4

fn from(value: Vector4<T>) -> Self

Converts to this type from the input type.

impl<T: Unit<Scalar = i32>> From<Vector4<T>> for IVec4

fn from(value: Vector4<T>) -> Self

Converts to this type from the input type.

impl<T: Unit> From<Vector4<T>> for Point4<T>

fn from(vec: Vector4<T>) -> Point4<T>

Converts to this type from the input type.

impl<T: Unit<Scalar = u16>> From<Vector4<T>> for U16Vec4

fn from(value: Vector4<T>) -> Self

Converts to this type from the input type.

impl<T: Unit<Scalar = u64>> From<Vector4<T>> for U64Vec4

fn from(value: Vector4<T>) -> Self

Converts to this type from the input type.

impl<T: Unit<Scalar = u32>> From<Vector4<T>> for UVec4

fn from(value: Vector4<T>) -> Self

Converts to this type from the input type.

impl<T: Unit<Scalar = f32>> From<Vector4<T>> for Vec4

fn from(value: Vector4<T>) -> Self

Converts to this type from the input type.

impl<T: IntUnit> Hash for Vector4<T>

fn hash<H>(&self, state: &mut H)

where H: Hasher,

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<T: Unit> Index<usize> for Vector4<T>

type Output = <T as Unit>::Scalar

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T: Unit> IndexMut<usize> for Vector4<T>

fn index_mut(&mut self, index: usize) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<T: Unit> IntoIterator for Vector4<T>

type Item = <T as Unit>::Scalar

The type of the elements being iterated over.

type IntoIter = <[<T as Unit>::Scalar; 4] 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<T: Unit> Mul<&Vector4<T>> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: &Vector4<T>) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = f32>> Mul<&Vector4<T>> for &f32

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: &Vector4<T>) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = f64>> Mul<&Vector4<T>> for &f64

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: &Vector4<T>) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = i16>> Mul<&Vector4<T>> for &i16

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: &Vector4<T>) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = i32>> Mul<&Vector4<T>> for &i32

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: &Vector4<T>) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = i64>> Mul<&Vector4<T>> for &i64

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: &Vector4<T>) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = u16>> Mul<&Vector4<T>> for &u16

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: &Vector4<T>) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = u32>> Mul<&Vector4<T>> for &u32

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: &Vector4<T>) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = u64>> Mul<&Vector4<T>> for &u64

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: &Vector4<T>) -> Vector4<T>

Performs the * operation.

impl<T: Unit> Mul<&Vector4<T>> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: &Vector4<T>) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = f32>> Mul<&Vector4<T>> for f32

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: &Vector4<T>) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = f64>> Mul<&Vector4<T>> for f64

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: &Vector4<T>) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = i16>> Mul<&Vector4<T>> for i16

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: &Vector4<T>) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = i32>> Mul<&Vector4<T>> for i32

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: &Vector4<T>) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = i64>> Mul<&Vector4<T>> for i64

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: &Vector4<T>) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = u16>> Mul<&Vector4<T>> for u16

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: &Vector4<T>) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = u32>> Mul<&Vector4<T>> for u32

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: &Vector4<T>) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = u64>> Mul<&Vector4<T>> for u64

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: &Vector4<T>) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = f32>> Mul<&f32> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: &f32) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = f32>> Mul<&f32> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: &f32) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = f64>> Mul<&f64> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: &f64) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = f64>> Mul<&f64> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: &f64) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = i16>> Mul<&i16> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: &i16) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = i16>> Mul<&i16> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: &i16) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = i32>> Mul<&i32> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: &i32) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = i32>> Mul<&i32> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: &i32) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = i64>> Mul<&i64> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: &i64) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = i64>> Mul<&i64> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: &i64) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = u16>> Mul<&u16> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: &u16) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = u16>> Mul<&u16> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: &u16) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = u32>> Mul<&u32> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: &u32) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = u32>> Mul<&u32> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: &u32) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = u64>> Mul<&u64> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: &u64) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = u64>> Mul<&u64> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: &u64) -> Vector4<T>

Performs the * operation.

impl<T: Unit> Mul<Vector4<T>> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Vector4<T>) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = f32>> Mul<Vector4<T>> for &f32

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Vector4<T>) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = f64>> Mul<Vector4<T>> for &f64

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Vector4<T>) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = i16>> Mul<Vector4<T>> for &i16

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Vector4<T>) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = i32>> Mul<Vector4<T>> for &i32

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Vector4<T>) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = i64>> Mul<Vector4<T>> for &i64

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Vector4<T>) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = u16>> Mul<Vector4<T>> for &u16

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Vector4<T>) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = u32>> Mul<Vector4<T>> for &u32

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Vector4<T>) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = u64>> Mul<Vector4<T>> for &u64

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Vector4<T>) -> Vector4<T>

Performs the * operation.

impl<T> Mul<Vector4<T>> for Matrix4<T::Scalar>

where T: FloatUnit,

type Output = Vector4<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T: Unit<Scalar = f32>> Mul<Vector4<T>> for f32

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Vector4<T>) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = f64>> Mul<Vector4<T>> for f64

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Vector4<T>) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = i16>> Mul<Vector4<T>> for i16

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Vector4<T>) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = i32>> Mul<Vector4<T>> for i32

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Vector4<T>) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = i64>> Mul<Vector4<T>> for i64

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Vector4<T>) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = u16>> Mul<Vector4<T>> for u16

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Vector4<T>) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = u32>> Mul<Vector4<T>> for u32

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Vector4<T>) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = u64>> Mul<Vector4<T>> for u64

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Vector4<T>) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = f32>> Mul<f32> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: f32) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = f32>> Mul<f32> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: f32) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = f64>> Mul<f64> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: f64) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = f64>> Mul<f64> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: f64) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = i16>> Mul<i16> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: i16) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = i16>> Mul<i16> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: i16) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = i32>> Mul<i32> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: i32) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = i32>> Mul<i32> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: i32) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = i64>> Mul<i64> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: i64) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = i64>> Mul<i64> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: i64) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = u16>> Mul<u16> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: u16) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = u16>> Mul<u16> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: u16) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = u32>> Mul<u32> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: u32) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = u32>> Mul<u32> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: u32) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = u64>> Mul<u64> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: u64) -> Vector4<T>

Performs the * operation.

impl<T: Unit<Scalar = u64>> Mul<u64> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: u64) -> Vector4<T>

Performs the * operation.

impl<T: Unit> Mul for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the * operator.

fn mul(self, rhs: Vector4<T>) -> Vector4<T>

Performs the * operation.

impl<T: Unit> MulAssign<&Vector4<T>> for Vector4<T>

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

Performs the *= operation.

impl<T: Unit<Scalar = f32>> MulAssign<&f32> for Vector4<T>

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

Performs the *= operation.

impl<T: Unit<Scalar = f64>> MulAssign<&f64> for Vector4<T>

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

Performs the *= operation.

impl<T: Unit<Scalar = i16>> MulAssign<&i16> for Vector4<T>

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

Performs the *= operation.

impl<T: Unit<Scalar = i32>> MulAssign<&i32> for Vector4<T>

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

Performs the *= operation.

impl<T: Unit<Scalar = i64>> MulAssign<&i64> for Vector4<T>

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

Performs the *= operation.

impl<T: Unit<Scalar = u16>> MulAssign<&u16> for Vector4<T>

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

Performs the *= operation.

impl<T: Unit<Scalar = u32>> MulAssign<&u32> for Vector4<T>

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

Performs the *= operation.

impl<T: Unit<Scalar = u64>> MulAssign<&u64> for Vector4<T>

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

Performs the *= operation.

impl<T: Unit<Scalar = f32>> MulAssign<f32> for Vector4<T>

fn mul_assign(&mut self, rhs: f32)

Performs the *= operation.

impl<T: Unit<Scalar = f64>> MulAssign<f64> for Vector4<T>

fn mul_assign(&mut self, rhs: f64)

Performs the *= operation.

impl<T: Unit<Scalar = i16>> MulAssign<i16> for Vector4<T>

fn mul_assign(&mut self, rhs: i16)

Performs the *= operation.

impl<T: Unit<Scalar = i32>> MulAssign<i32> for Vector4<T>

fn mul_assign(&mut self, rhs: i32)

Performs the *= operation.

impl<T: Unit<Scalar = i64>> MulAssign<i64> for Vector4<T>

fn mul_assign(&mut self, rhs: i64)

Performs the *= operation.

impl<T: Unit<Scalar = u16>> MulAssign<u16> for Vector4<T>

fn mul_assign(&mut self, rhs: u16)

Performs the *= operation.

impl<T: Unit<Scalar = u32>> MulAssign<u32> for Vector4<T>

fn mul_assign(&mut self, rhs: u32)

Performs the *= operation.

impl<T: Unit<Scalar = u64>> MulAssign<u64> for Vector4<T>

fn mul_assign(&mut self, rhs: u64)

Performs the *= operation.

impl<T: Unit> MulAssign for Vector4<T>

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

Performs the *= operation.

impl<T: SignedUnit> Neg for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl<T: Unit> PartialEq for Vector4<T>

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, T: Unit> Product<&'a Vector4<T>> for Vector4<T>

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

where I: Iterator<Item = &'a Self>,

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

impl<T: FloatUnit> RelativeEq for Vector4<T>

fn default_max_relative() -> Self::Epsilon

The default relative tolerance for testing values that are far-apart.

fn relative_eq( &self, other: &Self, epsilon: Self::Epsilon, max_relative: Self::Epsilon, ) -> bool

A test for equality that uses a relative comparison if the values are far apart.

fn relative_ne( &self, other: &Self, epsilon: Self::Epsilon, max_relative: Self::Epsilon, ) -> bool

The inverse of RelativeEq::relative_eq.

impl<T: Unit> Rem<&Vector4<T>> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the % operator.

fn rem(self, rhs: &Vector4<T>) -> Vector4<T>

Performs the % operation.

impl<T: Unit> Rem<&Vector4<T>> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the % operator.

fn rem(self, rhs: &Vector4<T>) -> Vector4<T>

Performs the % operation.

impl<T: Unit<Scalar = f32>> Rem<&f32> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the % operator.

fn rem(self, rhs: &f32) -> Vector4<T>

Performs the % operation.

impl<T: Unit<Scalar = f32>> Rem<&f32> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the % operator.

fn rem(self, rhs: &f32) -> Vector4<T>

Performs the % operation.

impl<T: Unit<Scalar = f64>> Rem<&f64> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the % operator.

fn rem(self, rhs: &f64) -> Vector4<T>

Performs the % operation.

impl<T: Unit<Scalar = f64>> Rem<&f64> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the % operator.

fn rem(self, rhs: &f64) -> Vector4<T>

Performs the % operation.

impl<T: Unit<Scalar = i16>> Rem<&i16> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the % operator.

fn rem(self, rhs: &i16) -> Vector4<T>

Performs the % operation.

impl<T: Unit<Scalar = i16>> Rem<&i16> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the % operator.

fn rem(self, rhs: &i16) -> Vector4<T>

Performs the % operation.

impl<T: Unit<Scalar = i32>> Rem<&i32> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the % operator.

fn rem(self, rhs: &i32) -> Vector4<T>

Performs the % operation.

impl<T: Unit<Scalar = i32>> Rem<&i32> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the % operator.

fn rem(self, rhs: &i32) -> Vector4<T>

Performs the % operation.

impl<T: Unit<Scalar = i64>> Rem<&i64> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the % operator.

fn rem(self, rhs: &i64) -> Vector4<T>

Performs the % operation.

impl<T: Unit<Scalar = i64>> Rem<&i64> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the % operator.

fn rem(self, rhs: &i64) -> Vector4<T>

Performs the % operation.

impl<T: Unit<Scalar = u16>> Rem<&u16> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the % operator.

fn rem(self, rhs: &u16) -> Vector4<T>

Performs the % operation.

impl<T: Unit<Scalar = u16>> Rem<&u16> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the % operator.

fn rem(self, rhs: &u16) -> Vector4<T>

Performs the % operation.

impl<T: Unit<Scalar = u32>> Rem<&u32> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the % operator.

fn rem(self, rhs: &u32) -> Vector4<T>

Performs the % operation.

impl<T: Unit<Scalar = u32>> Rem<&u32> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the % operator.

fn rem(self, rhs: &u32) -> Vector4<T>

Performs the % operation.

impl<T: Unit<Scalar = u64>> Rem<&u64> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the % operator.

fn rem(self, rhs: &u64) -> Vector4<T>

Performs the % operation.

impl<T: Unit<Scalar = u64>> Rem<&u64> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the % operator.

fn rem(self, rhs: &u64) -> Vector4<T>

Performs the % operation.

impl<T: Unit> Rem<Vector4<T>> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the % operator.

fn rem(self, rhs: Vector4<T>) -> Vector4<T>

Performs the % operation.

impl<T: Unit<Scalar = f32>> Rem<f32> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the % operator.

fn rem(self, rhs: f32) -> Vector4<T>

Performs the % operation.

impl<T: Unit<Scalar = f32>> Rem<f32> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the % operator.

fn rem(self, rhs: f32) -> Vector4<T>

Performs the % operation.

impl<T: Unit<Scalar = f64>> Rem<f64> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the % operator.

fn rem(self, rhs: f64) -> Vector4<T>

Performs the % operation.

impl<T: Unit<Scalar = f64>> Rem<f64> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the % operator.

fn rem(self, rhs: f64) -> Vector4<T>

Performs the % operation.

impl<T: Unit<Scalar = i16>> Rem<i16> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the % operator.

fn rem(self, rhs: i16) -> Vector4<T>

Performs the % operation.

impl<T: Unit<Scalar = i16>> Rem<i16> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the % operator.

fn rem(self, rhs: i16) -> Vector4<T>

Performs the % operation.

impl<T: Unit<Scalar = i32>> Rem<i32> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the % operator.

fn rem(self, rhs: i32) -> Vector4<T>

Performs the % operation.

impl<T: Unit<Scalar = i32>> Rem<i32> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the % operator.

fn rem(self, rhs: i32) -> Vector4<T>

Performs the % operation.

impl<T: Unit<Scalar = i64>> Rem<i64> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the % operator.

fn rem(self, rhs: i64) -> Vector4<T>

Performs the % operation.

impl<T: Unit<Scalar = i64>> Rem<i64> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the % operator.

fn rem(self, rhs: i64) -> Vector4<T>

Performs the % operation.

impl<T: Unit<Scalar = u16>> Rem<u16> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the % operator.

fn rem(self, rhs: u16) -> Vector4<T>

Performs the % operation.

impl<T: Unit<Scalar = u16>> Rem<u16> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the % operator.

fn rem(self, rhs: u16) -> Vector4<T>

Performs the % operation.

impl<T: Unit<Scalar = u32>> Rem<u32> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the % operator.

fn rem(self, rhs: u32) -> Vector4<T>

Performs the % operation.

impl<T: Unit<Scalar = u32>> Rem<u32> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the % operator.

fn rem(self, rhs: u32) -> Vector4<T>

Performs the % operation.

impl<T: Unit<Scalar = u64>> Rem<u64> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the % operator.

fn rem(self, rhs: u64) -> Vector4<T>

Performs the % operation.

impl<T: Unit<Scalar = u64>> Rem<u64> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the % operator.

fn rem(self, rhs: u64) -> Vector4<T>

Performs the % operation.

impl<T: Unit> Rem for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the % operator.

fn rem(self, rhs: Vector4<T>) -> Vector4<T>

Performs the % operation.

impl<T: Unit> RemAssign<&Vector4<T>> for Point4<T>

fn rem_assign(&mut self, rhs: &Vector4<T>)

Performs the %= operation.

impl<T: Unit> RemAssign<&Vector4<T>> for Vector4<T>

fn rem_assign(&mut self, rhs: &Vector4<T>)

Performs the %= operation.

impl<T: Unit<Scalar = f32>> RemAssign<&f32> for Vector4<T>

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

Performs the %= operation.

impl<T: Unit<Scalar = f64>> RemAssign<&f64> for Vector4<T>

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

Performs the %= operation.

impl<T: Unit<Scalar = i16>> RemAssign<&i16> for Vector4<T>

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

Performs the %= operation.

impl<T: Unit<Scalar = i32>> RemAssign<&i32> for Vector4<T>

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

Performs the %= operation.

impl<T: Unit<Scalar = i64>> RemAssign<&i64> for Vector4<T>

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

Performs the %= operation.

impl<T: Unit<Scalar = u16>> RemAssign<&u16> for Vector4<T>

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

Performs the %= operation.

impl<T: Unit<Scalar = u32>> RemAssign<&u32> for Vector4<T>

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

Performs the %= operation.

impl<T: Unit<Scalar = u64>> RemAssign<&u64> for Vector4<T>

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

Performs the %= operation.

impl<T: Unit> RemAssign<Vector4<T>> for Point4<T>

fn rem_assign(&mut self, rhs: Vector4<T>)

Performs the %= operation.

impl<T: Unit<Scalar = f32>> RemAssign<f32> for Vector4<T>

fn rem_assign(&mut self, rhs: f32)

Performs the %= operation.

impl<T: Unit<Scalar = f64>> RemAssign<f64> for Vector4<T>

fn rem_assign(&mut self, rhs: f64)

Performs the %= operation.

impl<T: Unit<Scalar = i16>> RemAssign<i16> for Vector4<T>

fn rem_assign(&mut self, rhs: i16)

Performs the %= operation.

impl<T: Unit<Scalar = i32>> RemAssign<i32> for Vector4<T>

fn rem_assign(&mut self, rhs: i32)

Performs the %= operation.

impl<T: Unit<Scalar = i64>> RemAssign<i64> for Vector4<T>

fn rem_assign(&mut self, rhs: i64)

Performs the %= operation.

impl<T: Unit<Scalar = u16>> RemAssign<u16> for Vector4<T>

fn rem_assign(&mut self, rhs: u16)

Performs the %= operation.

impl<T: Unit<Scalar = u32>> RemAssign<u32> for Vector4<T>

fn rem_assign(&mut self, rhs: u32)

Performs the %= operation.

impl<T: Unit<Scalar = u64>> RemAssign<u64> for Vector4<T>

fn rem_assign(&mut self, rhs: u64)

Performs the %= operation.

impl<T: Unit> RemAssign for Vector4<T>

fn rem_assign(&mut self, rhs: Vector4<T>)

Performs the %= operation.

impl<T: Unit> Sub<&Vector4<T>> for &Point4<T>

type Output = Point4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &Vector4<T>) -> Point4<T>

Performs the - operation.

impl<T: Unit> Sub<&Vector4<T>> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &Vector4<T>) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = f32>> Sub<&Vector4<T>> for &f32

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &Vector4<T>) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = f64>> Sub<&Vector4<T>> for &f64

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &Vector4<T>) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = i16>> Sub<&Vector4<T>> for &i16

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &Vector4<T>) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = i32>> Sub<&Vector4<T>> for &i32

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &Vector4<T>) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = i64>> Sub<&Vector4<T>> for &i64

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &Vector4<T>) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = u16>> Sub<&Vector4<T>> for &u16

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &Vector4<T>) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = u32>> Sub<&Vector4<T>> for &u32

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &Vector4<T>) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = u64>> Sub<&Vector4<T>> for &u64

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &Vector4<T>) -> Vector4<T>

Performs the - operation.

impl<T: Unit> Sub<&Vector4<T>> for Point4<T>

type Output = Point4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &Vector4<T>) -> Point4<T>

Performs the - operation.

impl<T: Unit> Sub<&Vector4<T>> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &Vector4<T>) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = f32>> Sub<&Vector4<T>> for f32

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &Vector4<T>) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = f64>> Sub<&Vector4<T>> for f64

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &Vector4<T>) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = i16>> Sub<&Vector4<T>> for i16

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &Vector4<T>) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = i32>> Sub<&Vector4<T>> for i32

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &Vector4<T>) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = i64>> Sub<&Vector4<T>> for i64

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &Vector4<T>) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = u16>> Sub<&Vector4<T>> for u16

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &Vector4<T>) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = u32>> Sub<&Vector4<T>> for u32

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &Vector4<T>) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = u64>> Sub<&Vector4<T>> for u64

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &Vector4<T>) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = f32>> Sub<&f32> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &f32) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = f32>> Sub<&f32> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &f32) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = f64>> Sub<&f64> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &f64) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = f64>> Sub<&f64> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &f64) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = i16>> Sub<&i16> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &i16) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = i16>> Sub<&i16> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &i16) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = i32>> Sub<&i32> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &i32) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = i32>> Sub<&i32> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &i32) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = i64>> Sub<&i64> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &i64) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = i64>> Sub<&i64> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &i64) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = u16>> Sub<&u16> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &u16) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = u16>> Sub<&u16> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &u16) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = u32>> Sub<&u32> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &u32) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = u32>> Sub<&u32> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &u32) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = u64>> Sub<&u64> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &u64) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = u64>> Sub<&u64> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &u64) -> Vector4<T>

Performs the - operation.

impl<T: Unit> Sub<Vector4<T>> for &Point4<T>

type Output = Point4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: Vector4<T>) -> Point4<T>

Performs the - operation.

impl<T: Unit> Sub<Vector4<T>> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: Vector4<T>) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = f32>> Sub<Vector4<T>> for &f32

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: Vector4<T>) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = f64>> Sub<Vector4<T>> for &f64

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: Vector4<T>) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = i16>> Sub<Vector4<T>> for &i16

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: Vector4<T>) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = i32>> Sub<Vector4<T>> for &i32

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: Vector4<T>) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = i64>> Sub<Vector4<T>> for &i64

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: Vector4<T>) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = u16>> Sub<Vector4<T>> for &u16

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: Vector4<T>) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = u32>> Sub<Vector4<T>> for &u32

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: Vector4<T>) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = u64>> Sub<Vector4<T>> for &u64

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: Vector4<T>) -> Vector4<T>

Performs the - operation.

impl<T: Unit> Sub<Vector4<T>> for Point4<T>

type Output = Point4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: Vector4<T>) -> Point4<T>

Performs the - operation.

impl<T: Unit<Scalar = f32>> Sub<Vector4<T>> for f32

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: Vector4<T>) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = f64>> Sub<Vector4<T>> for f64

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: Vector4<T>) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = i16>> Sub<Vector4<T>> for i16

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: Vector4<T>) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = i32>> Sub<Vector4<T>> for i32

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: Vector4<T>) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = i64>> Sub<Vector4<T>> for i64

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: Vector4<T>) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = u16>> Sub<Vector4<T>> for u16

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: Vector4<T>) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = u32>> Sub<Vector4<T>> for u32

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: Vector4<T>) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = u64>> Sub<Vector4<T>> for u64

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: Vector4<T>) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = f32>> Sub<f32> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: f32) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = f32>> Sub<f32> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: f32) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = f64>> Sub<f64> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: f64) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = f64>> Sub<f64> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: f64) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = i16>> Sub<i16> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: i16) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = i16>> Sub<i16> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: i16) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = i32>> Sub<i32> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: i32) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = i32>> Sub<i32> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: i32) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = i64>> Sub<i64> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: i64) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = i64>> Sub<i64> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: i64) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = u16>> Sub<u16> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: u16) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = u16>> Sub<u16> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: u16) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = u32>> Sub<u32> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: u32) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = u32>> Sub<u32> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: u32) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = u64>> Sub<u64> for &Vector4<T>

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: u64) -> Vector4<T>

Performs the - operation.

impl<T: Unit<Scalar = u64>> Sub<u64> for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: u64) -> Vector4<T>

Performs the - operation.

impl<T: Unit> Sub for Vector4<T>

type Output = Vector4<T>

The resulting type after applying the - operator.

fn sub(self, rhs: Vector4<T>) -> Vector4<T>

Performs the - operation.

impl<T: Unit> SubAssign<&Vector4<T>> for Point4<T>

fn sub_assign(&mut self, rhs: &Vector4<T>)

Performs the -= operation.

impl<T: Unit> SubAssign<&Vector4<T>> for Vector4<T>

fn sub_assign(&mut self, rhs: &Vector4<T>)

Performs the -= operation.

impl<T: Unit<Scalar = f32>> SubAssign<&f32> for Vector4<T>

fn sub_assign(&mut self, rhs: &f32)

Performs the -= operation.

impl<T: Unit<Scalar = f64>> SubAssign<&f64> for Vector4<T>

fn sub_assign(&mut self, rhs: &f64)

Performs the -= operation.

impl<T: Unit<Scalar = i16>> SubAssign<&i16> for Vector4<T>

fn sub_assign(&mut self, rhs: &i16)

Performs the -= operation.

impl<T: Unit<Scalar = i32>> SubAssign<&i32> for Vector4<T>

fn sub_assign(&mut self, rhs: &i32)

Performs the -= operation.

impl<T: Unit<Scalar = i64>> SubAssign<&i64> for Vector4<T>

fn sub_assign(&mut self, rhs: &i64)

Performs the -= operation.

impl<T: Unit<Scalar = u16>> SubAssign<&u16> for Vector4<T>

fn sub_assign(&mut self, rhs: &u16)

Performs the -= operation.

impl<T: Unit<Scalar = u32>> SubAssign<&u32> for Vector4<T>

fn sub_assign(&mut self, rhs: &u32)

Performs the -= operation.

impl<T: Unit<Scalar = u64>> SubAssign<&u64> for Vector4<T>

fn sub_assign(&mut self, rhs: &u64)

Performs the -= operation.

impl<T: Unit> SubAssign<Vector4<T>> for Point4<T>

fn sub_assign(&mut self, rhs: Vector4<T>)

Performs the -= operation.

impl<T: Unit<Scalar = f32>> SubAssign<f32> for Vector4<T>

fn sub_assign(&mut self, rhs: f32)

Performs the -= operation.

impl<T: Unit<Scalar = f64>> SubAssign<f64> for Vector4<T>

fn sub_assign(&mut self, rhs: f64)

Performs the -= operation.

impl<T: Unit<Scalar = i16>> SubAssign<i16> for Vector4<T>

fn sub_assign(&mut self, rhs: i16)

Performs the -= operation.

impl<T: Unit<Scalar = i32>> SubAssign<i32> for Vector4<T>

fn sub_assign(&mut self, rhs: i32)

Performs the -= operation.

impl<T: Unit<Scalar = i64>> SubAssign<i64> for Vector4<T>

fn sub_assign(&mut self, rhs: i64)

Performs the -= operation.

impl<T: Unit<Scalar = u16>> SubAssign<u16> for Vector4<T>

fn sub_assign(&mut self, rhs: u16)

Performs the -= operation.

impl<T: Unit<Scalar = u32>> SubAssign<u32> for Vector4<T>

fn sub_assign(&mut self, rhs: u32)

Performs the -= operation.

impl<T: Unit<Scalar = u64>> SubAssign<u64> for Vector4<T>

fn sub_assign(&mut self, rhs: u64)

Performs the -= operation.

impl<T: Unit> SubAssign for Vector4<T>

fn sub_assign(&mut self, rhs: Vector4<T>)

Performs the -= operation.

impl<'a, T: Unit> Sum<&'a Vector4<T>> for Vector4<T>

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

where I: Iterator<Item = &'a Self>,

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

impl<T: Unit> Sum for Vector4<T>

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

where I: Iterator<Item = Self>,

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

impl<T: Unit> Swizzle<T> for Vector4<T>

fn swizzle2<const X: usize, const Y: usize>(&self) -> Vector2<T>

Select two components from this vector and return a 2D vector made from those components.

fn swizzle3<const X: usize, const Y: usize, const Z: usize>(&self) -> Vector3<T>

Select three components from this vector and return a 3D vector made from those components.

fn swizzle4<const X: usize, const Y: usize, const Z: usize, const W: usize>( &self, ) -> Vector4<T>

Select four components from this vector and return a 4D vector made from those components.

impl<T: Unit> Transparent for Vector4<T>

SAFETY: These are guaranteed to have the same representation.

type Wrapped = <<T as Unit>::Scalar as Scalar>::Vec4

The inner type that shares a compatible representation with Self.

fn wrap(x: Self::Wrapped) -> Self

Wrap the inner type by copy.

fn peel(x: Self) -> Self::Wrapped

Unwrap the inner type by copy.

fn peel_copy(x: &Self) -> Self::Wrapped

Convert a reference to the inner type.

impl<T: FloatUnit> UlpsEq for Vector4<T>

fn default_max_ulps() -> u32

The default ULPs to tolerate when testing values that are far-apart.

fn ulps_eq(&self, other: &Self, epsilon: Self::Epsilon, max_ulps: u32) -> bool

A test for equality that uses units in the last place (ULP) if the values are far apart.

fn ulps_ne(&self, other: &Self, epsilon: Self::Epsilon, max_ulps: u32) -> bool

The inverse of UlpsEq::ulps_eq.

impl<T: Unit> Vec4Swizzles for Vector4<T>

type Vec2 = Vector2<T>

type Vec3 = Vector3<T>

fn xx(self) -> Vector2<T>

fn xy(self) -> Vector2<T>

fn yy(self) -> Vector2<T>

fn yx(self) -> Vector2<T>

fn xxx(self) -> Vector3<T>

fn xxy(self) -> Vector3<T>

fn xyx(self) -> Vector3<T>

fn xyy(self) -> Vector3<T>

fn yxx(self) -> Vector3<T>

fn yxy(self) -> Vector3<T>

fn yyx(self) -> Vector3<T>

fn yyy(self) -> Vector3<T>

fn xxxx(self) -> Vector4<T>

fn xxxy(self) -> Vector4<T>

fn xxyx(self) -> Vector4<T>

fn xxyy(self) -> Vector4<T>

fn xyxx(self) -> Vector4<T>

fn xyxy(self) -> Vector4<T>

fn xyyx(self) -> Vector4<T>

fn xyyy(self) -> Vector4<T>

fn yxxx(self) -> Vector4<T>

fn yxxy(self) -> Vector4<T>

fn yxyx(self) -> Vector4<T>

fn yxyy(self) -> Vector4<T>

fn yyxx(self) -> Vector4<T>

fn yyxy(self) -> Vector4<T>

fn yyyx(self) -> Vector4<T>

fn yyyy(self) -> Vector4<T>

fn with_xy(self, rhs: Vector2<T>) -> Self

fn with_xz(self, rhs: Vector2<T>) -> Self

fn with_yx(self, rhs: Vector2<T>) -> Self

fn with_yz(self, rhs: Vector2<T>) -> Self

fn with_zx(self, rhs: Vector2<T>) -> Self

fn with_zy(self, rhs: Vector2<T>) -> Self

fn xz(self) -> Vector2<T>

fn yz(self) -> Vector2<T>

fn zx(self) -> Vector2<T>

fn zy(self) -> Vector2<T>

fn zz(self) -> Vector2<T>

fn xxz(self) -> Vector3<T>

fn xyz(self) -> Vector3<T>

fn xzx(self) -> Vector3<T>

fn xzy(self) -> Vector3<T>

fn xzz(self) -> Vector3<T>

fn yxz(self) -> Vector3<T>

fn yyz(self) -> Vector3<T>

fn yzx(self) -> Vector3<T>

fn yzy(self) -> Vector3<T>

fn yzz(self) -> Vector3<T>

fn zxx(self) -> Vector3<T>

fn zxy(self) -> Vector3<T>

fn zxz(self) -> Vector3<T>

fn zyx(self) -> Vector3<T>

fn zyy(self) -> Vector3<T>

fn zyz(self) -> Vector3<T>

fn zzx(self) -> Vector3<T>

fn zzy(self) -> Vector3<T>

fn zzz(self) -> Vector3<T>

fn xxxz(self) -> Vector4<T>

fn xxyz(self) -> Vector4<T>

fn xxzx(self) -> Vector4<T>

fn xxzy(self) -> Vector4<T>

fn xxzz(self) -> Vector4<T>

fn xyxz(self) -> Vector4<T>

fn xyyz(self) -> Vector4<T>

fn xyzx(self) -> Vector4<T>

fn xyzy(self) -> Vector4<T>

fn xyzz(self) -> Vector4<T>

fn xzxx(self) -> Vector4<T>

fn xzxy(self) -> Vector4<T>

fn xzxz(self) -> Vector4<T>

fn xzyx(self) -> Vector4<T>

fn xzyy(self) -> Vector4<T>

fn xzyz(self) -> Vector4<T>

fn xzzx(self) -> Vector4<T>

fn xzzy(self) -> Vector4<T>

fn xzzz(self) -> Vector4<T>

fn yxxz(self) -> Vector4<T>

fn yxyz(self) -> Vector4<T>

fn yxzx(self) -> Vector4<T>

fn yxzy(self) -> Vector4<T>

fn yxzz(self) -> Vector4<T>

fn yyxz(self) -> Vector4<T>

fn yyyz(self) -> Vector4<T>

fn yyzx(self) -> Vector4<T>

fn yyzy(self) -> Vector4<T>

fn yyzz(self) -> Vector4<T>

fn yzxx(self) -> Vector4<T>

fn yzxy(self) -> Vector4<T>

fn yzxz(self) -> Vector4<T>

fn yzyx(self) -> Vector4<T>

fn yzyy(self) -> Vector4<T>

fn yzyz(self) -> Vector4<T>

fn yzzx(self) -> Vector4<T>

fn yzzy(self) -> Vector4<T>

fn yzzz(self) -> Vector4<T>

fn zxxx(self) -> Vector4<T>

fn zxxy(self) -> Vector4<T>

fn zxxz(self) -> Vector4<T>

fn zxyx(self) -> Vector4<T>

fn zxyy(self) -> Vector4<T>

fn zxyz(self) -> Vector4<T>

fn zxzx(self) -> Vector4<T>

fn zxzy(self) -> Vector4<T>

fn zxzz(self) -> Vector4<T>

fn zyxx(self) -> Vector4<T>

fn zyxy(self) -> Vector4<T>

fn zyxz(self) -> Vector4<T>

fn zyyx(self) -> Vector4<T>

fn zyyy(self) -> Vector4<T>

fn zyyz(self) -> Vector4<T>

fn zyzx(self) -> Vector4<T>

fn zyzy(self) -> Vector4<T>

fn zyzz(self) -> Vector4<T>

fn zzxx(self) -> Vector4<T>

fn zzxy(self) -> Vector4<T>

fn zzxz(self) -> Vector4<T>

fn zzyx(self) -> Vector4<T>

fn zzyy(self) -> Vector4<T>

fn zzyz(self) -> Vector4<T>

fn zzzx(self) -> Vector4<T>

fn zzzy(self) -> Vector4<T>

fn zzzz(self) -> Vector4<T>

fn with_wx(self, rhs: Vector2<T>) -> Self

fn with_wy(self, rhs: Vector2<T>) -> Self

fn with_wz(self, rhs: Vector2<T>) -> Self

fn with_xw(self, rhs: Vector2<T>) -> Self

fn with_yw(self, rhs: Vector2<T>) -> Self

fn with_zw(self, rhs: Vector2<T>) -> Self

fn with_wxy(self, rhs: Vector3<T>) -> Self

fn with_wxz(self, rhs: Vector3<T>) -> Self

fn with_wyx(self, rhs: Vector3<T>) -> Self

fn with_wyz(self, rhs: Vector3<T>) -> Self

fn with_wzx(self, rhs: Vector3<T>) -> Self

fn with_wzy(self, rhs: Vector3<T>) -> Self

fn with_xwy(self, rhs: Vector3<T>) -> Self

fn with_xwz(self, rhs: Vector3<T>) -> Self

fn with_xyw(self, rhs: Vector3<T>) -> Self

fn with_xyz(self, rhs: Vector3<T>) -> Self

fn with_xzw(self, rhs: Vector3<T>) -> Self

fn with_xzy(self, rhs: Vector3<T>) -> Self

fn with_ywx(self, rhs: Vector3<T>) -> Self

fn with_yxw(self, rhs: Vector3<T>) -> Self

fn with_yzx(self, rhs: Vector3<T>) -> Self

fn with_yzw(self, rhs: Vector3<T>) -> Self

fn with_yxz(self, rhs: Vector3<T>) -> Self

fn with_ywz(self, rhs: Vector3<T>) -> Self

fn with_zwx(self, rhs: Vector3<T>) -> Self

fn with_zxw(self, rhs: Vector3<T>) -> Self

fn with_zxy(self, rhs: Vector3<T>) -> Self

fn with_zyx(self, rhs: Vector3<T>) -> Self

fn with_zwy(self, rhs: Vector3<T>) -> Self

fn with_zyw(self, rhs: Vector3<T>) -> Self

fn xw(self) -> Vector2<T>

fn yw(self) -> Vector2<T>

fn zw(self) -> Vector2<T>

fn wx(self) -> Vector2<T>

fn wy(self) -> Vector2<T>

fn wz(self) -> Vector2<T>

fn ww(self) -> Vector2<T>

fn xxw(self) -> Vector3<T>

fn xyw(self) -> Vector3<T>

fn xzw(self) -> Vector3<T>

fn xwx(self) -> Vector3<T>

fn xwy(self) -> Vector3<T>

fn xwz(self) -> Vector3<T>

fn xww(self) -> Vector3<T>

fn yxw(self) -> Vector3<T>

fn yyw(self) -> Vector3<T>

fn yzw(self) -> Vector3<T>

fn ywx(self) -> Vector3<T>

fn ywy(self) -> Vector3<T>

fn ywz(self) -> Vector3<T>

fn yww(self) -> Vector3<T>

fn zxw(self) -> Vector3<T>

fn zyw(self) -> Vector3<T>

fn zzw(self) -> Vector3<T>

fn zwx(self) -> Vector3<T>

fn zwy(self) -> Vector3<T>

fn zwz(self) -> Vector3<T>

fn zww(self) -> Vector3<T>

fn wxx(self) -> Vector3<T>

fn wxy(self) -> Vector3<T>

fn wxz(self) -> Vector3<T>

fn wxw(self) -> Vector3<T>

fn wyx(self) -> Vector3<T>

fn wyy(self) -> Vector3<T>

fn wyz(self) -> Vector3<T>

fn wyw(self) -> Vector3<T>

fn wzx(self) -> Vector3<T>

fn wzy(self) -> Vector3<T>

fn wzz(self) -> Vector3<T>

fn wzw(self) -> Vector3<T>

fn wwx(self) -> Vector3<T>

fn wwy(self) -> Vector3<T>

fn wwz(self) -> Vector3<T>

fn www(self) -> Vector3<T>

fn xxxw(self) -> Vector4<T>

fn xxyw(self) -> Vector4<T>

fn xxzw(self) -> Vector4<T>

fn xxwx(self) -> Vector4<T>

fn xxwy(self) -> Vector4<T>

fn xxwz(self) -> Vector4<T>

fn xxww(self) -> Vector4<T>

fn xyxw(self) -> Vector4<T>

fn xyyw(self) -> Vector4<T>

fn xyzw(self) -> Vector4<T>

fn xywx(self) -> Vector4<T>

fn xywy(self) -> Vector4<T>

fn xywz(self) -> Vector4<T>

fn xyww(self) -> Vector4<T>

fn xzxw(self) -> Vector4<T>

fn xzyw(self) -> Vector4<T>

fn xzzw(self) -> Vector4<T>

fn xzwx(self) -> Vector4<T>

fn xzwy(self) -> Vector4<T>

fn xzwz(self) -> Vector4<T>

fn xzww(self) -> Vector4<T>

fn xwxx(self) -> Vector4<T>

fn xwxy(self) -> Vector4<T>

fn xwxz(self) -> Vector4<T>

fn xwxw(self) -> Vector4<T>

fn xwyx(self) -> Vector4<T>

fn xwyy(self) -> Vector4<T>

fn xwyz(self) -> Vector4<T>

fn xwyw(self) -> Vector4<T>

fn xwzx(self) -> Vector4<T>

fn xwzy(self) -> Vector4<T>

fn xwzz(self) -> Vector4<T>

fn xwzw(self) -> Vector4<T>

fn xwwx(self) -> Vector4<T>

fn xwwy(self) -> Vector4<T>

fn xwwz(self) -> Vector4<T>

fn xwww(self) -> Vector4<T>

fn yxxw(self) -> Vector4<T>

fn yxyw(self) -> Vector4<T>

fn yxzw(self) -> Vector4<T>

fn yxwx(self) -> Vector4<T>

fn yxwy(self) -> Vector4<T>

fn yxwz(self) -> Vector4<T>

fn yxww(self) -> Vector4<T>

fn yyxw(self) -> Vector4<T>

fn yyyw(self) -> Vector4<T>

fn yyzw(self) -> Vector4<T>

fn yywx(self) -> Vector4<T>

fn yywy(self) -> Vector4<T>

fn yywz(self) -> Vector4<T>

fn yyww(self) -> Vector4<T>

fn yzxw(self) -> Vector4<T>

fn yzyw(self) -> Vector4<T>

fn yzzw(self) -> Vector4<T>

fn yzwx(self) -> Vector4<T>

fn yzwy(self) -> Vector4<T>

fn yzwz(self) -> Vector4<T>

fn yzww(self) -> Vector4<T>

fn ywxx(self) -> Vector4<T>

fn ywxy(self) -> Vector4<T>

fn ywxz(self) -> Vector4<T>

fn ywxw(self) -> Vector4<T>

fn ywyx(self) -> Vector4<T>

fn ywyy(self) -> Vector4<T>

fn ywyz(self) -> Vector4<T>

fn ywyw(self) -> Vector4<T>

fn ywzx(self) -> Vector4<T>

fn ywzy(self) -> Vector4<T>

fn ywzz(self) -> Vector4<T>

fn ywzw(self) -> Vector4<T>

fn ywwx(self) -> Vector4<T>

fn ywwy(self) -> Vector4<T>

fn ywwz(self) -> Vector4<T>

fn ywww(self) -> Vector4<T>

fn zxxw(self) -> Vector4<T>

fn zxyw(self) -> Vector4<T>

fn zxzw(self) -> Vector4<T>

fn zxwx(self) -> Vector4<T>

fn zxwy(self) -> Vector4<T>

fn zxwz(self) -> Vector4<T>

fn zxww(self) -> Vector4<T>

fn zyxw(self) -> Vector4<T>

fn zyyw(self) -> Vector4<T>

fn zyzw(self) -> Vector4<T>

fn zywx(self) -> Vector4<T>

fn zywy(self) -> Vector4<T>

fn zywz(self) -> Vector4<T>

fn zyww(self) -> Vector4<T>

fn zzxw(self) -> Vector4<T>

fn zzyw(self) -> Vector4<T>

fn zzzw(self) -> Vector4<T>

fn zzwx(self) -> Vector4<T>

fn zzwy(self) -> Vector4<T>

fn zzwz(self) -> Vector4<T>

fn zzww(self) -> Vector4<T>

fn zwxx(self) -> Vector4<T>

fn zwxy(self) -> Vector4<T>

fn zwxz(self) -> Vector4<T>

fn zwxw(self) -> Vector4<T>

fn zwyx(self) -> Vector4<T>

fn zwyy(self) -> Vector4<T>

fn zwyz(self) -> Vector4<T>

fn zwyw(self) -> Vector4<T>

fn zwzx(self) -> Vector4<T>

fn zwzy(self) -> Vector4<T>

fn zwzz(self) -> Vector4<T>

fn zwzw(self) -> Vector4<T>

fn zwwx(self) -> Vector4<T>

fn zwwy(self) -> Vector4<T>

fn zwwz(self) -> Vector4<T>

fn zwww(self) -> Vector4<T>

fn wxxx(self) -> Vector4<T>

fn wxxy(self) -> Vector4<T>

fn wxxz(self) -> Vector4<T>

fn wxxw(self) -> Vector4<T>

fn wxyx(self) -> Vector4<T>

fn wxyy(self) -> Vector4<T>

fn wxyz(self) -> Vector4<T>

fn wxyw(self) -> Vector4<T>

fn wxzx(self) -> Vector4<T>

fn wxzy(self) -> Vector4<T>

fn wxzz(self) -> Vector4<T>

fn wxzw(self) -> Vector4<T>

fn wxwx(self) -> Vector4<T>

fn wxwy(self) -> Vector4<T>

fn wxwz(self) -> Vector4<T>

fn wxww(self) -> Vector4<T>

fn wyxx(self) -> Vector4<T>

fn wyxy(self) -> Vector4<T>

fn wyxz(self) -> Vector4<T>

fn wyxw(self) -> Vector4<T>

fn wyyx(self) -> Vector4<T>

fn wyyy(self) -> Vector4<T>

fn wyyz(self) -> Vector4<T>

fn wyyw(self) -> Vector4<T>

fn wyzx(self) -> Vector4<T>

fn wyzy(self) -> Vector4<T>

fn wyzz(self) -> Vector4<T>

fn wyzw(self) -> Vector4<T>

fn wywx(self) -> Vector4<T>

fn wywy(self) -> Vector4<T>

fn wywz(self) -> Vector4<T>

fn wyww(self) -> Vector4<T>

fn wzxx(self) -> Vector4<T>

fn wzxy(self) -> Vector4<T>

fn wzxz(self) -> Vector4<T>

fn wzxw(self) -> Vector4<T>

fn wzyx(self) -> Vector4<T>

fn wzyy(self) -> Vector4<T>

fn wzyz(self) -> Vector4<T>

fn wzyw(self) -> Vector4<T>

fn wzzx(self) -> Vector4<T>

fn wzzy(self) -> Vector4<T>

fn wzzz(self) -> Vector4<T>

fn wzzw(self) -> Vector4<T>

fn wzwx(self) -> Vector4<T>

fn wzwy(self) -> Vector4<T>

fn wzwz(self) -> Vector4<T>

fn wzww(self) -> Vector4<T>

fn wwxx(self) -> Vector4<T>

fn wwxy(self) -> Vector4<T>

fn wwxz(self) -> Vector4<T>

fn wwxw(self) -> Vector4<T>

fn wwyx(self) -> Vector4<T>

fn wwyy(self) -> Vector4<T>

fn wwyz(self) -> Vector4<T>

fn wwyw(self) -> Vector4<T>

fn wwzx(self) -> Vector4<T>

fn wwzy(self) -> Vector4<T>

fn wwzz(self) -> Vector4<T>

fn wwzw(self) -> Vector4<T>

fn wwwx(self) -> Vector4<T>

fn wwwy(self) -> Vector4<T>

fn wwwz(self) -> Vector4<T>

fn wwww(self) -> Vector4<T>

impl<T: Unit> Zeroable for Vector4<T>

SAFETY: T::Scalar is Zeroable, and Vector4 is #[repr(C)].

fn zeroed() -> Self

Calls zeroed.

impl<T: Unit> Copy for Vector4<T>

impl<T: Unit<Scalar: Eq>> Eq for Vector4<T>

impl<T: Unit> Pod for Vector4<T>

SAFETY: T::Scalar is Pod.