Struct quick_maths::Vector

pub struct Vector<const N: usize, T = DefaultFloat>(pub [T; N]);

Vector over floats and a const-size. Often used through Vec2, Vec3, and Vec4 instead of the raw struct.

Implementations

impl<T: Float> Vector<4_usize, T>

pub fn conj(self) -> Self

pub fn is_unit(&self) -> bool

pub fn scale(&self, factor: T) -> Self

Encodes a scaling factor into the quaternion

pub fn rot(along: &Vec3<T>) -> Self

Returns a quaternion which is a rotation in the 3 dimensions given

pub fn quat_mul(self, o: Self) -> Self

impl<T: Float> Vector<3_usize, T>

pub fn to_quat(&self) -> Quat<T>

pub fn apply_quat(&self, q: &Quat<T>) -> Self

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

pub fn of(v: T) -> Self

Creates a vector of the value v (every element = v).

pub fn apply_fn<F, S>(self, f: F) -> Vector<N, S> where
    F: FnMut(T) -> S, 

Applies this function to every vector value.

pub fn cast<S: From<T>>(self) -> Vector<N, S>

pub fn x(&self) -> T

X component of this vector, panics if out of range

pub fn y(&self) -> T

Y component of this vector, panics if out of range

pub fn z(&self) -> T

Z component of this vector, panics if out of range

pub fn w(&self) -> T

W componenent of this vector, panics if out of range

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

pub fn with<F>(f: F) -> Self where
    F: FnMut(usize) -> T, 

pub fn iter(&self) -> impl Iterator<Item = &T>

pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut T>

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

pub fn extend<const M: usize>(&self, v: T) -> Vector<M, T>

Extend this vector to a larger vector. Must increase the size of the vector or keep it the same size.

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

pub fn linspace(a: T, b: T) -> Self

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

Takes the dot product of two vectors

pub fn sqr_magn(&self) -> T

Computes the sqr_magnitude of the vector

pub fn magn(&self) -> T

Takes the magnitude of the vector

pub fn norm(&self) -> Self

Returns a unit vector in the same direction as self. Consider division instead of calling this method if you need efficiency.

pub fn cos_similarity(&self, o: &Self) -> T

pub fn reflect(&self, across: &Self) -> Self

pub fn refract(&self, norm: &Self, eta: T) -> Option<Self>

pub fn from_str_radix(
    strs: [&str; N],
    radix: u32
) -> Result<Self, T::FromStrRadixErr>

Computes a vector from a list of strings.

pub fn lerp(&self, v: &Self, alpha: T) -> Self

Linearly interpolates from self to v according to alpha, where 0 => self, and 1 => v.

pub fn max_component(&self) -> usize

Computes the max component of this vector

pub fn min_component(&self) -> usize

Computes the minimum component of this vector

pub fn clamp(&mut self, min: T, max: T)

Clamps self between min and max

pub fn dist(&self, o: &Self) -> T

pub fn reduce<const M: usize>(&self) -> Vector<M, T>

Shrink this vector to a lower dimension Must lower or keep the same size.

pub fn sift(&self, o: &Self) -> (Self, Self)

Takes the minimal and maximal elements from self and o and returns those vectors

pub fn project_onto(&self, onto: &Self) -> Self

pub fn col_vector(self) -> Matrix<N, 1, T>

pub fn row_vector(self) -> Matrix<1, N, T>

pub fn bisector(&self, o: &Self) -> Self

Computes the bisector of two vectors = (a,b) => |a|*b + |b|*a;

pub fn convolve<const M: usize>(&self, o: &Vector<M, T>) -> Self

Convolves self with other, returning a vector of the same size

pub fn scatter_fn<S: Copy, const M: usize>(
    &self,
    idx: &Vector<N, usize>,
    base: S,
    acc: impl Fn(S, T) -> S
) -> Vector<M, S>

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

pub fn any(&self) -> bool

pub fn all(&self) -> bool

impl<T> Vector<3_usize, T>

pub const fn new(a: T, b: T, c: T) -> Self

impl<T: Float> Vector<3_usize, T>

pub fn cross(&self, o: &Self) -> Self

Takes the cross product of self with other

pub fn sided(&self, o: &Self, normal: &Self) -> bool

Whether or not self is aligned on the right or left hand side of normal w.r.t o.

pub fn homogeneous(&self) -> Vec4<T>

Returns the homogeneous form of this vector.

pub fn homogenize(&self) -> Vec2<T>

impl<T> Vector<2_usize, T>

pub const fn new(a: T, b: T) -> Self

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

pub fn flip(&self) -> Self

impl<T: Float> Vector<2_usize, T>

pub fn rot(&self, theta: T) -> Self

Rotates this vector around the origin by theta (in radians)

pub fn signed_angle(&self, dst: &Self) -> T

pub fn perp(&self) -> Self

pub fn homogeneous(&self) -> Vec3<T>

impl<T> Vector<4_usize, T>

pub const fn new(a: T, b: T, c: T, w: T) -> Self

impl<T: Float> Vector<4_usize, T>

pub fn homogenize(&self) -> Vec3<T>

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

pub fn cos(&self) -> Self

Element-wise cos .

pub fn sin(&self) -> Self

Element-wise sin .

pub fn tan(&self) -> Self

Element-wise tan .

pub fn acos(&self) -> Self

Element-wise acos .

pub fn asin(&self) -> Self

Element-wise asin .

pub fn atan(&self) -> Self

Element-wise atan .

pub fn acosh(&self) -> Self

Element-wise acosh .

pub fn asinh(&self) -> Self

Element-wise asinh .

pub fn atanh(&self) -> Self

Element-wise atanh .

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

pub fn atan2(&self, v: T) -> Self

Element-wise atan2 .

pub fn hypot(&self, v: T) -> Self

Element-wise hypot .

pub fn ceil(&self) -> Self

Element-wise ceil .

pub fn floor(&self) -> Self

Element-wise floor .

pub fn round(&self) -> Self

Element-wise round .

pub fn fract(&self) -> Self

Element-wise fract .

pub fn trunc(&self) -> Self

Element-wise trunc .

pub fn abs(&self) -> Self

Element-wise abs .

pub fn signum(&self) -> Self

Element-wise signum .

pub fn abs_sub(&self, v: T) -> Self

Element-wise abs_sub .

pub fn is_sign_positive(&self) -> Vector<N, bool>

pub fn is_sign_negative(&self) -> Vector<N, bool>

pub fn recip(&self) -> Self

Element-wise recip .

pub fn log2(&self) -> Self

Element-wise log2 .

pub fn log10(&self) -> Self

Element-wise log10 .

pub fn ln(&self) -> Self

Element-wise ln .

pub fn ln_1p(&self) -> Self

Element-wise ln_1p .

pub fn exp(&self) -> Self

Element-wise exp .

pub fn exp2(&self) -> Self

Element-wise exp2 .

pub fn exp_m1(&self) -> Self

Element-wise exp_m1 .

pub fn sqrt(&self) -> Self

Element-wise sqrt .

pub fn cbrt(&self) -> Self

Element-wise cbrt .

pub fn powf(&self, v: T) -> Self

Element-wise powf .

pub fn powi(&self, v: i32) -> Self

pub fn log(&self, v: T) -> Self

Element-wise log .

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

Element-wise max .

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

Element-wise min .

pub fn to_degrees(&self) -> Self

Element-wise to_degrees .

pub fn to_radians(&self) -> Self

Element-wise to_radians .

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

pub fn dyn_tensor(self) -> DynTensor<1, T>

Trait Implementations

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

type Output = Vector<N, T::Output>

The resulting type after applying the + operator.

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

Performs the + operation.

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

type Output = Vector<N, T::Output>

The resulting type after applying the + operator.

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

Performs the + operation.

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

fn add_assign(&mut self, o: T)

Performs the += operation.

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

fn add_assign(&mut self, o: Self)

Performs the += operation.

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

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

Performs the conversion.

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

type Output = Vector<N, T::Output>

The resulting type after applying the & operator.

fn bitand(self, o: T) -> Self::Output

Performs the & operation.

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

type Output = Vector<N, T::Output>

The resulting type after applying the & operator.

fn bitand(self, o: Self) -> Self::Output

Performs the & operation.

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

fn bitand_assign(&mut self, o: T)

Performs the &= operation.

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

fn bitand_assign(&mut self, o: Self)

Performs the &= operation.

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

type Output = Vector<N, T::Output>

The resulting type after applying the | operator.

fn bitor(self, o: T) -> Self::Output

Performs the | operation.

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

type Output = Vector<N, T::Output>

The resulting type after applying the | operator.

fn bitor(self, o: Self) -> Self::Output

Performs the | operation.

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

fn bitor_assign(&mut self, o: T)

Performs the |= operation.

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

fn bitor_assign(&mut self, o: Self)

Performs the |= operation.

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

type Output = Vector<N, T::Output>

The resulting type after applying the ^ operator.

fn bitxor(self, o: T) -> Self::Output

Performs the ^ operation.

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

type Output = Vector<N, T::Output>

The resulting type after applying the ^ operator.

fn bitxor(self, o: Self) -> Self::Output

Performs the ^ operation.

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

fn bitxor_assign(&mut self, o: T)

Performs the ^= operation.

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

fn bitxor_assign(&mut self, o: Self)

Performs the ^= operation.

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

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

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

Formats the value using the given formatter.

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

type Output = Vector<N, T::Output>

The resulting type after applying the / operator.

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

Performs the / operation.

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

type Output = Vector<N, T::Output>

The resulting type after applying the / operator.

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

Performs the / operation.

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

fn div_assign(&mut self, o: T)

Performs the /= operation.

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

fn div_assign(&mut self, o: Self)

Performs the /= operation.

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

impl<R: SliceIndex<[T]>, T, const N: usize> Index<R> for Vector<N, T>

type Output = R::Output

The returned type after indexing.

fn index(&self, r: R) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<R: SliceIndex<[T]>, T, const N: usize> IndexMut<R> for Vector<N, T>

fn index_mut(&mut self, i: R) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

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

type Output = Vector<N, T::Output>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Vector<N, T::Output>

The resulting type after applying the * operator.

fn mul(self, o: Self) -> Self::Output

Performs the * operation.

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

fn mul_assign(&mut self, o: T)

Performs the *= operation.

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

fn mul_assign(&mut self, o: Self)

Performs the *= operation.

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

type Output = Self

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

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

type Output = Self

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

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

fn one() -> Self

Returns the multiplicative identity element of Self, 1.

fn is_one(&self) -> bool

Returns true if self is equal to the multiplicative identity.

fn set_one(&mut self)

Sets self to the multiplicative identity element of Self, 1.

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

fn cmp(&self, other: &Vector<N, T>) -> Ordering

This method returns an [Ordering] between self and other.

#[must_use]fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]fn clamp(self, min: Self, max: Self) -> Self

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

Restrict a value to a certain interval.

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

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

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

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

This method tests for !=.

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

fn partial_cmp(&self, other: &Vector<N, T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

This method tests less than (for self and other) and is used by the < operator.

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

This method tests less than or equal to (for self and other) and is used by the <= operator.

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

This method tests greater than (for self and other) and is used by the > operator.

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

This method tests greater than or equal to (for self and other) and is used by the >= operator.

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

type Output = Vector<N, T::Output>

The resulting type after applying the % operator.

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

Performs the % operation.

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

type Output = Vector<N, T::Output>

The resulting type after applying the % operator.

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

Performs the % operation.

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

fn rem_assign(&mut self, o: T)

Performs the %= operation.

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

fn rem_assign(&mut self, o: Self)

Performs the %= operation.

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

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

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

type Output = Vector<N, T::Output>

The resulting type after applying the - operator.

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

Performs the - operation.

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

type Output = Vector<N, T::Output>

The resulting type after applying the - operator.

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

Performs the - operation.

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

fn sub_assign(&mut self, o: T)

Performs the -= operation.

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

fn sub_assign(&mut self, o: Self)

Performs the -= operation.

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

fn zero() -> Self

Returns the additive identity element of Self, 0. # Purity

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.