Struct Vector

pub struct Vector<T, const N: usize> { /* private fields */ }

A compile-time n-dimensional vector, how fancy!

Implementations

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

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

Create a new vector with the given components.

Vector::new([1, 2, 3]);

pub fn zero() -> Self

where T: Num + Copy,

Create a new vector with zeroed components.

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

Returns the components of the vector as a slice.

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

pub fn num_cast<K: Num + Copy + NumCast>(&self) -> Option<Vector<K, N>>

where T: ToPrimitive,

Allows numerically casting each component of the vector. Makes use of the num_traits::NumCast trait. If the cast fails, None is returned.

let a = vector!(1.0, 2.0, 3.0);
let b = vector!(1, 2, 3);

assert_eq!(a.num_cast::<i32>().unwrap(), b);

pub fn try_cast<K: Num + Copy + TryFrom<T>>( &self, ) -> Result<Vector<K, N>, <K as TryFrom<T>>::Error>

Allows casting each component of the vector using the TryFrom trait. If the cast fails, an error is returned.

In many cases Vector::num_cast is more versatile as it supports more conversions. For example u32 to f32 is supported by Vector::num_cast but not by Vector::try_cast.

let a: Vector<u32, 3> = vector!(1, 2, 3);
let b: Vector<u8, 3> = vector!(1, 2, 3);

assert_eq!(a.try_cast().unwrap(), b);

pub fn cast<K: Num + Copy + From<T>>(&self) -> Vector<K, N>

Casts each component of the vector to the given type.

This is similar to Vector::try_cast but only works if the cast is infallible. Because of this, it should be preferred over Vector::try_cast when casting from smaller to larger types.

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

pub fn hadamard_product(&self, other: &Self) -> Self

Computes the Hadamard product of two vectors (component-wise multiplication).

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

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

Takes the minimum of each component of two vectors.

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

Takes the maximum of each component of two vectors.

pub fn min_component(&self) -> T

Takes the minimum component of a vector.

pub fn max_component(&self) -> T

Takes the maximum component of a vector.

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

pub fn opposite(&self) -> Self

Calculates the opposite of a vector. This is the vector with all components negated.

pub fn signum(&self) -> Self

Calculates the sign of each component of a vector. This is -1 if the component is negative, 0 if it is zero, and 1 if it is positive.

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

Calculates the Manhattan Distance of two vectors.

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

pub fn sum(&self) -> T

pub fn magnitude_squared(&self) -> T

Calculates the sum of all squared components. Used for calculating the magnitude of a vector.

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

Calculates the dot product of two vectors.

impl<T: Num + Copy + Sum + Real, const N: usize> Vector<T, N>

pub fn magnitude(&self) -> T

Calculates the magnitude of a vector. This is the square root of the sum of all squared components.

pub fn normalize(&self) -> Self

Normalizes a vector. This is the vector divided by its magnitude.

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

Calculates the Euclidean Distance of two vectors.

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

pub fn abs(&self) -> Self

Calculates the absolute value of each component of a vector.

impl<T: Copy> Vector<T, 2>

pub fn x(&self) -> T

pub fn y(&self) -> T

impl<T: Copy> Vector<T, 3>

pub fn x(&self) -> T

pub fn y(&self) -> T

pub fn z(&self) -> T

Trait Implementations

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

type Output = Vector<T, N>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Vector<T, N>

The resulting type after applying the + operator.

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

Performs the + operation.

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

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

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: Num + Copy + Display, 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 + Copy, const N: usize> Default for Vector<T, N>

fn default() -> Self

Create a new vector with zeroed components.

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

type Output = Vector<T, N>

The resulting type after applying the / operator.

fn div(self, other: T) -> Self::Output

Performs the / operation.

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

type Output = Vector<T, N>

The resulting type after applying the / operator.

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

Performs the / operation.

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

fn div_assign(&mut self, rhs: Self)

Performs the /= operation.

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

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

Create a new vector from an iterator. If the iterator has less than N items, the remaining components will be zeroed. If the iterator has more than N items, the remaining items will be ignored.

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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: Num + Copy + Send + Sync, const N: usize> Mul<T> for Vector<T, N>

type Output = Vector<T, N>

The resulting type after applying the * operator.

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

Performs the * operation.

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

fn neg(self) -> Self::Output

Negates all components of a vector.

type Output = Vector<T, N>

The resulting type after applying the - operator.

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

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<T: Num + Copy, const N: usize> Rem<T> for Vector<T, N>

type Output = Vector<T, N>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Vector<T, N>

The resulting type after applying the % operator.

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

Performs the % operation.

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

fn rem_assign(&mut self, rhs: Self)

Performs the %= operation.

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

type Output = Vector<T, N>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Vector<T, N>

The resulting type after applying the - operator.

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

Performs the - operation.

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

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

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

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