Struct pix_engine::vector::Vector

#[repr(transparent)]
pub struct Vector<T = f64, const N: usize = 2_usize>(_);

A Euclidean Vector in N-dimensional space.

Also known as a geometric vector. A Vector has both a magnitude and a direction. The Vector struct, however, contains N values for each dimensional coordinate.

The magnitude and direction are retrieved with the mag and heading methods.

Some example uses of a Vector include modeling a position, velocity, or acceleration of an object or particle.

Vectors can be combined using vector math, so for example two Vectors can be added together to form a new Vector using let v3 = v1 + v2 or you can add one Vector to another by calling v1 += v2.

Please see the module-level documentation for examples.

Implementations

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

pub fn as_<U>(&self) -> Vector<U, N> where
    U: 'static + Copy,
    T: AsPrimitive<U>, 

Converts Vector < T, N > to Vector < U, N >.

impl<T: Float, const N: usize> Vector<T, N>

pub fn round(&self) -> Self

Returns Vector < T, N > with the nearest integers to the numbers. Round half-way cases away from 0.0.

pub fn floor(&self) -> Self

Returns Vector < T, N > with the largest integers less than or equal to the numbers.

pub fn ceil(&self) -> Self

Returns Vector < T, N > with the smallest integers greater than or equal to the numbers.

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

pub const fn new(coords: [T; N]) -> Self

Constructs a Vector from [T; N] coordinates.

Examples

let v = Vector::new([2.1]);
assert_eq!(v.coords(), [2.1]);

let v = Vector::new([2.1, 3.5]);
assert_eq!(v.coords(), [2.1, 3.5]);

let v = Vector::new([2.1, 3.5, 1.0]);
assert_eq!(v.coords(), [2.1, 3.5, 1.0]);

pub fn origin() -> Self where
    T: Default, 

Constructs a Vector at the origin.

Example

let v: Vector<f64, 3> = Vector::origin();
assert_eq!(v.coords(), [0.0, 0.0, 0.0]);

impl<T> Vector<T, 1>

pub const fn from_x(x: T) -> Self

Constructs a Vector from an individual x coordinate.

impl<T> Vector<T>

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

Constructs a Vector from individual x/y coordinates.

impl<T> Vector<T, 3>

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

Constructs a Vector from individual x/y/z coordinates.

impl<T: Num + Float> Vector<T>

pub fn rotated<V>(v: V, angle: T) -> Self where
    V: Into<Vector<T>>, 

Constructs a Vector from another Vector, rotated by an angle.

Example

use pix_engine::math::FRAC_PI_2;
let v1 = Vector::new([10.0, 20.0]);
let v2 = Vector::rotated(v1, FRAC_PI_2);
assert!(v2.approx_eq(vector![-20.0, 10.0], 1e-4));

pub fn from_angle(angle: T, length: T) -> Self

Constructs a 2D unit Vector in the XY plane from a given angle. Angle is given as radians and is unaffected by AngleMode.

Example

use pix_engine::math::FRAC_PI_4;
let v = Vector::from_angle(FRAC_PI_4, 15.0);
assert!(v.approx_eq(vector!(10.6066, 10.6066), 1e-4));

pub fn heading(&self) -> T

Returns the 2D angular direction of the Vector.

Example

let v = vector!(10.0, 10.0);
let heading: f64 = v.heading();
assert_eq!(heading.to_degrees(), 45.0);

pub fn rotate(&mut self, angle: T)

Rotate a 2D Vector by an angle in radians, magnitude remains the same. Unaffected by AngleMode.

Example

use pix_engine::math::FRAC_PI_2;
let mut v = vector!(10.0, 20.0);
v.rotate(FRAC_PI_2);
assert!(v.approx_eq(vector![-20.0, 10.0], 1e-4));

impl<T: Num + Float> Vector<T, 3>

pub fn cross<V>(&self, v: V) -> Self where
    V: Into<Vector<T, 3>>, 

Returns the cross product between two Vectors. Only defined for 3D Vectors.

Example

let v1 = vector!(1.0, 2.0, 3.0);
let v2 = vector!(1.0, 2.0, 3.0);
let cross = v1.cross(v2);
assert_eq!(cross.coords(), [0.0, 0.0, 0.0]);

pub fn angle_between<V>(&self, v: V) -> T where
    V: Into<Vector<T, 3>>, 

Returns the angle between two 3D Vectors in radians.

Example

let v1 = vector!(1.0, 0.0, 0.0);
let v2 = vector!(0.0, 1.0, 0.0);
let angle = v1.angle_between(v2);
assert_eq!(angle, std::f64::consts::FRAC_PI_2);

impl<T: Copy, const N: usize> Vector<T, N>

pub fn from_point(p: Point<T, N>) -> Self

Constructs a Vector from a Point.

Example

let p = point!(1.0, 2.0);
let v = Vector::from_point(p);
assert_eq!(v.coords(), [1.0, 2.0]);

pub fn x(&self) -> T

Returns the x-coordinate.

Panics

If Vector has zero dimensions.

Example

let v = vector!(1.0, 2.0);
assert_eq!(v.x(), 1.0);

pub fn set_x(&mut self, x: T)

Sets the x-magnitude.

Panics

If Vector has zero dimensions.

Example

let mut v = vector!(1.0, 2.0);
v.set_x(3.0);
assert_eq!(v.coords(), [3.0, 2.0]);

pub fn y(&self) -> T

Returns the y-magnitude.

Panics

If Vector has less than 2 dimensions.

Example

let v = vector!(1.0, 2.0);
assert_eq!(v.y(), 2.0);

pub fn set_y(&mut self, y: T)

Sets the y-magnitude.

Panics

If Vector has less than 2 dimensions.

Example

let mut v = vector!(1.0, 2.0);
v.set_y(3.0);
assert_eq!(v.coords(), [1.0, 3.0]);

pub fn z(&self) -> T

Returns the z-magnitude.

Panics

If Vector has less than 3 dimensions.

Example

let v = vector!(1.0, 2.0, 2.5);
assert_eq!(v.z(), 2.5);

pub fn set_z(&mut self, z: T)

Sets the z-magnitude.

Panics

If Vector has less than 3 dimensions.

Example

let mut v = vector!(1.0, 2.0, 1.0);
v.set_z(3.0);
assert_eq!(v.coords(), [1.0, 2.0, 3.0]);

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

Get Vector coordinates as [T; N].

Example

let v = vector!(2.0, 1.0, 3.0);
assert_eq!(v.coords(), [2.0, 1.0, 3.0]);

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

Get Vector coordinates as a mutable slice &[T; N].

Example

let mut vector = vector!(2.0, 1.0, 3.0);
for v in vector.coords_mut() {
    *v *= 2.0;
}
assert_eq!(vector.coords(), [4.0, 2.0, 6.0]);

pub fn to_vec(self) -> Vec<T>

Returns Vector as a Vec.

Example

let v = vector!(1.0, 1.0, 0.0);
assert_eq!(v.to_vec(), vec![1.0, 1.0, 0.0]);

impl<T: Num, const N: usize> Vector<T, N>

pub fn offset<V, const M: usize>(&mut self, offsets: V) where
    V: Into<Vector<T, M>>, 

Constructs a Vector by shifting coordinates by given amount.

Examples

let mut v = vector!(2.0, 3.0, 1.5);
v.offset([2.0, -4.0]);
assert_eq!(v.coords(), [4.0, -1.0, 1.5]);

pub fn offset_x(&mut self, offset: T)

Offsets the x-coordinate of the point by a given amount.

Panics

If Point has zero dimensions.

pub fn offset_y(&mut self, offset: T)

Offsets the y-coordinate of the point by a given amount.

Panics

If Vector has less than 2 dimensions.

pub fn offset_z(&mut self, offset: T)

Offsets the z-coordinate of the point by a given amount.

Panics

If Vector has less than 3 dimensions.

pub fn scale<U>(&mut self, s: U) where
    T: MulAssign<U>,
    U: Num, 

Constructs a Vector by multiplying it by the given scale factor.

Examples

let mut v = vector!(2.0, 3.0, 1.5);
v.scale(2.0);
assert_eq!(v.coords(), [4.0, 6.0, 3.0]);

pub fn wrap(&mut self, wrap: [T; N], size: T) where
    T: Signed, 

Wraps Vector around the given [T; N], and size (radius).

Examples

let mut v = vector!(200.0, 300.0);
v.wrap([150.0, 400.0], 10.0);
assert_eq!(v.coords(), [-10.0, 300.0]);

let mut v = vector!(-100.0, 300.0);
v.wrap([150.0, 400.0], 10.0);
assert_eq!(v.coords(), [160.0, 300.0]);

pub fn random() -> Self where
    T: SampleUniform, 

Constructs a random unit Vector in 1D space.

Example

let v: Vector<f64, 3> = Vector::random();
assert!(v.x() > -1.0 && v.x() < 1.0);
assert!(v.y() > -1.0 && v.y() < 1.0);
assert!(v.z() > -1.0 && v.z() < 1.0);

// May make v's (x, y, z) values something like:
// (0.61554617, 0.0, 0.0) or
// (-0.4695841, 0.0, 0.0) or
// (0.6091097, 0.0, 0.0)

impl<T: Num + Float, const N: usize> Vector<T, N>

pub fn reflection<V>(v: V, normal: V) -> Self where
    V: Into<Vector<T, N>>, 

Constructs a Vector from a reflection about a normal to a line in 2D space or a plane in 3D space.

Example

let v1 = Vector::new([1.0, 1.0, 0.0]);
let normal = Vector::new([0.0, 1.0, 0.0]);
let v2 = Vector::reflection(v1, normal);
assert_eq!(v2.coords(), [-1.0, 1.0, 0.0]);

pub fn normalized<V>(v: V) -> Self where
    V: Into<Vector<T, N>>, 

Constructs a unit Vector of length 1 from another Vector.

Example

let v1 = Vector::new([0.0, 5.0, 0.0]);
let v2 = Vector::normalized(v1);
assert_eq!(v2.coords(), [0.0, 1.0, 0.0]);

pub fn mag(&self) -> T

Returns the magnitude (length) of the Vector.

The formula used for 2D is sqrt(x*x + y*y). The formula used for 3D is sqrt(x*x + y*y + z*z).

Example

let v = vector!(1.0, 2.0, 3.0);
let abs_difference = (v.mag() as f64 - 3.7416).abs();
assert!(abs_difference <= 1e-4);

pub fn mag_sq(&self) -> T

Returns the squared magnitude (length) of the Vector. This is faster if the real length is not required in the case of comparing vectors.

The formula used for 2D is x*x + y*y. The formula used for 3D is x*x + y*y + z*z.

Example

let v = vector!(1.0, 2.0, 3.0);
assert_eq!(v.mag_sq(), 14.0);

pub fn dot<V>(&self, o: V) -> T where
    V: Into<Vector<T, N>>, 

Returns the dot product betwen two Vectors.

Example

let v1 = vector!(1.0, 2.0, 3.0);
let v2 = vector!(2.0, 3.0, 4.0);
let dot_product = v1.dot(v2);
assert_eq!(dot_product, 20.0);

pub fn reflect<V>(&mut self, normal: V) where
    V: Into<Vector<T, N>>, 

Reflect Vector about a normal to a line in 2D space or a plane in 3D space.

Example

let mut v = vector!(4.0, 6.0); // Vector heading right and down
let n = vector!(0.0, 1.0); // Surface normal facing up
v.reflect(n); // Reflect about the surface normal (e.g. the x-axis)
assert_eq!(v.x(), -4.0);
assert_eq!(v.y(), 6.0);

pub fn set_mag(&mut self, mag: T)

Set the magnitude (length) of the Vector.

Examples

let mut v = vector!(10.0, 20.0, 2.0);
v.set_mag(10.0);
assert!(v.approx_eq(vector![4.4543, 8.9087, 0.8908], 1e-4));

pub fn dist<V>(&self, v: V) -> T where
    V: Into<Vector<T, N>>, 

Returns the Euclidean distance between two Vectors.

Example

let v1 = vector!(1.0, 0.0, 0.0);
let v2 = vector!(0.0, 1.0, 0.0);
let dist = v1.dist(v2);
let abs_difference: f64 = (dist - std::f64::consts::SQRT_2).abs();
assert!(abs_difference <= 1e-4);

pub fn normalize(&mut self)

Normalize the Vector to length 1 making it a unit vector.

Example

let mut v = vector!(10.0, 20.0, 2.0);
v.normalize();
assert!(v.approx_eq(vector!(0.4454, 0.8908, 0.0890), 1e-4));

pub fn limit(&mut self, max: T)

Clamp the magnitude (length) of Vector to the value given by max.

Example

let mut v = vector!(10.0, 20.0, 2.0);
v.limit(5.0);
assert!(v.approx_eq(vector!(2.2271, 4.4543,  0.4454), 1e-4));

pub fn lerp<V>(&self, o: V, amt: T) -> Self where
    V: Into<Vector<T, N>>, 

Constructs a Vector by linear interpolating between two Vectors by a given amount between 0.0 and 1.0.

Example

let v1 = vector!(1.0, 1.0, 0.0);
let v2 = vector!(3.0, 3.0, 0.0);
let v3 = v1.lerp(v2, 0.5);
assert_eq!(v3.coords(), [2.0, 2.0, 0.0]);

pub fn approx_eq<V>(&self, other: V, epsilon: T) -> bool where
    V: Into<Vector<T, N>>, 

Returns whether two Vectors are approximately equal.

Example

let v1 = vector!(10.0, 20.0, 2.0);
let v2 = vector!(10.0001, 20.0, 2.0);
assert!(v1.approx_eq(v2, 1e-3));

Methods from Deref<Target = [T; N]>

pub fn as_slice(&self) -> &[T]

Returns a slice containing the entire array. Equivalent to &s[..].

pub fn as_mut_slice(&mut self) -> &mut [T]

Returns a mutable slice containing the entire array. Equivalent to &mut s[..].

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

🔬 This is a nightly-only experimental API. (array_methods)

Borrows each element and returns an array of references with the same size as self.

Example

#![feature(array_methods)]

let floats = [3.1, 2.7, -1.0];
let float_refs: [&f64; 3] = floats.each_ref();
assert_eq!(float_refs, [&3.1, &2.7, &-1.0]);

This method is particularly useful if combined with other methods, like map. This way, you can avoid moving the original array if its elements are not Copy.

#![feature(array_methods)]

let strings = ["Ferris".to_string(), "♥".to_string(), "Rust".to_string()];
let is_ascii = strings.each_ref().map(|s| s.is_ascii());
assert_eq!(is_ascii, [true, false, true]);

// We can still access the original array: it has not been moved.
assert_eq!(strings.len(), 3);

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

🔬 This is a nightly-only experimental API. (array_methods)

Borrows each element mutably and returns an array of mutable references with the same size as self.

Example

#![feature(array_methods)]

let mut floats = [3.1, 2.7, -1.0];
let float_refs: [&mut f64; 3] = floats.each_mut();
*float_refs[0] = 0.0;
assert_eq!(float_refs, [&mut 0.0, &mut 2.7, &mut -1.0]);
assert_eq!(floats, [0.0, 2.7, -1.0]);

pub fn split_array_ref<const M: usize>(&self) -> (&[T; M], &[T])

🔬 This is a nightly-only experimental API. (split_array)

Divides one array reference into two at an index.

The first will contain all indices from [0, M) (excluding the index M itself) and the second will contain all indices from [M, N) (excluding the index N itself).

Panics

Panics if M > N.

Examples

#![feature(split_array)]

let v = [1, 2, 3, 4, 5, 6];

{
   let (left, right) = v.split_array_ref::<0>();
   assert_eq!(left, &[]);
   assert_eq!(right, &[1, 2, 3, 4, 5, 6]);
}

{
    let (left, right) = v.split_array_ref::<2>();
    assert_eq!(left, &[1, 2]);
    assert_eq!(right, &[3, 4, 5, 6]);
}

{
    let (left, right) = v.split_array_ref::<6>();
    assert_eq!(left, &[1, 2, 3, 4, 5, 6]);
    assert_eq!(right, &[]);
}

pub fn split_array_mut<const M: usize>(&mut self) -> (&mut [T; M], &mut [T])

🔬 This is a nightly-only experimental API. (split_array)

Divides one mutable array reference into two at an index.

The first will contain all indices from [0, M) (excluding the index M itself) and the second will contain all indices from [M, N) (excluding the index N itself).

Panics

Panics if M > N.

Examples

#![feature(split_array)]

let mut v = [1, 0, 3, 0, 5, 6];
let (left, right) = v.split_array_mut::<2>();
assert_eq!(left, &mut [1, 0][..]);
assert_eq!(right, &mut [3, 0, 5, 6]);
left[1] = 2;
right[1] = 4;
assert_eq!(v, [1, 2, 3, 4, 5, 6]);

pub fn rsplit_array_ref<const M: usize>(&self) -> (&[T], &[T; M])

🔬 This is a nightly-only experimental API. (split_array)

Divides one array reference into two at an index from the end.

The first will contain all indices from [0, N - M) (excluding the index N - M itself) and the second will contain all indices from [N - M, N) (excluding the index N itself).

Panics

Panics if M > N.

Examples

#![feature(split_array)]

let v = [1, 2, 3, 4, 5, 6];

{
   let (left, right) = v.rsplit_array_ref::<0>();
   assert_eq!(left, &[1, 2, 3, 4, 5, 6]);
   assert_eq!(right, &[]);
}

{
    let (left, right) = v.rsplit_array_ref::<2>();
    assert_eq!(left, &[1, 2, 3, 4]);
    assert_eq!(right, &[5, 6]);
}

{
    let (left, right) = v.rsplit_array_ref::<6>();
    assert_eq!(left, &[]);
    assert_eq!(right, &[1, 2, 3, 4, 5, 6]);
}

pub fn rsplit_array_mut<const M: usize>(&mut self) -> (&mut [T], &mut [T; M])

🔬 This is a nightly-only experimental API. (split_array)

Divides one mutable array reference into two at an index from the end.

The first will contain all indices from [0, N - M) (excluding the index N - M itself) and the second will contain all indices from [N - M, N) (excluding the index N itself).

Panics

Panics if M > N.

Examples

#![feature(split_array)]

let mut v = [1, 0, 3, 0, 5, 6];
let (left, right) = v.rsplit_array_mut::<4>();
assert_eq!(left, &mut [1, 0]);
assert_eq!(right, &mut [3, 0, 5, 6][..]);
left[1] = 2;
right[1] = 4;
assert_eq!(v, [1, 2, 3, 4, 5, 6]);

Trait Implementations

impl<T, const N: usize> Add<Point<T, N>> for Vector<T, N> where
    T: Num + Add, 

type Output = Point<T, N>

The resulting type after applying the + operator.

fn add(self, other: Point<T, N>) -> Self::Output

Performs the + operation.

impl<T, U, const N: usize> Add<U> for Vector<T, N> where
    T: Num + Add<U, Output = T>,
    U: Num, 

type Output = Vector<T, N>

The resulting type after applying the + operator.

fn add(self, val: U) -> Self::Output

Performs the + operation.

impl<T, const N: usize> Add<Vector<T, N>> for Point<T, N> where
    T: Num + Add, 

type Output = Point<T, N>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, const N: usize> Add<Vector<T, N>> for Vector<T, N> where
    T: Num + Add, 

type Output = Vector<T, N>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<T, U, const N: usize> AddAssign<U> for Vector<T, N> where
    T: Num + AddAssign<U>,
    U: Num, 

fn add_assign(&mut self, val: U)

Performs the += operation.

impl<T: Num, const N: usize> AddAssign<Vector<T, N>> for Point<T, N>

fn add_assign(&mut self, other: Vector<T, N>)

Performs the += operation.

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

fn add_assign(&mut self, other: Vector<T, N>)

Performs the += operation.

impl<T, const N: usize> AsMut<[T; N]> for Vector<T, N>

fn as_mut(&mut self) -> &mut [T; N]

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

impl<T, const N: usize> AsRef<[T; N]> for Vector<T, N>

fn as_ref(&self) -> &[T; N]

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

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

fn clone(&self) -> Vector<T, N>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug, const N: usize> Debug for Vector<T, N>

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

Formats the value using the given formatter.

impl<T: Default, const N: usize> Default for Vector<T, N>

fn default() -> Self

Return default Vector as origin.

impl<T, const N: usize> Deref for Vector<T, N>

type Target = [T; N]

The resulting type after dereferencing.

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

Dereferences the value.

impl<T, const N: usize> DerefMut for Vector<T, N>

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

Mutably dereferences the value.

impl<'de, T, const N: usize> Deserialize<'de> for Vector<T, N> where
    T: Serialize + DeserializeOwned, 

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<T, const N: usize> Display for Vector<T, N> where
    [T; N]: Debug, 

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

Display Vector as a string of coordinates.

impl<T, U, const N: usize> Div<U> for Vector<T, N> where
    T: Num + Div<U, Output = T>,
    U: Num, 

type Output = Vector<T, N>

The resulting type after applying the / operator.

fn div(self, val: U) -> Self::Output

Performs the / operation.

impl<T, U, const N: usize> DivAssign<U> for Vector<T, N> where
    T: Num + DivAssign<U>,
    U: Num, 

fn div_assign(&mut self, val: U)

Performs the /= operation.

impl<T: Copy, const N: usize> From<&'_ [T; N]> for Vector<T, N>

fn from(arr: &[T; N]) -> Self

Converts &[T; M] to Vector < T, N >.

impl<T: Copy, const N: usize> From<&'_ Point<T, N>> for Vector<T, N>

fn from(p: &Point<T, N>) -> Self

Converts to this type from the input type.

impl<T: Copy, const N: usize> From<&'_ Vector<T, N>> for [T; N]

fn from(t: &Vector<T, N>) -> Self

Converts Vector < T, N > to &[T; M].

impl<T: Copy, const N: usize> From<&'_ Vector<T, N>> for Point<T, N>

fn from(v: &Vector<T, N>) -> Self

Converts to this type from the input type.

impl<T, const N: usize> From<[T; N]> for Vector<T, N>

fn from(arr: [T; N]) -> Self

Converts [T; M] to Vector < T, N >.

impl<T: Copy, const N: usize> From<Point<T, N>> for Vector<T, N>

fn from(p: Point<T, N>) -> Self

Converts to this type from the input type.

impl<T, const N: usize> From<Vector<T, N>> for [T; N]

fn from(t: Vector<T, N>) -> Self

Converts Vector < T, N > to [T; M].

impl<T: Copy, const N: usize> From<Vector<T, N>> for Point<T, N>

fn from(v: Vector<T, N>) -> Self

Converts to this type from the input type.

impl<T: Default, const N: usize> FromIterator<T> for Vector<T, N>

fn from_iter<I>(iter: I) -> Self where
    I: IntoIterator<Item = T>, 

Creates a value from an iterator.

impl<T: Hash, const N: usize> Hash for Vector<T, N>

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

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl<T, const N: usize> Index<usize> for Vector<T, N>

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T, const N: usize> IndexMut<usize> for Vector<T, N>

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

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

impl<T, const N: usize> IntoIterator for Vector<T, N>

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<<Vector<T, N> as IntoIterator>::Item, N>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T, const N: usize> IntoIterator for &'a Vector<T, N>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T, const N: usize> IntoIterator for &'a mut Vector<T, N>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = IterMut<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T, U, const N: usize> Mul<U> for Vector<T, N> where
    T: Num + Mul<U, Output = T>,
    U: Num, 

type Output = Vector<T, N>

The resulting type after applying the * operator.

fn mul(self, val: U) -> Self::Output

Performs the * operation.

impl<const N: usize> Mul<Vector<f32, N>> for f32

fn mul(self, t: Vector<f32, N>) -> Self::Output

T * Point.

type Output = Vector<f32, N>

The resulting type after applying the * operator.

impl<const N: usize> Mul<Vector<f64, N>> for f64

fn mul(self, t: Vector<f64, N>) -> Self::Output

T * Point.

type Output = Vector<f64, N>

The resulting type after applying the * operator.

impl<const N: usize> Mul<Vector<i128, N>> for i128

fn mul(self, t: Vector<i128, N>) -> Self::Output

T * Point.

type Output = Vector<i128, N>

The resulting type after applying the * operator.

impl<const N: usize> Mul<Vector<i16, N>> for i16

fn mul(self, t: Vector<i16, N>) -> Self::Output

T * Point.

type Output = Vector<i16, N>

The resulting type after applying the * operator.

impl<const N: usize> Mul<Vector<i32, N>> for i32

fn mul(self, t: Vector<i32, N>) -> Self::Output

T * Point.

type Output = Vector<i32, N>

The resulting type after applying the * operator.

impl<const N: usize> Mul<Vector<i64, N>> for i64

fn mul(self, t: Vector<i64, N>) -> Self::Output

T * Point.

type Output = Vector<i64, N>

The resulting type after applying the * operator.

impl<const N: usize> Mul<Vector<i8, N>> for i8

fn mul(self, t: Vector<i8, N>) -> Self::Output

T * Point.

type Output = Vector<i8, N>

The resulting type after applying the * operator.

impl<const N: usize> Mul<Vector<isize, N>> for isize

fn mul(self, t: Vector<isize, N>) -> Self::Output

T * Point.

type Output = Vector<isize, N>

The resulting type after applying the * operator.

impl<const N: usize> Mul<Vector<u128, N>> for u128

fn mul(self, t: Vector<u128, N>) -> Self::Output

T * Point.

type Output = Vector<u128, N>

The resulting type after applying the * operator.

impl<const N: usize> Mul<Vector<u16, N>> for u16

fn mul(self, t: Vector<u16, N>) -> Self::Output

T * Point.

type Output = Vector<u16, N>

The resulting type after applying the * operator.

impl<const N: usize> Mul<Vector<u32, N>> for u32

fn mul(self, t: Vector<u32, N>) -> Self::Output

T * Point.

type Output = Vector<u32, N>

The resulting type after applying the * operator.

impl<const N: usize> Mul<Vector<u64, N>> for u64

fn mul(self, t: Vector<u64, N>) -> Self::Output

T * Point.

type Output = Vector<u64, N>

The resulting type after applying the * operator.

impl<const N: usize> Mul<Vector<u8, N>> for u8

fn mul(self, t: Vector<u8, N>) -> Self::Output

T * Point.

type Output = Vector<u8, N>

The resulting type after applying the * operator.

impl<const N: usize> Mul<Vector<usize, N>> for usize

fn mul(self, t: Vector<usize, N>) -> Self::Output

T * Point.

type Output = Vector<usize, N>

The resulting type after applying the * operator.

impl<T, U, const N: usize> MulAssign<U> for Vector<T, N> where
    T: Num + MulAssign<U>,
    U: Num, 

fn mul_assign(&mut self, val: U)

Performs the *= operation.

impl<T, const N: usize> Neg for Vector<T, N> where
    T: Num + Neg<Output = T>, 

type Output = Vector<T, N>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T: Ord, const N: usize> Ord for Vector<T, N>

fn cmp(&self, other: &Vector<T, N>) -> Ordering

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

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

Restrict a value to a certain interval.

impl<T: PartialEq, const N: usize> PartialEq<Vector<T, N>> for Vector<T, N>

fn eq(&self, other: &Vector<T, N>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Vector<T, N>) -> bool

This method tests for !=.

impl<T: PartialOrd, const N: usize> PartialOrd<Vector<T, N>> for Vector<T, N>

fn partial_cmp(&self, other: &Vector<T, N>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'a, T, const N: usize> Product<&'a Vector<T, N>> for Vector<T, N> where
    Self: Default + Mul<Output = Self>,
    T: Num, 

fn product<I>(iter: I) -> Self where
    I: Iterator<Item = &'a Self>, 

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<T, const N: usize> Product<Vector<T, N>> for Vector<T, N> where
    Self: Default + Mul<Output = Self>,
    T: Num, 

fn product<I>(iter: I) -> Self where
    I: Iterator<Item = Self>, 

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<T, const N: usize> Serialize for Vector<T, N> where
    T: Serialize + DeserializeOwned, 

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.

impl<T, const N: usize> Sub<Point<T, N>> for Vector<T, N> where
    T: Num + Sub, 

type Output = Point<T, N>

The resulting type after applying the - operator.

fn sub(self, other: Point<T, N>) -> Self::Output

Performs the - operation.

impl<T, U, const N: usize> Sub<U> for Vector<T, N> where
    T: Num + Sub<U, Output = T>,
    U: Num, 

type Output = Vector<T, N>

The resulting type after applying the - operator.

fn sub(self, val: U) -> Self::Output

Performs the - operation.

impl<T, const N: usize> Sub<Vector<T, N>> for Point<T, N> where
    T: Num + Sub, 

type Output = Point<T, N>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, const N: usize> Sub<Vector<T, N>> for Vector<T, N> where
    T: Num + Sub, 

type Output = Vector<T, N>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<T, U, const N: usize> SubAssign<U> for Vector<T, N> where
    T: Num + SubAssign<U>,
    U: Num, 

fn sub_assign(&mut self, val: U)

Performs the -= operation.

impl<T: Num, const N: usize> SubAssign<Vector<T, N>> for Point<T, N>

fn sub_assign(&mut self, other: Vector<T, N>)

Performs the -= operation.

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

fn sub_assign(&mut self, other: Vector<T, N>)

Performs the -= operation.

impl<'a, T, const N: usize> Sum<&'a Vector<T, N>> for Vector<T, N> where
    Self: Default + Add<Output = Self>,
    T: Num, 

fn sum<I>(iter: I) -> Self where
    I: Iterator<Item = &'a Self>, 

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl<T, const N: usize> Sum<Vector<T, N>> for Vector<T, N> where
    Self: Default + Add<Output = Self>,
    T: Num, 

fn sum<I>(iter: I) -> Self where
    I: Iterator<Item = Self>, 

Method which takes an iterator and generates Self from the elements by “summing up” the items.

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

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

impl<T, const N: usize> StructuralEq for Vector<T, N>

impl<T, const N: usize> StructuralPartialEq for Vector<T, N>