Struct vecmat::Vector

#[repr(transparent)]pub struct Vector<T, const N: usize> { /* fields omitted */ }

Vector of fixed size.

Implementations

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

pub fn uninit() -> Vector<MaybeUninit<T>, N>

Create a vector with uninitialized content.

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

pub unsafe fn assume_init(self) -> Vector<T, N>

Assume that vector content is initialized.

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

pub fn init<F: FnMut() -> T>(f: F) -> Self

Initialize a vector with values from closure.

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

pub fn new() -> Self

Create default vector.

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

pub fn fill(v: T) -> Self

Create vector which elements are filled with scalar value.

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

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

Create from array.

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

Convert to array.

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

Get a reference to underlying array.

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

Get a mutable reference to underlying array.

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

pub fn as_ptr(&self) -> *const T

Get pointer to the first element.

pub fn as_mut_ptr(&mut self) -> *mut T

Get mutable pointer to the first element.

pub unsafe fn get_unchecked(&self, i: usize) -> &T

Get reference to the elements without boundary checking.

pub unsafe fn get_unchecked_mut(&mut self, i: usize) -> &mut T

Get mutable reference to the elements without boundary checking.

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

pub fn iter(&self) -> Iter<'_, T>

Returns iterator over vector element refrences.

pub fn iter_mut(&mut self) -> IterMut<'_, T>

Returns iterator over vector element mutable refrences.

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

pub fn try_from_iter<I>(iter: I) -> Option<Self> where
    I: Iterator<Item = T>, 

Try to conctruct a vector from iterator. If iterator conatains less items than vector, then Err is returned.

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

pub fn indices() -> Self

Create vector which element value equals to its position in vector.

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

pub fn for_each<F: FnMut(T)>(self, f: F)

Call closure for each element of the vector passing it by value.

pub fn map<U, F: FnMut(T) -> U>(self, f: F) -> Vector<U, N>

Map vector elements.

pub fn zip<U>(self, other: Vector<U, N>) -> Vector<(T, U), N>

Zip two vectors into one.

pub fn enumerate(self) -> Vector<(usize, T), N>

Enumerate vector elements.

impl<T, U, const N: usize> Vector<(T, U), N>

pub fn unzip(self) -> (Vector<T, N>, Vector<U, N>)

Unzip vector of tuples into two vectors.

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

pub fn fold<S, F: FnMut(S, T) -> S>(self, s: S, f: F) -> S

pub fn fold_first<F: FnMut(T, T) -> T>(self, f: F) -> T

pub fn scan<S, U, F: FnMut(&mut S, T) -> U>(self, s: S, f: F) -> Vector<U, N>

impl<T, const N: usize> Vector<T, N> where
    T: Add<Output = T> + Mul<Output = T> + Copy, 

pub fn square_length(self) -> T

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

pub fn length(self) -> T

pub fn normalize(self) -> Vector<T, N>

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

pub fn sum(self) -> T where
    T: Add<Output = T>, 

pub fn max(self) -> T where
    T: PartialOrd, 

pub fn min(self) -> T where
    T: PartialOrd, 

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

pub fn any(self) -> bool

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

pub fn all(self) -> bool

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

pub fn div_floor(self, other: Vector<T, N>) -> Vector<T, N>

pub fn mod_floor(self, other: Vector<T, N>) -> Vector<T, N>

pub fn div_mod_floor(self, other: Vector<T, N>) -> (Vector<T, N>, Vector<T, N>)

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

pub fn veq(self, other: Vector<T, N>) -> Vector<bool, N>

pub fn vne(self, other: Vector<T, N>) -> Vector<bool, N>

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

pub fn vlt(self, other: Vector<T, N>) -> Vector<bool, N>

pub fn vle(self, other: Vector<T, N>) -> Vector<bool, N>

pub fn vgt(self, other: Vector<T, N>) -> Vector<bool, N>

pub fn vge(self, other: Vector<T, N>) -> Vector<bool, N>

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

pub fn x(&self) -> T

pub fn y(&self) -> T

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

pub fn x(&self) -> T

pub fn y(&self) -> T

pub fn z(&self) -> T

impl<T> Vector<T, 4> where
    T: Copy, 

pub fn x(&self) -> T

pub fn y(&self) -> T

pub fn z(&self) -> T

pub fn w(&self) -> T

impl<T> Vector<T, 2>

pub fn x_ref(&self) -> &T

pub fn y_ref(&self) -> &T

pub fn x_mut(&mut self) -> &mut T

pub fn y_mut(&mut self) -> &mut T

impl<T> Vector<T, 3>

pub fn x_ref(&self) -> &T

pub fn y_ref(&self) -> &T

pub fn z_ref(&self) -> &T

pub fn x_mut(&mut self) -> &mut T

pub fn y_mut(&mut self) -> &mut T

pub fn z_mut(&mut self) -> &mut T

impl<T> Vector<T, 4>

pub fn x_ref(&self) -> &T

pub fn y_ref(&self) -> &T

pub fn z_ref(&self) -> &T

pub fn w_ref(&self) -> &T

pub fn x_mut(&mut self) -> &mut T

pub fn y_mut(&mut self) -> &mut T

pub fn z_mut(&mut self) -> &mut T

pub fn w_mut(&mut self) -> &mut T

impl<T> Vector<T, 2> where
    T: Mul<Output = T> + Sub<Output = T> + Copy, 

pub fn cross(self, other: Vector<T, 2>) -> T

Pseudo-cross product for 2D vector.

impl<T> Vector<T, 3> where
    T: Mul<Output = T> + Sub<Output = T> + Copy, 

pub fn cross(self, other: Vector<T, 3>) -> Vector<T, 3>

Cross product.

impl<T> Vector<T, 4> where
    T: Mul<Output = T> + Sub<Output = T> + Zero + Copy, 

pub fn cross(self, other: Vector<T, 4>) -> Vector<T, 4>

Cross product of first three components, fourth one is set to zero.

impl<T> Vector<T, 2>

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

pub fn into_tuple(self) -> (T, T)

impl<T> Vector<T, 3>

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

pub fn into_tuple(self) -> (T, T, T)

impl<T> Vector<T, 4>

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

pub fn into_tuple(self) -> (T, T, T, T)

Trait Implementations

impl<T, const N: usize> AbsDiffEq<Vector<T, N>> for Vector<T, N> where
    T: AbsDiffEq<Epsilon = T> + Copy, 

type Epsilon = T

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.

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

The inverse of AbsDiffEq::abs_diff_eq.

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

type Output = Vector<T, N>

The resulting type after applying the + operator.

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

Performs the + operation.

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

fn add_assign(&mut self, vec: 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]

Performs the conversion.

impl<T, const M: usize, const N: usize> AsMut<Vector<Vector<T, N>, M>> for Matrix<T, M, N>

fn as_mut(&mut self) -> &mut Vector<Vector<T, N>, M>

Performs the conversion.

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

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

Performs the conversion.

impl<T, const M: usize, const N: usize> AsRef<Vector<Vector<T, N>, M>> for Matrix<T, M, N>

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

Performs the conversion.

impl<T, const N: usize> BitAnd<Vector<T, N>> for Vector<T, N> where
    T: BitAnd<Output = T>, 

type Output = Vector<T, N>

The resulting type after applying the & operator.

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

Performs the & operation.

impl<T, const N: usize> BitAndAssign<Vector<T, N>> for Vector<T, N> where
    T: BitAndAssign, 

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

Performs the &= operation.

impl<T, const N: usize> BitOr<Vector<T, N>> for Vector<T, N> where
    T: BitOr<Output = T>, 

type Output = Vector<T, N>

The resulting type after applying the | operator.

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

Performs the | operation.

impl<T, const N: usize> BitOrAssign<Vector<T, N>> for Vector<T, N> where
    T: BitOrAssign, 

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

Performs the |= operation.

impl<T, const N: usize> BitXor<Vector<T, N>> for Vector<T, N> where
    T: BitXor<Output = T>, 

type Output = Vector<T, N>

The resulting type after applying the ^ operator.

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

Performs the ^ operation.

impl<T, const N: usize> BitXorAssign<Vector<T, N>> for Vector<T, N> where
    T: BitXorAssign, 

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

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.

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

Performs copy-assignment from source.

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

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

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

Formats the value using the given formatter.

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

fn default() -> Self

Create vector filled with default values.

impl<T, const N: usize> Display for Vector<T, N> where
    T: Display, 

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

Formats the value using the given formatter.

impl<D: Distribution<T>, T, const N: usize> Distribution<Vector<T, N>> for VectorDistribution<D, T, N>

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Vector<T, N>

Generate a random value of T, using rng as the source of randomness.

pub fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T> where
    R: Rng, 

Create an iterator that generates random values of T, using rng as the source of randomness.

impl<T, const N: usize> Distribution<Vector<T, N>> for Normal where
    Normal: Distribution<T>, 

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Vector<T, N>

Generate a random value of T, using rng as the source of randomness.

pub fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T> where
    R: Rng, 

Create an iterator that generates random values of T, using rng as the source of randomness.

impl<T: Float, const N: usize> Distribution<Vector<T, N>> for NonZero where
    Normal: Distribution<Vector<T, N>>, 

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Vector<T, N>

Generate a random value of T, using rng as the source of randomness.

pub fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T> where
    R: Rng, 

Create an iterator that generates random values of T, using rng as the source of randomness.

impl<T: Float, const N: usize> Distribution<Vector<T, N>> for Unit where
    NonZero: Distribution<Vector<T, N>>, 

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Vector<T, N>

Generate a random value of T, using rng as the source of randomness.

pub fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T> where
    R: Rng, 

Create an iterator that generates random values of T, using rng as the source of randomness.

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

type Output = Vector<T, N>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Vector<T, N>

The resulting type after applying the / operator.

fn div(self, vec: Vector<T, N>) -> Self::Output

Performs the / operation.

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

fn div_assign(&mut self, a: T)

Performs the /= operation.

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

fn div_assign(&mut self, vec: Vector<T, N>)

Performs the /= operation.

impl<T, const M: usize, const N: usize> Dot<Matrix<T, M, N>> for Vector<T, M> where
    T: Mul<Output = T> + Add<Output = T> + Copy, 

type Output = Vector<T, N>

Dot product output type.

fn dot(self, mat: Matrix<T, M, N>) -> Self::Output

Perform dot product.

impl<T, const M: usize, const N: usize> Dot<Vector<T, N>> for Matrix<T, M, N> where
    T: Mul<Output = T> + Add<Output = T> + Copy, 

type Output = Vector<T, M>

Dot product output type.

fn dot(self, vec: Vector<T, N>) -> Self::Output

Perform dot product.

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

type Output = T

Dot product output type.

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

Perform dot product.

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

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

Performs the conversion.

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

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

Performs the conversion.

impl<'a, T, const M: usize, const N: usize> From<&'a Matrix<T, M, N>> for &'a Vector<Vector<T, N>, M>

fn from(mr: &'a Matrix<T, M, N>) -> Self

Performs the conversion.

impl<'a, T, const M: usize, const N: usize> From<&'a mut Matrix<T, M, N>> for &'a mut Vector<Vector<T, N>, M>

fn from(mr: &'a mut Matrix<T, M, N>) -> Self

Performs the conversion.

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

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

Performs the conversion.

impl<T> From<(T, T, T, T)> for Vector<T, 4>

fn from(tuple: (T, T, T, T)) -> Self

Performs the conversion.

impl<T> From<(T, T, T)> for Vector<T, 3>

fn from(tuple: (T, T, T)) -> Self

Performs the conversion.

impl<T> From<(T, T)> for Vector<T, 2>

fn from(tuple: (T, T)) -> Self

Performs the conversion.

impl<T, const M: usize, const N: usize> From<Matrix<T, M, N>> for Vector<Vector<T, N>, M>

fn from(mat: Matrix<T, M, N>) -> Self

Performs the conversion.

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

fn from(shift: Shift<T, N>) -> Self

Performs the conversion.

impl<T> From<Vector<T, 2_usize>> for Complex<T>

fn from(vec: Vector2<T>) -> Self

Performs the conversion.

impl<T> From<Vector<T, 4_usize>> for Quaternion<T>

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

Performs the conversion.

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

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

Performs the conversion.

impl<T, const M: usize, const N: usize> From<Vector<Vector<T, N>, M>> for Matrix<T, M, N>

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

Performs the conversion.

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

type Output = T

The returned type after indexing.

fn index(&self, i: usize) -> &T

Performs the indexing (container[index]) operation.

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

fn index_mut(&mut self, i: usize) -> &mut T

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<T, 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, const N: usize> Mul<T> for Vector<T, N> where
    T: Mul<Output = T> + Copy, 

type Output = Vector<T, N>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Vector<T, N>

The resulting type after applying the * operator.

fn mul(self, vec: Vector<T, N>) -> Self::Output

Performs the * operation.

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

fn mul_assign(&mut self, a: T)

Performs the *= operation.

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

fn mul_assign(&mut self, vec: Vector<T, N>)

Performs the *= operation.

impl<T, const N: usize> Neg for Vector<T, N> where
    T: 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, const N: usize> NormL1 for Vector<T, N> where
    T: NormL1<Output = T> + Add<Output = T>, 

type Output = T

Type of the norm.

fn norm_l1(self) -> T

Norm of the element.

impl<T, const N: usize> NormL2 for Vector<T, N> where
    T: Float, 

type Output = T

Type of the norm.

fn norm_l2_sqr(self) -> T

Square norm of the element.

fn norm_l2(self) -> T

Norm of the element.

impl<T, const N: usize> NormLInf for Vector<T, N> where
    T: NormLInf<Output = T> + PartialOrd, 

type Output = T

Type of the norm.

fn norm_l_inf(self) -> T

Norm of the element.

impl<T, const N: usize> Not for Vector<T, N> where
    T: Not<Output = T>, 

type Output = Vector<T, N>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<T, const M: usize, const N: usize> Outer<Vector<T, N>> for Vector<T, M> where
    T: Mul<Output = T> + Copy, 

type Output = Matrix<T, M, N>

Outer product output type.

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

Perform outer product.

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

type Output = Vector<T, N>

The resulting type after applying the % operator.

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

Performs the % operation.

impl<T, const N: usize> Rem<Vector<T, N>> for Vector<T, N> where
    T: Rem<Output = T>, 

type Output = Vector<T, N>

The resulting type after applying the % operator.

fn rem(self, vec: Vector<T, N>) -> Self::Output

Performs the % operation.

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

fn rem_assign(&mut self, a: T)

Performs the %= operation.

impl<T, const N: usize> RemAssign<Vector<T, N>> for Vector<T, N> where
    T: RemAssign, 

fn rem_assign(&mut self, vec: Vector<T, N>)

Performs the %= operation.

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

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

type Output = Vector<T, N>

The resulting type after applying the - operator.

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

Performs the - operation.

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

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

Performs the -= operation.

impl<'a, T, const N: usize> TryFrom<&'a [T]> for Vector<T, N> where
    T: Copy, 

type Error = ()

The type returned in the event of a conversion error.

fn try_from(s: &'a [T]) -> Result<Self, Self::Error>

Performs the conversion.

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

fn zero() -> Self

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

pub fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.