Struct vecmat::Vector

source · [−]

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

Expand description

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)

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

pub fn abs(self) -> Self

pub fn abs_sub<B: Broadcast<Self>>(self, other: B) -> Self

pub fn signum(self) -> Self

pub fn cbrt(self) -> Self

pub fn sqrt(self) -> Self

pub fn vmin<B: Broadcast<Self>>(self, other: B) -> Self

pub fn vmax<B: Broadcast<Self>>(self, other: B) -> Self

pub fn clamp<A: Broadcast<Self>, B: Broadcast<Self>>(self, a: A, b: B) -> Self

pub fn acos(self) -> Self

pub fn asin(self) -> Self

pub fn atan(self) -> Self

pub fn atan2<B: Broadcast<Self>>(self, other: B) -> Self

pub fn cosh(self) -> Self

pub fn hypot<B: Broadcast<Self>>(self, other: B) -> Self

pub fn sinh(self) -> Self

pub fn tan(self) -> Self

pub fn tanh(self) -> Self

pub fn log2(self) -> Self

pub fn mul_add<A: Broadcast<Self>, B: Broadcast<Self>>(self, a: A, b: B) -> Self

pub fn exp(self) -> Self

pub fn powi<B: Broadcast<Vector<i32, N>>>(self, other: B) -> Self

pub fn ln(self) -> Self

pub fn powf<B: Broadcast<Self>>(self, other: B) -> Self

pub fn log<B: Broadcast<Self>>(self, other: B) -> Self

pub fn sin(self) -> Self

pub fn cos(self) -> Self

pub fn asinh(self) -> Self

pub fn acosh(self) -> Self

pub fn atanh(self) -> Self

pub fn floor(self) -> Self

pub fn ceil(self) -> Self

pub fn round(self) -> Self

pub fn trunc(self) -> Self

pub fn fract(self) -> Self

pub fn recip(self) -> Self

pub fn exp2(self) -> Self

pub fn log10(self) -> Self

pub fn sin_cos(self) -> (Self, Self)

pub fn exp_m1(self) -> Self

pub fn ln_1p(self) -> Self

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. Read more

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. Read more

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. Read more

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. Read more

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 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>

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, 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>

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

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. Read more

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. Read more

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. Read more

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. Read more

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. Read more

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. Read more

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

fn broadcast(self) -> Matrix<T, M, N>

Copy values along axes to get V.

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

fn broadcast(self) -> Self

Copy values along axes to get V.

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

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

Returns a copy of the value. Read more

1.0.0 · source

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

Performs copy-assignment from source. Read more

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. Read more

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

fn default() -> Self

Create vector filled with default values.

impl<T> Directional<Vector<T, 2_usize>> for Rotation2<T> where
Self: Transform<Vector<T, 2>>,

fn apply_dir(&self, pos: Vector<T, 2>, dir: Vector<T, 2>) -> Vector<T, 2>

Returns the result of the direction transformation at the specified position.

fn apply_normal(&self, pos: Vector<T, 2>, normal: Vector<T, 2>) -> Vector<T, 2>

Returns the result of the normal transformation at the specified position. Read more

impl<T> Directional<Vector<T, 3_usize>> for Rotation3<T> where
Self: Transform<Vector<T, 3>>,

fn apply_dir(&self, pos: Vector<T, 3>, dir: Vector<T, 3>) -> Vector<T, 3>

Returns the result of the direction transformation at the specified position.

fn apply_normal(&self, pos: Vector<T, 3>, normal: Vector<T, 3>) -> Vector<T, 3>

Returns the result of the normal transformation at the specified position. Read more

impl<T, const N: usize> Directional<Vector<T, N>> for Linear<T, N> where
    Self: Transform<Vector<T, N>>,
    T: Neg<Output = T> + Num + Copy,
    Vector<T, N>: Normalize,
    Matrix<T, N, N>: Inv<Output = Matrix<T, N, N>>,

fn apply_dir(&self, pos: Vector<T, N>, dir: Vector<T, N>) -> Vector<T, N>

Returns the result of the direction transformation at the specified position.

fn apply_normal(&self, _: Vector<T, N>, normal: Vector<T, N>) -> Vector<T, N>

Returns the result of the normal transformation at the specified position. Read more

impl<T, const N: usize> Directional<Vector<T, N>> for Shift<T, N> where
Self: Transform<Vector<T, N>>,

fn apply_dir(&self, _: Vector<T, N>, dir: Vector<T, N>) -> Vector<T, N>

Returns the result of the direction transformation at the specified position.

fn apply_normal(&self, _: Vector<T, N>, normal: Vector<T, N>) -> Vector<T, N>

Returns the result of the normal transformation at the specified position. Read more

impl<T, const N: usize> Directional<Vector<T, N>> for Scale<T> where
Self: Transform<Vector<T, N>>,

fn apply_dir(&self, _: Vector<T, N>, dir: Vector<T, N>) -> Vector<T, N>

Returns the result of the direction transformation at the specified position.

fn apply_normal(&self, _: Vector<T, N>, normal: Vector<T, N>) -> Vector<T, N>

Returns the result of the normal transformation at the specified position. Read more

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. Read more

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.

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. Read more

fn map<F, S>(self, func: F) -> DistMap<Self, F, T, S> where
F: Fn(T) -> S,

Create a distribution of values of ‘S’ by mapping the output of Self through the closure F Read more

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.

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. Read more

fn map<F, S>(self, func: F) -> DistMap<Self, F, T, S> where
F: Fn(T) -> S,

Create a distribution of values of ‘S’ by mapping the output of Self through the closure F Read more

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.

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. Read more

fn map<F, S>(self, func: F) -> DistMap<Self, F, T, S> where
F: Fn(T) -> S,

Create a distribution of values of ‘S’ by mapping the output of Self through the closure F Read more

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.

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. Read more

fn map<F, S>(self, func: F) -> DistMap<Self, F, T, S> where
F: Fn(T) -> S,

Create a distribution of values of ‘S’ by mapping the output of Self through the closure F Read more

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. Read more

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. Read more

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. Read more

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. Read more

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

Converts to this type from the input type.

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

Converts to this type from the input type.

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

Converts to this type from the input type.

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

fn from(vr: &'a Vector<T, N>) -> Self

Converts to this type from the input type.

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

Converts to this type from the input type.

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

fn from(vr: &'a mut 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(a: [T; N]) -> Self

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

fn from(vec: Vector<T, 2>) -> Self

Converts to this type from the input type.

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

fn from(vec: Vector<T, 3>) -> Self

Converts to this type from the input type.

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

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

Converts to this type from the input type.

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

fn from(vec: Vector<T, 4>) -> Self

Converts to this type from the input type.

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

fn from(pos: Vector<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(vec: Vector<T, N>) -> Self

Converts to this type from the input type.

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

Converts to this type from the input type.

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. Read more

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. Read more

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. Read more

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. Read more

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. Read more

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. Read more

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. Read more

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

Workaround for reverse multiplication.

type Output = Vector<f32, N>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

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

Workaround for reverse multiplication.

type Output = Vector<f64, N>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

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

Workaround for reverse multiplication.

type Output = Vector<i16, N>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

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

Workaround for reverse multiplication.

type Output = Vector<i32, N>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

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

Workaround for reverse multiplication.

type Output = Vector<i64, N>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

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

Workaround for reverse multiplication.

type Output = Vector<i8, N>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

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

Workaround for reverse multiplication.

type Output = Vector<u16, N>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

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

Workaround for reverse multiplication.

type Output = Vector<u32, N>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

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

Workaround for reverse multiplication.

type Output = Vector<u64, N>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

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

Workaround for reverse multiplication.

type Output = Vector<u8, N>

The resulting type after applying the * operator.

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

Performs the * operation. Read more

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. Read more

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. Read more

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. Read more

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> Normalize for Vector<T, N> where
T: Float,

fn normalize(self) -> Self

Normalize object.

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. Read more

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 ==. Read more

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

This method tests for !=.

impl<T: One + Mul, const N: usize> Product<Vector<T, N>> for Vector<T, N>

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

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

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. Read more

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. Read more

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. Read more

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. Read more

impl<T, const N: usize> Reorder<Linear<T, N>, Vector<T, N>> for Shift<T, N> where
Linear<T, N>: Transform<Vector<T, N>> + Copy,
Self: Transform<Vector<T, N>>,

fn reorder(self, other: Linear<T, N>) -> (Linear<T, N>, Shift<T, N>)

For given A and B returns B' and A'.

impl<T> Reorder<Rotation2<T>, Vector<T, 2_usize>> for Shift<T, 2> where
Rotation2<T>: Transform<Vector<T, 2>> + Copy,
Self: Transform<Vector<T, 2>>,

fn reorder(self, other: Rotation2<T>) -> (Rotation2<T>, Shift<T, 2>)

For given A and B returns B' and A'.

impl<T> Reorder<Rotation3<T>, Vector<T, 3_usize>> for Shift<T, 3> where
Rotation3<T>: Transform<Vector<T, 3>> + Copy,
Self: Transform<Vector<T, 3>>,

fn reorder(self, other: Rotation3<T>) -> (Rotation3<T>, Shift<T, 3>)

For given A and B returns B' and A'.

impl<T, const N: usize> Reorder<Scale<T>, Vector<T, N>> for Shift<T, N> where
Scale<T>: Transform<Vector<T, N>> + Copy,
Self: Transform<Vector<T, N>>,

fn reorder(self, other: Scale<T>) -> (Scale<T>, Shift<T, N>)

For given A and B returns B' and A'.

impl<T> Reorder<Shift<T, 2_usize>, Vector<T, 2_usize>> for Rotation2<T> where
Self: Transform<Vector<T, 2>>,
Shift<T, 2>: Transform<Vector<T, 2>>,

fn reorder(self, other: Shift<T, 2>) -> (Shift<T, 2>, Rotation2<T>)

For given A and B returns B' and A'.

impl<T> Reorder<Shift<T, 3_usize>, Vector<T, 3_usize>> for Rotation3<T> where
Self: Transform<Vector<T, 3>>,
Shift<T, 3>: Transform<Vector<T, 3>>,

fn reorder(self, other: Shift<T, 3>) -> (Shift<T, 3>, Rotation3<T>)

For given A and B returns B' and A'.

impl<T, const N: usize> Reorder<Shift<T, N>, Vector<T, N>> for Linear<T, N> where
Self: Transform<Vector<T, N>>,
Shift<T, N>: Transform<Vector<T, N>>,

fn reorder(self, other: Shift<T, N>) -> (Shift<T, N>, Linear<T, N>)

For given A and B returns B' and A'.

impl<T, const N: usize> Reorder<Shift<T, N>, Vector<T, N>> for Scale<T> where
Self: Transform<Vector<T, N>>,
Shift<T, N>: Transform<Vector<T, N>>,

fn reorder(self, other: Shift<T, N>) -> (Shift<T, N>, Scale<T>)

For given A and B returns B' and A'.

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. Read more

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. Read more

impl<T: Zero + Add, const N: usize> Sum<Vector<T, N>> for Vector<T, N>

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

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

impl<T> Transform<Vector<T, 2_usize>> for Rotation2<T> where
T: Neg<Output = T> + Num + Copy,

fn identity() -> Self

Identity transformation.

fn inv(self) -> Self

Inverse transformation.

fn apply(&self, pos: Vector<T, 2>) -> Vector<T, 2>

Perform the transformation itself.

fn deriv(&self, _pos: Vector<T, 2>, dir: Vector<T, 2>) -> Vector<T, 2>

Find transformation directional derivative at specified point.

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

Chain two transformations into a new one. Read more

impl<T> Transform<Vector<T, 3_usize>> for Rotation3<T> where
T: Neg<Output = T> + Num + Copy,

fn identity() -> Self

Identity transformation.

fn inv(self) -> Self

Inverse transformation.

fn apply(&self, pos: Vector<T, 3>) -> Vector<T, 3>

Perform the transformation itself.

fn deriv(&self, _pos: Vector<T, 3>, dir: Vector<T, 3>) -> Vector<T, 3>

Find transformation directional derivative at specified point.

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

Chain two transformations into a new one. Read more

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

fn identity() -> Self

Identity transformation.

fn inv(self) -> Self

Inverse transformation.

fn apply(&self, pos: Vector<T, N>) -> Vector<T, N>

Perform the transformation itself.

fn deriv(&self, _pos: Vector<T, N>, dir: Vector<T, N>) -> Vector<T, N>

Find transformation directional derivative at specified point.

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

Chain two transformations into a new one. Read more

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

fn identity() -> Self

Identity transformation.

fn inv(self) -> Self

Inverse transformation.

fn apply(&self, pos: Vector<T, N>) -> Vector<T, N>

Perform the transformation itself.

fn deriv(&self, _pos: Vector<T, N>, dir: Vector<T, N>) -> Vector<T, N>

Find transformation directional derivative at specified point.

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

Chain two transformations into a new one. Read more

impl<T, const N: usize> Transform<Vector<T, N>> for Scale<T> where
T: Num + Inv<Output = T> + Copy,

fn identity() -> Self

Identity transformation.

fn inv(self) -> Self

Inverse transformation.

fn apply(&self, pos: Vector<T, N>) -> Vector<T, N>

Perform the transformation itself.

fn deriv(&self, _pos: Vector<T, N>, dir: Vector<T, N>) -> Vector<T, N>

Find transformation directional derivative at specified point.

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

Chain two transformations into a new one. Read more

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. Read more

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

fn set_zero(&mut self)

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

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

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

Auto Trait Implementations

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

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

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

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

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

Blanket Implementations

impl<T> Any for T where
T: 'static + ?Sized,

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<T> Borrow<T> for T where
T: ?Sized,

const: unstable · source

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for T where
T: ?Sized,

const: unstable · source

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

impl<T, const M: usize, const N: usize> Broadcast<Matrix<T, M, N>> for T where
T: Copy,

fn broadcast(self) -> Matrix<T, M, N>

Copy values along axes to get V.

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

fn broadcast(self) -> Vector<T, N>

Copy values along axes to get V.

impl<T> From<T> for T

const: unstable · source

fn from(t: T) -> T

Returns the argument unchanged.

impl<T, U> Into<U> for T where
U: From<T>,

const: unstable · source

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

impl<T> ToOwned for T where
T: Clone,

type Owned = T

The resulting type after obtaining ownership.

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

fn clone_into(&self, target: &mut T)

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

Uses borrowed data to replace owned data, usually by cloning. Read more

impl<T> ToString for T where
T: Display + ?Sized,

default fn to_string(&self) -> String

Converts the given value to a String. Read more

impl<T, U> TryFrom<U> for T where
U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

const: unstable · source

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.

impl<T, U> TryInto<U> for T where
U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

const: unstable · source

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.

impl<V, T> VZip<V> for T where
V: MultiLane<T>,

fn vzip(self) -> V

impl<T, Rhs> NumAssignOps<Rhs> for T where
T: AddAssign<Rhs> + SubAssign<Rhs> + MulAssign<Rhs> + DivAssign<Rhs> + RemAssign<Rhs>,

impl<T, Rhs, Output> NumOps<Rhs, Output> for T where
T: Mul<Rhs, Output = Output> + Div<Rhs, Output = Output> + Rem<Rhs, Output = Output> + Add<Rhs, Output = Output> + Sub<Rhs, Output = Output>,