Struct Vector 

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

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

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

The inverse of AbsDiffEq::abs_diff_eq.

impl<T, const N: usize> Add 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 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]

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 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 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 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 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 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 for Vector<T, N>

where T: BitXorAssign,

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

Performs the ^= operation.

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 duplicate of the value.

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

Performs copy-assignment from source.

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> Directional<Vector<T, 2>> 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.

impl<T> Directional<Vector<T, 3>> 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.

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.

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.

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.

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

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

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

where F: Fn(T) -> S, Self: Sized,

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

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

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

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

where F: Fn(T) -> S, Self: Sized,

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

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

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

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

where F: Fn(T) -> S, Self: Sized,

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

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

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

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

where F: Fn(T) -> S, Self: Sized,

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

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 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 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 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<'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<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 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)> for Vector<T, 2>

fn from(tuple: (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, T, T)> for Vector<T, 4>

fn from(tuple: (T, T, 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>> for (T, T)

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

impl<T> From<Vector<T, 3>> 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>> for (T, T, T, T)

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

Converts to this type from the input type.

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

fn from(vec: Vector4<T>) -> 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 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 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.

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

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.

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.

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.

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.

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.

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.

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.

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.

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.

impl<T, const N: usize> Mul 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 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> 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.

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 for Vector<T, N>

fn eq(&self, other: &Vector<T, N>) -> 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: One + Mul, const N: usize> Product for Vector<T, N>

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

Takes an iterator and generates Self from the elements by multiplying the items.

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 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 for Vector<T, N>

where T: RemAssign,

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

Performs the %= operation.

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>> 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>> 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>, Vector<T, 2>> 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>, Vector<T, 3>> 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 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 for Vector<T, N>

where T: SubAssign,

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

Performs the -= operation.

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

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

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<T> Transform<Vector<T, 2>> 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.

impl<T> Transform<Vector<T, 3>> 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.

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.

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.

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.

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.

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>