Struct Vector 

pub struct Vector<E, const LEN: usize>(pub [E; LEN])
where
    E: MatEl;

A vector structure.

Tuple Fields

0: [E; LEN]

Implementations

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

where E: MatEl,

pub const fn splat(v: E) -> Self

Creates a vector from a single value : [ v ; N ]

pub fn to_array(&self) -> [E; N]

Return underlying array data

pub fn from_array(src: [E; N]) -> Self

Creates vector from given raw array

pub fn from_slice(src: &[E]) -> Self

Creates vector from given raw slice. Assumes slice’s length is equal to vector size

Panics

Panics if src lenght does not match vector size

impl<E: MatEl + NdFloat, const LEN: usize> Vector<E, LEN>

pub fn normalize(self) -> Self

Normalizes the vector

pub fn mag(&self) -> E

Compute the length of the vector

pub fn mag2(&self) -> E

Computer the squared length of the vector

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

Compute a vector, whose elements are minimum of both vectors: r[ i ] = a[ i ].min( b [ i ] )

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

Compute a vector, whose elements are maximum of both vectors: r[ i ] = a[ i ].max( b [ i ] )

pub fn distance(&self, rhs: &Self) -> E

Computes length of the vector between two points in space

pub fn distance_squared(&self, rhs: &Self) -> E

Computes squared length of the vector between two points in space

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

Computes the dot product of two vectors

impl<E> Vector<E, 2>

where E: MatEl + NdFloat,

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

Create a new vector

pub fn x(&self) -> E

The x component of vector

pub fn y(&self) -> E

The y component of vector

impl Vector<f32, 2>

pub const X: Self

Unit x vector

pub const Y: Self

Unit y vector

pub const NEG_X: Self

Minus unit x vector

pub const NEG_Y: Self

Minus unit y vector

pub const MIN: Self

All elements are f32::MIN

pub const MAX: Self

All elements are f32::MAX

pub const ZERO: Self

All elemets are ZERO

impl<E> Vector<E, 3>

where E: MatEl + NdFloat,

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

Create a new vector

pub fn x(&self) -> E

The x component of vector

pub fn y(&self) -> E

The y component of vector

pub fn z(&self) -> E

The z component of vector

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

Calculates cross product with another vector

pub fn to_homogenous(self) -> Vector<E, 4>

Creates homogeneous vector from self

impl Vector<f32, 3>

pub const X: Self

Unit x vector

pub const Y: Self

Unit y vector

pub const Z: Self

Unit z vector

pub const NEG_X: Self

Minus unit x vector

pub const NEG_Y: Self

Minus unit y vector

pub const NEG_Z: Self

Minus unit z vector

pub const MIN: Self

All elements are f32::MIN

pub const MAX: Self

All elements are f32::MAX

pub const ZERO: Self

All elemets are ZERO

impl<E> Vector<E, 4>

where E: MatEl + NdFloat,

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

Create a new vector

pub fn x(&self) -> E

The x component of vector

pub fn y(&self) -> E

The y component of vector

pub fn z(&self) -> E

The z component of vector

pub fn w(&self) -> E

The w component of vector

pub fn truncate(&self) -> Vector<E, 3>

Truncates w component of a vector creating vector of 3 elements

impl Vector<f32, 4>

pub const X: Self

Unit x vector

pub const Y: Self

Unit y vector

pub const Z: Self

Unit z vector

pub const W: Self

Unit w vector

pub const NEG_X: Self

Minus unit x vector

pub const NEG_Y: Self

Minus unit y vector

pub const NEG_Z: Self

Minus unit z vector

pub const NEG_W: Self

Minus unit w vector

pub const MIN: Self

All elements are f32::MIN

pub const MAX: Self

All elements are f32::MAX

pub const ZERO: Self

All elemets are ZERO

Methods from Deref<Target = [E; 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]

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

Example

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.

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]

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

Example

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<E, const SIZE: usize> AbsDiffEq for Vector<E, SIZE>

where E: AbsDiffEq + MatEl, E::Epsilon: Copy,

type Epsilon = <[E] 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: &Rhs, epsilon: Self::Epsilon) -> bool

The inverse of AbsDiffEq::abs_diff_eq.

impl<E, const LEN: usize> Add<E> for Vector<E, LEN>

where E: MatEl + NdFloat,

type Output = Vector<E, LEN>

The resulting type after applying the + operator.

fn add(self, rhs: E) -> Self::Output

Performs the + operation.

impl<E, const LEN: usize> Add for &Vector<E, LEN>

where E: MatEl + NdFloat,

type Output = Vector<E, LEN>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<E, const LEN: usize> Add for Vector<E, LEN>

where E: MatEl + NdFloat,

type Output = Vector<E, LEN>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<E, const LEN: usize> AddAssign for Vector<E, LEN>

where E: MatEl + NdFloat,

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<E, const N: usize> ArrayMut<E, N> for Vector<E, N>

where E: MatEl,

fn vector_mut(&mut self) -> &mut [E; N]

Returns a mutable reference to a fixed-size array from the collection.

impl<E, const N: usize> ArrayRef<E, N> for Vector<E, N>

where E: MatEl,

fn array_ref(&self) -> &[E; N]

Returns a reference to a fixed-size array from the collection.

impl<E, const LEN: usize> Clone for Vector<E, LEN>

where E: MatEl + Clone,

fn clone(&self) -> Vector<E, LEN>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<E, const N: usize> Collection for Vector<E, N>

where E: MatEl,

type Scalar = E

The scalar type contained in the collection.

impl<E, const N: usize> ConstLength for Vector<E, N>

where E: MatEl,

const LEN: usize = N

The length of the entity.

impl<E, const LEN: usize> Debug for Vector<E, LEN>

where E: MatEl + Debug,

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

Formats the value using the given formatter.

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

where E: MatEl + Default,

fn default() -> Self

Returns the “default value” for a type.

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

where E: MatEl,

type Target = [E; N]

The resulting type after dereferencing.

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

Dereferences the value.

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

where E: MatEl,

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

Mutably dereferences the value.

impl<E, const LEN: usize> Div<E> for Vector<E, LEN>

where E: MatEl + NdFloat,

type Output = Vector<E, LEN>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<E, const LEN: usize> Div for Vector<E, LEN>

where E: MatEl + NdFloat + DivAssign,

type Output = Vector<E, LEN>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<E, const LEN: usize> DivAssign<E> for Vector<E, LEN>

where E: MatEl + NdFloat,

fn div_assign(&mut self, rhs: E)

Performs the /= operation.

impl<E, const LEN: usize> DivAssign for Vector<E, LEN>

where E: MatEl + NdFloat,

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

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

fn from(value: [E; N]) -> Self

Converts to this type from the input type.

impl<E, Vec2> From<(Vec2, Vec2)> for Vector<E, 4>

where Vec2: VectorIter<E, 2>, E: MatEl,

fn from(value: (Vec2, Vec2)) -> Self

Converts to this type from the input type.

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

fn from(value: Vector<E, N>) -> Self

Converts to this type from the input type.

impl<E, const LEN: usize> Hash for Vector<E, LEN>

where E: MatEl + Hash,

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

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

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

where E: MatEl,

type Output = E

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

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

where E: MatEl,

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

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

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

where E: MatEl,

type Item = &'a E

The type of the elements being iterated over.

type IntoIter = Iter<'a, E>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

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

where E: MatEl,

type Item = &'a mut E

The type of the elements being iterated over.

type IntoIter = IterMut<'a, E>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

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

where E: MatEl,

type Item = E

The type of the elements being iterated over.

type IntoIter = IntoIter<E, N>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<E, const ROWS: usize, const COLS: usize, Descriptor> Mul<&Vector<E, COLS>> for &Mat<ROWS, COLS, E, Descriptor>

where Descriptor: Descriptor, E: MatEl + NdFloat, Mat<ROWS, COLS, E, Descriptor>: Indexable<Index = Ix2> + IndexingRef<Scalar = E>,

type Output = Vector<E, COLS>

The resulting type after applying the * operator.

fn mul(self, rhs: &Vector<E, COLS>) -> Self::Output

Performs the * operation.

impl<E, const LEN: usize> Mul<E> for Vector<E, LEN>

where E: MatEl + NdFloat,

type Output = Vector<E, LEN>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<E, const ROWS: usize, const COLS: usize, Descriptor> Mul<Vector<E, COLS>> for Mat<ROWS, COLS, E, Descriptor>

where Descriptor: Descriptor, E: MatEl + NdFloat, Mat<ROWS, COLS, E, Descriptor>: Indexable<Index = Ix2> + IndexingRef<Scalar = E>,

type Output = Vector<E, COLS>

The resulting type after applying the * operator.

fn mul(self, rhs: Vector<E, COLS>) -> Self::Output

Performs the * operation.

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

type Output = Vector<f32, LEN>

The resulting type after applying the * operator.

fn mul(self, rhs: Vector<f32, LEN>) -> Self::Output

Performs the * operation.

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

type Output = Vector<f64, LEN>

The resulting type after applying the * operator.

fn mul(self, rhs: Vector<f64, LEN>) -> Self::Output

Performs the * operation.

impl<E, const LEN: usize> Mul for Vector<E, LEN>

where E: MatEl + NdFloat,

type Output = Vector<E, LEN>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<E, const LEN: usize> MulAssign<E> for Vector<E, LEN>

where E: MatEl + NdFloat,

fn mul_assign(&mut self, rhs: E)

Performs the *= operation.

impl<E, const ROWS: usize, const COLS: usize, Descriptor> MulAssign<Mat<ROWS, COLS, E, Descriptor>> for Vector<E, COLS>

where Descriptor: Descriptor, E: MatEl + NdFloat, Mat<ROWS, COLS, E, Descriptor>: Indexable<Index = Ix2> + IndexingRef<Scalar = E>,

fn mul_assign(&mut self, rhs: Mat<ROWS, COLS, E, Descriptor>)

Performs the *= operation.

impl<E, const LEN: usize> Neg for &Vector<E, LEN>

where E: MatEl + NdFloat,

type Output = Vector<E, LEN>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<E, const LEN: usize> Neg for Vector<E, LEN>

where E: MatEl + NdFloat,

type Output = Vector<E, LEN>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<E, const LEN: usize> PartialEq for Vector<E, LEN>

where E: MatEl + PartialEq,

fn eq(&self, other: &Vector<E, LEN>) -> 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<E, const LEN: usize> PartialOrd for Vector<E, LEN>

where E: MatEl + PartialOrd,

fn partial_cmp(&self, other: &Vector<E, LEN>) -> Option<Ordering>

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

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

Tests greater than (for self and other) and is used by the > operator.

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

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

impl<E, const SIZE: usize> RelativeEq for Vector<E, SIZE>

where E: RelativeEq + MatEl, E::Epsilon: Copy,

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: &Rhs, epsilon: Self::Epsilon, max_relative: Self::Epsilon, ) -> bool

The inverse of RelativeEq::relative_eq.

impl<E, const LEN: usize> Rem<E> for &Vector<E, LEN>

where E: MatEl + NdFloat + Rem<Output = E>,

type Output = Vector<E, LEN>

The resulting type after applying the % operator.

fn rem(self, scalar: E) -> Self::Output

Performs the % operation.

impl<E, const LEN: usize> Rem<E> for Vector<E, LEN>

where E: MatEl + NdFloat + Rem<Output = E>,

type Output = Vector<E, LEN>

The resulting type after applying the % operator.

fn rem(self, scalar: E) -> Self::Output

Performs the % operation.

impl<E, const LEN: usize> Rem for &Vector<E, LEN>

where E: MatEl + NdFloat + Rem<Output = E>,

type Output = Vector<E, LEN>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<E, const LEN: usize> Rem for Vector<E, LEN>

where E: MatEl + NdFloat + Rem<Output = E>,

type Output = Vector<E, LEN>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<E, const LEN: usize> RemAssign<E> for Vector<E, LEN>

where E: MatEl + NdFloat + Rem<Output = E>,

fn rem_assign(&mut self, scalar: E)

Performs the %= operation.

impl<E, const LEN: usize> RemAssign for Vector<E, LEN>

where E: MatEl + NdFloat + Rem<Output = E>,

fn rem_assign(&mut self, rhs: Self)

Performs the %= operation.

impl<E, const LEN: usize> Sub<E> for Vector<E, LEN>

where E: MatEl + NdFloat,

type Output = Vector<E, LEN>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<E, const LEN: usize> Sub for &Vector<E, LEN>

where E: MatEl + NdFloat,

type Output = Vector<E, LEN>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<E, const LEN: usize> Sub for Vector<E, LEN>

where E: MatEl + NdFloat,

type Output = Vector<E, LEN>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<E, const LEN: usize> SubAssign for Vector<E, LEN>

where E: MatEl + NdFloat,

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<E, const N: usize> TryFrom<&[E]> for Vector<E, N>

where E: MatEl,

type Error = &'static str

The type returned in the event of a conversion error.

fn try_from(value: &[E]) -> Result<Self, Self::Error>

Performs the conversion.

impl<E, const SIZE: usize> UlpsEq for Vector<E, SIZE>

where E: UlpsEq + MatEl, E::Epsilon: Copy,

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: &Rhs, epsilon: Self::Epsilon, max_ulps: u32) -> bool

The inverse of UlpsEq::ulps_eq.

impl<E, const N: usize> VectorIter<E, N> for Vector<E, N>

where E: MatEl,

fn vector_iter<'a>(&'a self) -> impl VectorIteratorRef<'a, &'a E>

where E: 'a,

Returns an iterator over references to the elements of the vector.

impl<E, const N: usize> VectorIterMut<E, N> for Vector<E, N>

where E: MatEl,

fn vector_iter_mut<'a>(&'a mut self) -> impl VectorIterator<'a, &'a mut E>

where E: 'a,

Returns an iterator over mutable references to the elements of the vector.

impl<E, const LEN: usize> Copy for Vector<E, LEN>

where E: MatEl + Copy,

impl<E, const LEN: usize> StructuralPartialEq for Vector<E, LEN>

where E: MatEl,