Struct Vect 

#[repr(transparent)]
pub struct Vect<const N: usize, S>(pub [S; N]);

Tuple Fields

0: [S; N]

Implementations

impl<S: Field> Vect<4, S>

pub fn point(position: Vect<3, S>) -> Self

pub fn point_at_inf(direction: Nrml<3, S>) -> Self

impl<S: Ring, const N: usize> Vect<N, S>

pub const ZERO: Self

pub const fn axis(i: usize, value: S) -> Self

pub const fn splat(s: S) -> Self

pub fn from_fn<F: Fn(usize) -> S>(f: F) -> Self

pub fn swiz<const M: usize>(self, f: impl Fn([S; N]) -> [S; M]) -> Vect<M, S>

pub fn map<T: Ring>(self, f: impl Fn(S) -> T) -> Vect<N, T>

pub fn scale(self, other: Self) -> Self

pub fn zero_extend<const M: usize>(self, i: usize) -> Vect<M, S>

where S: Sized,

pub fn is_nan(self) -> bool

pub fn is_finite(self) -> bool

impl<const N: usize> Vect<N, f32>

pub fn to_f64(self) -> Vect<N, f64>

impl<const N: usize> Vect<N, f64>

pub fn to_f32(self) -> Vect<N, f32>

impl<S: Ring, const N: usize> Vect<N, S>

pub fn sqr_magn(self) -> S

impl<S: Field, const N: usize> Vect<N, S>

pub fn magn(self) -> S

pub fn normal(self) -> Option<Nrml<N, S>>

pub fn normal_or_zero(self) -> Vect<N, S>

pub fn magn_normal(self) -> Option<(S, Nrml<N, S>)>

pub fn magn_normal_or_zero(self) -> (S, Vect<N, S>)

pub fn divide_by_infinity(self) -> Option<Vect<N, S>>

impl<S: Field> Vect<1, S>

pub fn x(self) -> S

impl<S: Field> Vect<2, S>

pub fn x(self) -> S

pub fn y(self) -> S

impl<S: Field> Vect<3, S>

pub fn x(self) -> S

pub fn y(self) -> S

pub fn z(self) -> S

impl<S: Field> Vect<4, S>

pub fn x(self) -> S

pub fn y(self) -> S

pub fn z(self) -> S

pub fn w(self) -> S

Trait Implementations

impl<S: Field, const N: usize> Add<Nrml<N, S>> for Vect<N, S>

type Output = Vect<N, S>

The resulting type after applying the + operator.

fn add(self, rhs: Nrml<N, S>) -> Self::Output

Performs the + operation.

impl<S: Field, const N: usize> Add<Vect<N, S>> for Nrml<N, S>

type Output = Vect<N, S>

The resulting type after applying the + operator.

fn add(self, rhs: Vect<N, S>) -> Self::Output

Performs the + operation.

impl<S: Ring, const N: usize> Add for Vect<N, S>

type Output = Vect<N, S>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<S: Ring, const N: usize> AddAssign for Vect<N, S>

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<const N: usize, S: Field> Apl<Vect<N, S>> for Rig<N, S>

where (): RotDim<N>,

type Output = Vect<N, S>

fn apl(self, other: Vect<N, S>) -> Vect<N, S>

impl<const N: usize, S: Field> Apl<Vect<N, S>> for Rot<N, S>

where (): RotDim<N>,

type Output = Vect<N, S>

fn apl(self, other: Vect<N, S>) -> Self::Output

impl<const N: usize, S: Clone> Clone for Vect<N, S>

fn clone(&self) -> Vect<N, S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<S: Field, const N: usize> Cross<Nrml<N, S>> for Vect<N, S>

where Self: Cross,

type Output = <Vect<N, S> as Cross>::Output

fn cross(self, other: Nrml<N, S>) -> Self::Output

impl<S: Field, const N: usize> Cross<Vect<N, S>> for Nrml<N, S>

where Vect<N, S>: Cross,

type Output = <Vect<N, S> as Cross>::Output

fn cross(self, other: Vect<N, S>) -> Self::Output

impl<S: Field> Cross for Vect<2, S>

type Output = Vect<1, S>

fn cross(self, other: Self) -> Vect<1, S>

impl<S: Field> Cross for Vect<3, S>

type Output = Vect<3, S>

fn cross(self, other: Self) -> Vect<3, S>

impl<S: Ring + Debug, const N: usize> Debug for Vect<N, S>

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

Formats the value using the given formatter.

impl<const N: usize, S: Ring> Default for Vect<N, S>

fn default() -> Self

Returns the “default value” for a type.

impl<S: Ring + Display, const N: usize> Display for Vect<N, S>

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

Formats the value using the given formatter.

impl<S: Ring, const N: usize> Div<S> for Vect<N, S>

type Output = Vect<N, S>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<S: Ring, const N: usize> DivAssign<S> for Vect<N, S>

fn div_assign(&mut self, rhs: S)

Performs the /= operation.

impl<S: Field, const N: usize> Dot<Nrml<N, S>> for Vect<N, S>

type Output = S

fn dot(self, other: Nrml<N, S>) -> S

impl<S: Field, const N: usize> Dot<Vect<N, S>> for Nrml<N, S>

type Output = S

fn dot(self, other: Vect<N, S>) -> S

impl<S: Ring, const N: usize> Dot<Vect<N, S>> for Vect<N, S>

type Output = S

fn dot(self, other: Self) -> Self::Output

impl<S: Field, const N: usize> From<Nrml<N, S>> for Vect<N, S>

fn from(value: Nrml<N, S>) -> Self

Converts to this type from the input type.

impl<const N: usize, S: Hash> Hash for Vect<N, S>

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<S: Ring, const N: usize> Index<RangeFull> for Vect<N, S>

type Output = [S]

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<S: Ring, const N: usize> Index<usize> for Vect<N, S>

type Output = S

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<S: Ring, const N: usize> IndexMut<usize> for Vect<N, S>

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

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

impl<S: Field, const N: usize, const M: usize> Mul<Mat<N, M, S>> for Vect<N, S>

type Output = Vect<N, S>

The resulting type after applying the * operator.

fn mul(self, matrix: Mat<N, M, S>) -> Self::Output

Performs the * operation.

impl<S: Ring, const N: usize> Mul<S> for Vect<N, S>

type Output = Vect<N, S>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<S: Field, const N: usize, const M: usize> Mul<Vect<M, S>> for Mat<N, M, S>

type Output = Vect<N, S>

The resulting type after applying the * operator.

fn mul(self, vector: Vect<M, S>) -> Self::Output

Performs the * operation.

impl<S: Ring, const N: usize> MulAssign<S> for Vect<N, S>

fn mul_assign(&mut self, rhs: S)

Performs the *= operation.

impl<S: Ring, const N: usize> Neg for Vect<N, S>

type Output = Vect<N, S>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<const N: usize, S: PartialEq> PartialEq for Vect<N, S>

fn eq(&self, other: &Vect<N, S>) -> 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<S: Field, const N: usize> ProjRej<Nrml<N, S>> for Vect<N, S>

type Output = Vect<N, S>

fn proj(self, axis: Nrml<N, S>) -> Self

fn rej(self, axis: Nrml<N, S>) -> Self

fn proj_rej(self, axis: Nrml<N, S>) -> (Self, Self)

impl<S: Field, const N: usize> ProjRej<Option<Nrml<N, S>>> for Vect<N, S>

type Output = Vect<N, S>

fn proj(self, axis: Option<Nrml<N, S>>) -> Self

fn rej(self, axis: Option<Nrml<N, S>>) -> Self

fn proj_rej(self, axis: Option<Nrml<N, S>>) -> (Self, Self)

impl<S: Field, const N: usize> ProjRej<Vect<N, S>> for Vect<N, S>

type Output = Vect<N, S>

fn proj(self, axis: Vect<N, S>) -> Self::Output

fn rej(self, axis: Vect<N, S>) -> Self::Output

fn proj_rej(self, axis: Vect<N, S>) -> (Self::Output, Self::Output)

impl<S: Field, const N: usize> Refl<Nrml<N, S>> for Vect<N, S>

type Output = Vect<N, S>

fn refl(self, axis: Nrml<N, S>) -> Self::Output

impl<S: Field, const N: usize> Refl<Option<Nrml<N, S>>> for Vect<N, S>

type Output = Vect<N, S>

fn refl(self, axis: Option<Nrml<N, S>>) -> Self::Output

impl<S: Field, const N: usize> Refl<Vect<N, S>> for Vect<N, S>

type Output = Vect<N, S>

fn refl(self, axis: Vect<N, S>) -> Self::Output

impl<S: Field, const N: usize> Sub<Nrml<N, S>> for Vect<N, S>

type Output = Vect<N, S>

The resulting type after applying the - operator.

fn sub(self, rhs: Nrml<N, S>) -> Self::Output

Performs the - operation.

impl<S: Field, const N: usize> Sub<Vect<N, S>> for Nrml<N, S>

type Output = Vect<N, S>

The resulting type after applying the - operator.

fn sub(self, rhs: Vect<N, S>) -> Self::Output

Performs the - operation.

impl<S: Ring, const N: usize> Sub for Vect<N, S>

type Output = Vect<N, S>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<S: Ring, const N: usize> SubAssign for Vect<N, S>

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<S: Ring, const N: usize> Sum for Vect<N, S>

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

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

impl<const N: usize, S: Copy> Copy for Vect<N, S>

impl<const N: usize, S: Eq> Eq for Vect<N, S>

impl<const N: usize, S> StructuralPartialEq for Vect<N, S>