Struct Vector 

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

Implementations

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

pub const fn new(data: [T; N]) -> Self

pub fn pure(x: T) -> Self

where T: Clone,

pub const fn const_pure(x: T) -> Self

where T: Copy,

pub fn gen<F>(f: F) -> Self

where F: Fn(usize) -> T,

pub fn dot(self, rhs: Vector<T, N>) -> T

where T: Mul<T, Output = T> + Sum,

pub fn mag_sq(self) -> T

where T: Mul<T, Output = T> + Sum + Clone,

pub fn mag(self) -> T

where T: Float + Sum,

pub fn normalised(self) -> Self

where T: Float + Sum,

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

where F: Fn(T) -> U,

pub fn map_mut<F>(&mut self, f: F)

where F: Fn(&mut T),

pub fn apply<F, U, V>(self, f: F, rhs: Vector<U, N>) -> Vector<V, N>

where F: Fn(T, U) -> V,

pub fn apply_mut<F, U>(&mut self, f: F, rhs: Vector<U, N>)

where F: Fn(&mut T, U),

pub fn into_iter(self) -> <Self as IntoIterator>::IntoIter

pub fn iter(&self) -> <&Self as IntoIterator>::IntoIter

pub fn iter_mut(&mut self) -> <&mut Self as IntoIterator>::IntoIter

impl<T> Vector<T, 1>

pub const fn new1(x: T) -> Self

pub const fn x(&self) -> &T

impl<T> Vector<T, 2>

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

pub const fn x(&self) -> &T

pub const fn y(&self) -> &T

impl<T> Vector<T, 3>

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

pub const fn x(&self) -> &T

pub const fn y(&self) -> &T

pub const fn z(&self) -> &T

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

where T: Mul<T, Output = T> + Add<T, Output = T> + Sub<T, Output = T> + Neg<Output = T> + Clone,

impl<T> Vector<T, 4>

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

pub const fn x(&self) -> &T

pub const fn y(&self) -> &T

pub const fn z(&self) -> &T

pub const fn w(&self) -> &T

Trait Implementations

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

where T: Add<T, Output = T>,

type Output = Vector<T, N>

The resulting type after applying the + operator.

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

Performs the + operation.

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

where T: AddAssign<T>,

fn add_assign(&mut self, rhs: Vector<T, N>)

Performs the += operation.

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

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

where T: ConstOne + Copy,

const ONE: Self

The multiplicative identity element of Self, 1.

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

where T: ConstZero + Copy,

const ZERO: Self

The additive identity element of Self, 0.

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

where T: Div<T, Output = T> + Clone,

type Output = Vector<T, N>

The resulting type after applying the / operator.

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

Performs the / operation.

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

where T: Div<T, Output = T>,

type Output = Vector<T, N>

The resulting type after applying the / operator.

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

Performs the / operation.

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

where T: DivAssign<T> + Clone,

fn div_assign(&mut self, rhs: T)

Performs the /= operation.

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

where T: DivAssign<T>,

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

Performs the /= operation.

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

fn from(value: Matrix<T, N, 1>) -> Self

Converts to this type from the input type.

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

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

Converts to this type from the input type.

impl From<Vector<f64, 3>> for Colour

fn from(v: Vector<f64, 3>) -> Self

Converts to this type from the input type.

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

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

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

type Output = T

The returned type after indexing.

fn index(&self, index: 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, index: usize) -> &mut Self::Output

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<T, Output = T> + Clone,

type Output = Vector<T, N>

The resulting type after applying the * operator.

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

Performs the * operation.

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

where T: Clone + Mul<T, Output = T> + Sum,

type Output = Vector<T, M>

The resulting type after applying the * operator.

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

Performs the * operation.

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

where T: Mul<T, Output = T>,

type Output = Vector<T, N>

The resulting type after applying the * operator.

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

Performs the * operation.

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

where T: MulAssign + Clone,

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

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

where T: MulAssign,

fn mul_assign(&mut self, rhs: 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> One for Vector<T, N>

where T: One + Clone,

fn one() -> Self

Returns the multiplicative identity element of Self, 1.

fn set_one(&mut self)

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

fn is_one(&self) -> bool

where Self: PartialEq,

Returns true if self is equal to the multiplicative identity.

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

where T: Sub<T, Output = T>,

type Output = Vector<T, N>

The resulting type after applying the - operator.

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

Performs the - operation.

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

where T: SubAssign<T>,

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

Performs the -= operation.

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

where T: Add<T, Output = T> + Zero + Clone,

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

where T: Zero + Clone,

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

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