Struct aljabar::Vector

pub struct Vector<T, const N: usize>(_);

N-element vector.

Vectors can be constructed from arrays of any type and size. There are convenience constructor functions provided for the most common sizes.

Methods

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

pub fn trunc(self) -> (TruncatedVector<T, { N }>, T)

Drop the last component and return the vector with one fewer dimension.

Trait Implementations

impl<T, const N: usize> Zero for Vector<T, { N }> where
    T: Zero, 

fn zero() -> Self

Returns the additive identity of Self.

fn is_zero(&self) -> bool

Returns true if the value is the additive identity.

impl<T, const N: usize> VectorSpace for Vector<T, { N }> where
    T: Clone + Zero,
    T: Add<T, Output = T>,
    T: Sub<T, Output = T>,
    T: Mul<T, Output = T>,
    T: Div<T, Output = T>, 

type Scalar = T

fn lerp(self, other: Self, amount: Self::Scalar) -> Self

impl<T, const N: usize> MetricSpace for Vector<T, { N }> where
    Self: InnerSpace, 

type Metric = Self::Scalar

fn distance2(self, other: Self) -> Self::Metric

Returns the distance squared between the two values.

impl<T, const N: usize> InnerSpace for Vector<T, { N }> where
    T: Clone + Zero,
    T: Add<T, Output = T>,
    T: Sub<T, Output = T>,
    T: Mul<T, Output = T>,
    T: Div<T, Output = T>,
    T: AddAssign<T>,
    Self: Clone, 

fn dot(self, rhs: Self) -> T

Return the inner (also known as "dot") product.

fn magnitude2(self) -> Self::Scalar

Returns the squared length of the value.

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

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

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

Performs the conversion.

impl<T, const N: usize> Into<[T; N]> for Vector<T, { N }>

fn into(self) -> [T; {N}]

Performs the conversion.

impl<A, B, RHS, const N: usize> PartialEq<RHS> for Vector<A, { N }> where
    RHS: Deref<Target = [B; {N}]>,
    A: PartialEq<B>, 

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

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

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

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

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

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

Formats the value using the given formatter.

impl<A, B, const N: usize> Div<B> for Vector<A, { N }> where
    A: Div<B>,
    B: Clone, 

Scalar divide

type Output = Vector<<A as Div<B>>::Output, { N }>

The resulting type after applying the / operator.

fn div(self, scalar: B) -> Self::Output

Performs the / operation.

impl<A, B, const N: usize> Add<Vector<B, N>> for Vector<A, { N }> where
    A: Add<B>, 

type Output = Vector<<A as Add<B>>::Output, { N }>

The resulting type after applying the + operator.

fn add(self, rhs: Vector<B, { N }>) -> Self::Output

Performs the + operation.

impl<A, B, const N: usize> Sub<Vector<B, N>> for Vector<A, { N }> where
    A: Sub<B>, 

type Output = Vector<<A as Sub<B>>::Output, { N }>

The resulting type after applying the - operator.

fn sub(self, rhs: Vector<B, { N }>) -> Self::Output

Performs the - operation.

impl<A, B, const N: usize> Mul<B> for Vector<A, { N }> where
    A: Mul<B>,
    B: Clone, 

Scalar multiply

type Output = Vector<<A as Mul<B>>::Output, { N }>

The resulting type after applying the * operator.

fn mul(self, scalar: B) -> Self::Output

Performs the * operation.

impl<T, const N: usize, const M: usize> Mul<Vector<T, M>> for Matrix<T, { N }, { M }> where
    T: Add<T, Output = T> + Mul<T, Output = T> + Clone,
    Vector<T, { M }>: InnerSpace, 

type Output = Vector<<Vector<T, { M }> as VectorSpace>::Scalar, { N }>

The resulting type after applying the * operator.

fn mul(self, rhs: Vector<T, { M }>) -> Self::Output

Performs the * operation.

impl<T, const N: usize> Neg for Vector<T, { N }> where
    T: Neg, 

type Output = Vector<<T as Neg>::Output, { N }>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<A, B, const N: usize> AddAssign<Vector<B, N>> for Vector<A, { N }> where
    A: AddAssign<B>, 

fn add_assign(&mut self, rhs: Vector<B, { N }>)

Performs the += operation.

impl<A, B, const N: usize> SubAssign<Vector<B, N>> for Vector<A, { N }> where
    A: SubAssign<B>, 

fn sub_assign(&mut self, rhs: Vector<B, { N }>)

Performs the -= operation.

impl<A, B, const N: usize> MulAssign<B> for Vector<A, { N }> where
    A: MulAssign<B>,
    B: Clone, 

Scalar multiply assign

fn mul_assign(&mut self, scalar: B)

Performs the *= operation.

impl<A, B, const N: usize> DivAssign<B> for Vector<A, { N }> where
    A: DivAssign<B>,
    B: Clone, 

Scalar divide assign

fn div_assign(&mut self, scalar: B)

Performs the /= operation.

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.