Struct quick_maths::Vector

pub struct Vector<T = DefaultFloat, const N: usize>(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<T, 4usize>

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<T, 3usize>

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

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

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

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<S, N> where
    F: FnMut(T) -> S, 

Applies this function to every vector value.

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

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

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

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 zxtend<const M: usize>(&self) -> Vector<T, M>

Zero-extend this vector to a larger vector. Must increase the size of the vector or keep it the same size.

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

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

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

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

pub fn any(&self) -> bool

pub fn all(&self) -> bool

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

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

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

Takes the cross product of self with other

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

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

Returns the homogeneous form of this vector.

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

pub fn x(&self) -> T

X component of this vector

pub fn y(&self) -> T

Y component of this vector

pub fn z(&self) -> T

Z component of this vector

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

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

pub fn x(&self) -> T

pub fn y(&self) -> T

pub fn flip(&self) -> Self

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

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

pub fn perp(&self) -> Self

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

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

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

pub fn x(&self) -> T

pub fn y(&self) -> T

pub fn z(&self) -> T

pub fn w(&self) -> T

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

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

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 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 abs_sub(&self, v: T) -> Self

Element-wise abs_sub .

pub fn signum(&self) -> Self

Element-wise signum .

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

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

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 .

Trait Implementations

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

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

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

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

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

fn add_assign(&mut self, o: T)

Performs the += operation.

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

fn add_assign(&mut self, o: Self)

Performs the += operation.

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

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

Performs the conversion.

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

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

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

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

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

fn bitand_assign(&mut self, o: T)

Performs the &= operation.

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

fn bitand_assign(&mut self, o: Self)

Performs the &= operation.

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

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

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

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

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

fn bitor_assign(&mut self, o: T)

Performs the |= operation.

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

fn bitor_assign(&mut self, o: Self)

Performs the |= operation.

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

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

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

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

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

fn bitxor_assign(&mut self, o: T)

Performs the ^= operation.

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

fn bitxor_assign(&mut self, o: Self)

Performs the ^= operation.

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

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

Immutably borrows from an owned value.

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

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

Mutably borrows from an owned value.

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

fn clone(&self) -> Self

Returns a copy of the value.

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: Debug, const N: usize> Debug for Vector<T, N>

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

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

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

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

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

fn div_assign(&mut self, o: T)

Performs the /= operation.

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

fn div_assign(&mut self, o: Self)

Performs the /= operation.

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

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

type Output = T

The returned type after indexing.

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

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 Self::Output

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

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

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

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

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

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

fn mul_assign(&mut self, o: T)

Performs the *= operation.

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

fn mul_assign(&mut self, o: Self)

Performs the *= operation.

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

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

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

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<T: Ord, const N: usize> Ord for Vector<T, N>

fn cmp(&self, o: &Self) -> 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<T: PartialEq, const N: usize> PartialEq<Vector<T, N>> for Vector<T, N>

fn eq(&self, o: &Self) -> bool

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

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

This method tests for !=.

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

fn partial_cmp(&self, o: &Self) -> Option<Ordering>

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

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

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

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

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

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

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

#[must_use]fn ge(&self, other: &Rhs) -> 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<T, N>

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

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

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

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

fn rem_assign(&mut self, o: T)

Performs the %= operation.

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

fn rem_assign(&mut self, o: Self)

Performs the %= operation.

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

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

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

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

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

fn sub_assign(&mut self, o: T)

Performs the -= operation.

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

fn sub_assign(&mut self, o: Self)

Performs the -= operation.

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

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.