Struct NdVector 

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

Numeric primitive for attribute values, and the trait exposing default() on the encoder configs. An array of N elements of type T, where T is often a DataValue, which is a trait that defines the basic mathematical operations and properties for the elements of the vector. This means that NdVector can be used to represent vectors in N-dimensional space (or a free module) over T. The vector operations for this type are implemented on a static basis, meaning that the operations are defined for a fixed number of dimensions at compile time without looping over N elements.

Implementations

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

where T: Float,

pub fn normalize(self) -> NdVector<N, T>

pub fn norm(self) -> T

Trait Implementations

impl<T> Add for NdVector<1, T>

where T: Add<Output = T> + AddAssign + Copy,

type Output = NdVector<1, T>

The resulting type after applying the + operator.

fn add(self, rhs: NdVector<1, T>) -> <NdVector<1, T> as Add>::Output

Performs the + operation.

impl<T> Add for NdVector<2, T>

where T: Add<Output = T> + AddAssign + Copy,

type Output = NdVector<2, T>

The resulting type after applying the + operator.

fn add(self, rhs: NdVector<2, T>) -> <NdVector<2, T> as Add>::Output

Performs the + operation.

impl<T> Add for NdVector<3, T>

where T: Add<Output = T> + AddAssign + Copy,

type Output = NdVector<3, T>

The resulting type after applying the + operator.

fn add(self, rhs: NdVector<3, T>) -> <NdVector<3, T> as Add>::Output

Performs the + operation.

impl<T> Add for NdVector<4, T>

where T: Add<Output = T> + AddAssign + Copy,

type Output = NdVector<4, T>

The resulting type after applying the + operator.

fn add(self, rhs: NdVector<4, T>) -> <NdVector<4, T> as Add>::Output

Performs the + operation.

impl<T> AddAssign for NdVector<1, T>

where T: AddAssign + Copy,

fn add_assign(&mut self, rhs: NdVector<1, T>)

Performs the += operation.

impl<T> AddAssign for NdVector<2, T>

where T: AddAssign + Copy,

fn add_assign(&mut self, rhs: NdVector<2, T>)

Performs the += operation.

impl<T> AddAssign for NdVector<3, T>

where T: AddAssign + Copy,

fn add_assign(&mut self, rhs: NdVector<3, T>)

Performs the += operation.

impl<T> AddAssign for NdVector<4, T>

where T: AddAssign + Copy,

fn add_assign(&mut self, rhs: NdVector<4, T>)

Performs the += operation.

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

where T: Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

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

where T: Copy,

impl<const N: usize, T> Cross for NdVector<N, T>

where T: DataValue,

fn cross(self, other: NdVector<N, T>) -> NdVector<N, T>

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

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Div<T> for NdVector<1, T>

where T: Div<Output = T> + DivAssign + Copy,

type Output = NdVector<1, T>

The resulting type after applying the / operator.

fn div(self, rhs: T) -> <NdVector<1, T> as Div<T>>::Output

Performs the / operation.

impl<T> Div<T> for NdVector<2, T>

where T: Div<Output = T> + DivAssign + Copy,

type Output = NdVector<2, T>

The resulting type after applying the / operator.

fn div(self, rhs: T) -> <NdVector<2, T> as Div<T>>::Output

Performs the / operation.

impl<T> Div<T> for NdVector<3, T>

where T: Div<Output = T> + DivAssign + Copy,

type Output = NdVector<3, T>

The resulting type after applying the / operator.

fn div(self, rhs: T) -> <NdVector<3, T> as Div<T>>::Output

Performs the / operation.

impl<T> Div<T> for NdVector<4, T>

where T: Div<Output = T> + DivAssign + Copy,

type Output = NdVector<4, T>

The resulting type after applying the / operator.

fn div(self, rhs: T) -> <NdVector<4, T> as Div<T>>::Output

Performs the / operation.

impl<T> DivAssign<T> for NdVector<1, T>

where T: DivAssign + Copy,

fn div_assign(&mut self, rhs: T)

Performs the /= operation.

impl<T> DivAssign<T> for NdVector<2, T>

where T: DivAssign + Copy,

fn div_assign(&mut self, rhs: T)

Performs the /= operation.

impl<T> DivAssign<T> for NdVector<3, T>

where T: DivAssign + Copy,

fn div_assign(&mut self, rhs: T)

Performs the /= operation.

impl<T> DivAssign<T> for NdVector<4, T>

where T: DivAssign + Copy,

fn div_assign(&mut self, rhs: T)

Performs the /= operation.

impl<Data> Dot for NdVector<1, Data>

where Data: DataValue,

type Product = Data

fn dot(self, rhs: NdVector<1, Data>) -> <NdVector<1, Data> as Dot>::Product

impl<Data> Dot for NdVector<2, Data>

where Data: DataValue,

type Product = Data

fn dot(self, rhs: NdVector<2, Data>) -> <NdVector<2, Data> as Dot>::Product

impl<Data> Dot for NdVector<3, Data>

where Data: DataValue,

type Product = Data

fn dot(self, rhs: NdVector<3, Data>) -> <NdVector<3, Data> as Dot>::Product

impl<Data> Dot for NdVector<4, Data>

where Data: DataValue,

type Product = Data

fn dot(self, rhs: NdVector<4, Data>) -> <NdVector<4, Data> as Dot>::Product

impl<Data> ElementWiseDiv for NdVector<1, Data>

where Data: DataValue + DivAssign,

type Output = NdVector<1, Data>

fn elem_div( self, rhs: NdVector<1, Data>, ) -> <NdVector<1, Data> as ElementWiseDiv>::Output

impl<Data> ElementWiseDiv for NdVector<2, Data>

where Data: DataValue + DivAssign,

type Output = NdVector<2, Data>

fn elem_div( self, rhs: NdVector<2, Data>, ) -> <NdVector<2, Data> as ElementWiseDiv>::Output

impl<Data> ElementWiseDiv for NdVector<3, Data>

where Data: DataValue + DivAssign,

type Output = NdVector<3, Data>

fn elem_div( self, rhs: NdVector<3, Data>, ) -> <NdVector<3, Data> as ElementWiseDiv>::Output

impl<Data> ElementWiseDiv for NdVector<4, Data>

where Data: DataValue + DivAssign,

type Output = NdVector<4, Data>

fn elem_div( self, rhs: NdVector<4, Data>, ) -> <NdVector<4, Data> as ElementWiseDiv>::Output

impl<Data> ElementWiseMul for NdVector<1, Data>

where Data: DataValue + MulAssign,

type Output = NdVector<1, Data>

fn elem_mul( self, rhs: NdVector<1, Data>, ) -> <NdVector<1, Data> as ElementWiseMul>::Output

impl<Data> ElementWiseMul for NdVector<2, Data>

where Data: DataValue + MulAssign,

type Output = NdVector<2, Data>

fn elem_mul( self, rhs: NdVector<2, Data>, ) -> <NdVector<2, Data> as ElementWiseMul>::Output

impl<Data> ElementWiseMul for NdVector<3, Data>

where Data: DataValue + MulAssign,

type Output = NdVector<3, Data>

fn elem_mul( self, rhs: NdVector<3, Data>, ) -> <NdVector<3, Data> as ElementWiseMul>::Output

impl<Data> ElementWiseMul for NdVector<4, Data>

where Data: DataValue + MulAssign,

type Output = NdVector<4, Data>

fn elem_mul( self, rhs: NdVector<4, Data>, ) -> <NdVector<4, Data> as ElementWiseMul>::Output

impl<const N: usize, T> From<[T; N]> for NdVector<N, T>

fn from(data: [T; N]) -> NdVector<N, T>

Converts to this type from the input type.

impl<T> Mul<T> for NdVector<1, T>

where T: Mul<Output = T> + MulAssign + Copy,

type Output = NdVector<1, T>

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> <NdVector<1, T> as Mul<T>>::Output

Performs the * operation.

impl<T> Mul<T> for NdVector<2, T>

where T: Mul<Output = T> + MulAssign + Copy,

type Output = NdVector<2, T>

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> <NdVector<2, T> as Mul<T>>::Output

Performs the * operation.

impl<T> Mul<T> for NdVector<3, T>

where T: Mul<Output = T> + MulAssign + Copy,

type Output = NdVector<3, T>

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> <NdVector<3, T> as Mul<T>>::Output

Performs the * operation.

impl<T> Mul<T> for NdVector<4, T>

where T: Mul<Output = T> + MulAssign + Copy,

type Output = NdVector<4, T>

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> <NdVector<4, T> as Mul<T>>::Output

Performs the * operation.

impl<T> MulAssign<T> for NdVector<1, T>

where T: MulAssign + Copy,

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl<T> MulAssign<T> for NdVector<2, T>

where T: MulAssign + Copy,

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl<T> MulAssign<T> for NdVector<3, T>

where T: MulAssign + Copy,

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl<T> MulAssign<T> for NdVector<4, T>

where T: MulAssign + Copy,

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl<Data> PartialEq for NdVector<1, Data>

where Data: PartialEq,

fn eq(&self, rhs: &NdVector<1, Data>) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<Data> PartialEq for NdVector<2, Data>

where Data: PartialEq,

fn eq(&self, rhs: &NdVector<2, Data>) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<Data> PartialEq for NdVector<3, Data>

where Data: PartialEq,

fn eq(&self, rhs: &NdVector<3, Data>) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<Data> PartialEq for NdVector<4, Data>

where Data: PartialEq,

fn eq(&self, rhs: &NdVector<4, Data>) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<Data> Portable for NdVector<1, Data>

where Data: DataValue,

fn to_bytes(self) -> Vec<u8>

fn write_to<W>(self, writer: &mut W)

where W: ByteWriter,

fn read_from<R>(reader: &mut R) -> Result<NdVector<1, Data>, ReaderErr>

where R: ByteReader,

impl<Data> Portable for NdVector<2, Data>

where Data: DataValue,

fn to_bytes(self) -> Vec<u8>

fn write_to<W>(self, writer: &mut W)

where W: ByteWriter,

fn read_from<R>(reader: &mut R) -> Result<NdVector<2, Data>, ReaderErr>

where R: ByteReader,

impl<Data> Portable for NdVector<3, Data>

where Data: DataValue,

fn to_bytes(self) -> Vec<u8>

fn write_to<W>(self, writer: &mut W)

where W: ByteWriter,

fn read_from<R>(reader: &mut R) -> Result<NdVector<3, Data>, ReaderErr>

where R: ByteReader,

impl<Data> Portable for NdVector<4, Data>

where Data: DataValue,

fn to_bytes(self) -> Vec<u8>

fn write_to<W>(self, writer: &mut W)

where W: ByteWriter,

fn read_from<R>(reader: &mut R) -> Result<NdVector<4, Data>, ReaderErr>

where R: ByteReader,

impl<T> Sub for NdVector<1, T>

where T: Sub<Output = T> + SubAssign + Copy,

type Output = NdVector<1, T>

The resulting type after applying the - operator.

fn sub(self, rhs: NdVector<1, T>) -> <NdVector<1, T> as Sub>::Output

Performs the - operation.

impl<T> Sub for NdVector<2, T>

where T: Sub<Output = T> + SubAssign + Copy,

type Output = NdVector<2, T>

The resulting type after applying the - operator.

fn sub(self, rhs: NdVector<2, T>) -> <NdVector<2, T> as Sub>::Output

Performs the - operation.

impl<T> Sub for NdVector<3, T>

where T: Sub<Output = T> + SubAssign + Copy,

type Output = NdVector<3, T>

The resulting type after applying the - operator.

fn sub(self, rhs: NdVector<3, T>) -> <NdVector<3, T> as Sub>::Output

Performs the - operation.

impl<T> Sub for NdVector<4, T>

where T: Sub<Output = T> + SubAssign + Copy,

type Output = NdVector<4, T>

The resulting type after applying the - operator.

fn sub(self, rhs: NdVector<4, T>) -> <NdVector<4, T> as Sub>::Output

Performs the - operation.

impl<T> SubAssign for NdVector<1, T>

where T: SubAssign + Copy,

fn sub_assign(&mut self, rhs: NdVector<1, T>)

Performs the -= operation.

impl<T> SubAssign for NdVector<2, T>

where T: SubAssign + Copy,

fn sub_assign(&mut self, rhs: NdVector<2, T>)

Performs the -= operation.

impl<T> SubAssign for NdVector<3, T>

where T: SubAssign + Copy,

fn sub_assign(&mut self, rhs: NdVector<3, T>)

Performs the -= operation.

impl<T> SubAssign for NdVector<4, T>

where T: SubAssign + Copy,

fn sub_assign(&mut self, rhs: NdVector<4, T>)

Performs the -= operation.

impl Vector<1> for NdVector<1, u8>

type Component = u8

fn zero() -> NdVector<1, u8>

fn get(&self, index: usize) -> &<NdVector<1, u8> as Vector<1>>::Component

fn get_mut( &mut self, index: usize, ) -> &mut <NdVector<1, u8> as Vector<1>>::Component

unsafe fn get_unchecked( &self, index: usize, ) -> &<NdVector<1, u8> as Vector<1>>::Component

Safety

unsafe fn get_unchecked_mut( &mut self, index: usize, ) -> &mut <NdVector<1, u8> as Vector<1>>::Component

Safety

impl Vector<1> for NdVector<1, u16>

type Component = u16

fn zero() -> NdVector<1, u16>

fn get(&self, index: usize) -> &<NdVector<1, u16> as Vector<1>>::Component

fn get_mut( &mut self, index: usize, ) -> &mut <NdVector<1, u16> as Vector<1>>::Component

unsafe fn get_unchecked( &self, index: usize, ) -> &<NdVector<1, u16> as Vector<1>>::Component

Safety

unsafe fn get_unchecked_mut( &mut self, index: usize, ) -> &mut <NdVector<1, u16> as Vector<1>>::Component

Safety

impl Vector<1> for NdVector<1, u32>

type Component = u32

fn zero() -> NdVector<1, u32>

fn get(&self, index: usize) -> &<NdVector<1, u32> as Vector<1>>::Component

fn get_mut( &mut self, index: usize, ) -> &mut <NdVector<1, u32> as Vector<1>>::Component

unsafe fn get_unchecked( &self, index: usize, ) -> &<NdVector<1, u32> as Vector<1>>::Component

Safety

unsafe fn get_unchecked_mut( &mut self, index: usize, ) -> &mut <NdVector<1, u32> as Vector<1>>::Component

Safety

impl Vector<1> for NdVector<1, u64>

type Component = u64

fn zero() -> NdVector<1, u64>

fn get(&self, index: usize) -> &<NdVector<1, u64> as Vector<1>>::Component

fn get_mut( &mut self, index: usize, ) -> &mut <NdVector<1, u64> as Vector<1>>::Component

unsafe fn get_unchecked( &self, index: usize, ) -> &<NdVector<1, u64> as Vector<1>>::Component

Safety

unsafe fn get_unchecked_mut( &mut self, index: usize, ) -> &mut <NdVector<1, u64> as Vector<1>>::Component

Safety

impl Vector<1> for NdVector<1, i8>

type Component = i8

fn zero() -> NdVector<1, i8>

fn get(&self, index: usize) -> &<NdVector<1, i8> as Vector<1>>::Component

fn get_mut( &mut self, index: usize, ) -> &mut <NdVector<1, i8> as Vector<1>>::Component

unsafe fn get_unchecked( &self, index: usize, ) -> &<NdVector<1, i8> as Vector<1>>::Component

Safety

unsafe fn get_unchecked_mut( &mut self, index: usize, ) -> &mut <NdVector<1, i8> as Vector<1>>::Component

Safety

impl Vector<1> for NdVector<1, i16>

type Component = i16

fn zero() -> NdVector<1, i16>

fn get(&self, index: usize) -> &<NdVector<1, i16> as Vector<1>>::Component

fn get_mut( &mut self, index: usize, ) -> &mut <NdVector<1, i16> as Vector<1>>::Component

unsafe fn get_unchecked( &self, index: usize, ) -> &<NdVector<1, i16> as Vector<1>>::Component

Safety

unsafe fn get_unchecked_mut( &mut self, index: usize, ) -> &mut <NdVector<1, i16> as Vector<1>>::Component

Safety

impl Vector<1> for NdVector<1, i32>

type Component = i32

fn zero() -> NdVector<1, i32>

fn get(&self, index: usize) -> &<NdVector<1, i32> as Vector<1>>::Component

fn get_mut( &mut self, index: usize, ) -> &mut <NdVector<1, i32> as Vector<1>>::Component

unsafe fn get_unchecked( &self, index: usize, ) -> &<NdVector<1, i32> as Vector<1>>::Component

Safety

unsafe fn get_unchecked_mut( &mut self, index: usize, ) -> &mut <NdVector<1, i32> as Vector<1>>::Component

Safety

impl Vector<1> for NdVector<1, i64>

type Component = i64

fn zero() -> NdVector<1, i64>

fn get(&self, index: usize) -> &<NdVector<1, i64> as Vector<1>>::Component

fn get_mut( &mut self, index: usize, ) -> &mut <NdVector<1, i64> as Vector<1>>::Component

unsafe fn get_unchecked( &self, index: usize, ) -> &<NdVector<1, i64> as Vector<1>>::Component

Safety

unsafe fn get_unchecked_mut( &mut self, index: usize, ) -> &mut <NdVector<1, i64> as Vector<1>>::Component

Safety

impl Vector<1> for NdVector<1, f32>

type Component = f32

fn zero() -> NdVector<1, f32>

fn get(&self, index: usize) -> &<NdVector<1, f32> as Vector<1>>::Component

fn get_mut( &mut self, index: usize, ) -> &mut <NdVector<1, f32> as Vector<1>>::Component

unsafe fn get_unchecked( &self, index: usize, ) -> &<NdVector<1, f32> as Vector<1>>::Component

Safety

unsafe fn get_unchecked_mut( &mut self, index: usize, ) -> &mut <NdVector<1, f32> as Vector<1>>::Component

Safety

impl Vector<1> for NdVector<1, f64>

type Component = f64

fn zero() -> NdVector<1, f64>

fn get(&self, index: usize) -> &<NdVector<1, f64> as Vector<1>>::Component

fn get_mut( &mut self, index: usize, ) -> &mut <NdVector<1, f64> as Vector<1>>::Component

unsafe fn get_unchecked( &self, index: usize, ) -> &<NdVector<1, f64> as Vector<1>>::Component

Safety

unsafe fn get_unchecked_mut( &mut self, index: usize, ) -> &mut <NdVector<1, f64> as Vector<1>>::Component

Safety

impl Vector<2> for NdVector<2, u8>

type Component = u8

fn zero() -> NdVector<2, u8>

fn get(&self, index: usize) -> &<NdVector<2, u8> as Vector<2>>::Component

fn get_mut( &mut self, index: usize, ) -> &mut <NdVector<2, u8> as Vector<2>>::Component

unsafe fn get_unchecked( &self, index: usize, ) -> &<NdVector<2, u8> as Vector<2>>::Component

Safety

unsafe fn get_unchecked_mut( &mut self, index: usize, ) -> &mut <NdVector<2, u8> as Vector<2>>::Component

Safety

impl Vector<2> for NdVector<2, u16>

type Component = u16

fn zero() -> NdVector<2, u16>

fn get(&self, index: usize) -> &<NdVector<2, u16> as Vector<2>>::Component

fn get_mut( &mut self, index: usize, ) -> &mut <NdVector<2, u16> as Vector<2>>::Component

unsafe fn get_unchecked( &self, index: usize, ) -> &<NdVector<2, u16> as Vector<2>>::Component

Safety

unsafe fn get_unchecked_mut( &mut self, index: usize, ) -> &mut <NdVector<2, u16> as Vector<2>>::Component

Safety

impl Vector<2> for NdVector<2, u32>

type Component = u32

fn zero() -> NdVector<2, u32>

fn get(&self, index: usize) -> &<NdVector<2, u32> as Vector<2>>::Component

fn get_mut( &mut self, index: usize, ) -> &mut <NdVector<2, u32> as Vector<2>>::Component

unsafe fn get_unchecked( &self, index: usize, ) -> &<NdVector<2, u32> as Vector<2>>::Component

Safety

unsafe fn get_unchecked_mut( &mut self, index: usize, ) -> &mut <NdVector<2, u32> as Vector<2>>::Component

Safety

impl Vector<2> for NdVector<2, u64>

type Component = u64

fn zero() -> NdVector<2, u64>

fn get(&self, index: usize) -> &<NdVector<2, u64> as Vector<2>>::Component

fn get_mut( &mut self, index: usize, ) -> &mut <NdVector<2, u64> as Vector<2>>::Component

unsafe fn get_unchecked( &self, index: usize, ) -> &<NdVector<2, u64> as Vector<2>>::Component

Safety

unsafe fn get_unchecked_mut( &mut self, index: usize, ) -> &mut <NdVector<2, u64> as Vector<2>>::Component

Safety

impl Vector<2> for NdVector<2, i8>

type Component = i8

fn zero() -> NdVector<2, i8>

fn get(&self, index: usize) -> &<NdVector<2, i8> as Vector<2>>::Component

fn get_mut( &mut self, index: usize, ) -> &mut <NdVector<2, i8> as Vector<2>>::Component

unsafe fn get_unchecked( &self, index: usize, ) -> &<NdVector<2, i8> as Vector<2>>::Component

Safety

unsafe fn get_unchecked_mut( &mut self, index: usize, ) -> &mut <NdVector<2, i8> as Vector<2>>::Component

Safety

impl Vector<2> for NdVector<2, i16>

type Component = i16

fn zero() -> NdVector<2, i16>

fn get(&self, index: usize) -> &<NdVector<2, i16> as Vector<2>>::Component

fn get_mut( &mut self, index: usize, ) -> &mut <NdVector<2, i16> as Vector<2>>::Component

unsafe fn get_unchecked( &self, index: usize, ) -> &<NdVector<2, i16> as Vector<2>>::Component

Safety

unsafe fn get_unchecked_mut( &mut self, index: usize, ) -> &mut <NdVector<2, i16> as Vector<2>>::Component

Safety

impl Vector<2> for NdVector<2, i32>

type Component = i32

fn zero() -> NdVector<2, i32>

fn get(&self, index: usize) -> &<NdVector<2, i32> as Vector<2>>::Component

fn get_mut( &mut self, index: usize, ) -> &mut <NdVector<2, i32> as Vector<2>>::Component

unsafe fn get_unchecked( &self, index: usize, ) -> &<NdVector<2, i32> as Vector<2>>::Component

Safety

unsafe fn get_unchecked_mut( &mut self, index: usize, ) -> &mut <NdVector<2, i32> as Vector<2>>::Component

Safety

impl Vector<2> for NdVector<2, i64>

type Component = i64

fn zero() -> NdVector<2, i64>

fn get(&self, index: usize) -> &<NdVector<2, i64> as Vector<2>>::Component

fn get_mut( &mut self, index: usize, ) -> &mut <NdVector<2, i64> as Vector<2>>::Component

unsafe fn get_unchecked( &self, index: usize, ) -> &<NdVector<2, i64> as Vector<2>>::Component

Safety

unsafe fn get_unchecked_mut( &mut self, index: usize, ) -> &mut <NdVector<2, i64> as Vector<2>>::Component

Safety

impl Vector<2> for NdVector<2, f32>

type Component = f32

fn zero() -> NdVector<2, f32>

fn get(&self, index: usize) -> &<NdVector<2, f32> as Vector<2>>::Component

fn get_mut( &mut self, index: usize, ) -> &mut <NdVector<2, f32> as Vector<2>>::Component

unsafe fn get_unchecked( &self, index: usize, ) -> &<NdVector<2, f32> as Vector<2>>::Component

Safety

unsafe fn get_unchecked_mut( &mut self, index: usize, ) -> &mut <NdVector<2, f32> as Vector<2>>::Component

Safety

impl Vector<2> for NdVector<2, f64>

type Component = f64

fn zero() -> NdVector<2, f64>

fn get(&self, index: usize) -> &<NdVector<2, f64> as Vector<2>>::Component

fn get_mut( &mut self, index: usize, ) -> &mut <NdVector<2, f64> as Vector<2>>::Component

unsafe fn get_unchecked( &self, index: usize, ) -> &<NdVector<2, f64> as Vector<2>>::Component

Safety

unsafe fn get_unchecked_mut( &mut self, index: usize, ) -> &mut <NdVector<2, f64> as Vector<2>>::Component

Safety

impl Vector<3> for NdVector<3, u8>

type Component = u8

fn zero() -> NdVector<3, u8>

fn get(&self, index: usize) -> &<NdVector<3, u8> as Vector<3>>::Component

fn get_mut( &mut self, index: usize, ) -> &mut <NdVector<3, u8> as Vector<3>>::Component

unsafe fn get_unchecked( &self, index: usize, ) -> &<NdVector<3, u8> as Vector<3>>::Component

Safety

unsafe fn get_unchecked_mut( &mut self, index: usize, ) -> &mut <NdVector<3, u8> as Vector<3>>::Component

Safety

impl Vector<3> for NdVector<3, u16>

type Component = u16

fn zero() -> NdVector<3, u16>

fn get(&self, index: usize) -> &<NdVector<3, u16> as Vector<3>>::Component

fn get_mut( &mut self, index: usize, ) -> &mut <NdVector<3, u16> as Vector<3>>::Component

unsafe fn get_unchecked( &self, index: usize, ) -> &<NdVector<3, u16> as Vector<3>>::Component

Safety

unsafe fn get_unchecked_mut( &mut self, index: usize, ) -> &mut <NdVector<3, u16> as Vector<3>>::Component

Safety

impl Vector<3> for NdVector<3, u32>

type Component = u32

fn zero() -> NdVector<3, u32>

fn get(&self, index: usize) -> &<NdVector<3, u32> as Vector<3>>::Component

fn get_mut( &mut self, index: usize, ) -> &mut <NdVector<3, u32> as Vector<3>>::Component

unsafe fn get_unchecked( &self, index: usize, ) -> &<NdVector<3, u32> as Vector<3>>::Component

Safety

unsafe fn get_unchecked_mut( &mut self, index: usize, ) -> &mut <NdVector<3, u32> as Vector<3>>::Component

Safety

impl Vector<3> for NdVector<3, u64>

type Component = u64

fn zero() -> NdVector<3, u64>

fn get(&self, index: usize) -> &<NdVector<3, u64> as Vector<3>>::Component

fn get_mut( &mut self, index: usize, ) -> &mut <NdVector<3, u64> as Vector<3>>::Component

unsafe fn get_unchecked( &self, index: usize, ) -> &<NdVector<3, u64> as Vector<3>>::Component

Safety

unsafe fn get_unchecked_mut( &mut self, index: usize, ) -> &mut <NdVector<3, u64> as Vector<3>>::Component

Safety

impl Vector<3> for NdVector<3, i8>

type Component = i8

fn zero() -> NdVector<3, i8>

fn get(&self, index: usize) -> &<NdVector<3, i8> as Vector<3>>::Component

fn get_mut( &mut self, index: usize, ) -> &mut <NdVector<3, i8> as Vector<3>>::Component

unsafe fn get_unchecked( &self, index: usize, ) -> &<NdVector<3, i8> as Vector<3>>::Component

Safety

unsafe fn get_unchecked_mut( &mut self, index: usize, ) -> &mut <NdVector<3, i8> as Vector<3>>::Component

Safety

impl Vector<3> for NdVector<3, i16>

type Component = i16

fn zero() -> NdVector<3, i16>

fn get(&self, index: usize) -> &<NdVector<3, i16> as Vector<3>>::Component

fn get_mut( &mut self, index: usize, ) -> &mut <NdVector<3, i16> as Vector<3>>::Component

unsafe fn get_unchecked( &self, index: usize, ) -> &<NdVector<3, i16> as Vector<3>>::Component

Safety

unsafe fn get_unchecked_mut( &mut self, index: usize, ) -> &mut <NdVector<3, i16> as Vector<3>>::Component

Safety

impl Vector<3> for NdVector<3, i32>

type Component = i32

fn zero() -> NdVector<3, i32>

fn get(&self, index: usize) -> &<NdVector<3, i32> as Vector<3>>::Component

fn get_mut( &mut self, index: usize, ) -> &mut <NdVector<3, i32> as Vector<3>>::Component

unsafe fn get_unchecked( &self, index: usize, ) -> &<NdVector<3, i32> as Vector<3>>::Component

Safety

unsafe fn get_unchecked_mut( &mut self, index: usize, ) -> &mut <NdVector<3, i32> as Vector<3>>::Component

Safety

impl Vector<3> for NdVector<3, i64>

type Component = i64

fn zero() -> NdVector<3, i64>

fn get(&self, index: usize) -> &<NdVector<3, i64> as Vector<3>>::Component

fn get_mut( &mut self, index: usize, ) -> &mut <NdVector<3, i64> as Vector<3>>::Component

unsafe fn get_unchecked( &self, index: usize, ) -> &<NdVector<3, i64> as Vector<3>>::Component

Safety

unsafe fn get_unchecked_mut( &mut self, index: usize, ) -> &mut <NdVector<3, i64> as Vector<3>>::Component

Safety

impl Vector<3> for NdVector<3, f32>

type Component = f32

fn zero() -> NdVector<3, f32>

fn get(&self, index: usize) -> &<NdVector<3, f32> as Vector<3>>::Component

fn get_mut( &mut self, index: usize, ) -> &mut <NdVector<3, f32> as Vector<3>>::Component

unsafe fn get_unchecked( &self, index: usize, ) -> &<NdVector<3, f32> as Vector<3>>::Component

Safety

unsafe fn get_unchecked_mut( &mut self, index: usize, ) -> &mut <NdVector<3, f32> as Vector<3>>::Component

Safety

impl Vector<3> for NdVector<3, f64>

type Component = f64

fn zero() -> NdVector<3, f64>

fn get(&self, index: usize) -> &<NdVector<3, f64> as Vector<3>>::Component

fn get_mut( &mut self, index: usize, ) -> &mut <NdVector<3, f64> as Vector<3>>::Component

unsafe fn get_unchecked( &self, index: usize, ) -> &<NdVector<3, f64> as Vector<3>>::Component

Safety

unsafe fn get_unchecked_mut( &mut self, index: usize, ) -> &mut <NdVector<3, f64> as Vector<3>>::Component

Safety

impl Vector<4> for NdVector<4, u8>

type Component = u8

fn zero() -> NdVector<4, u8>

fn get(&self, index: usize) -> &<NdVector<4, u8> as Vector<4>>::Component

fn get_mut( &mut self, index: usize, ) -> &mut <NdVector<4, u8> as Vector<4>>::Component

unsafe fn get_unchecked( &self, index: usize, ) -> &<NdVector<4, u8> as Vector<4>>::Component

Safety

unsafe fn get_unchecked_mut( &mut self, index: usize, ) -> &mut <NdVector<4, u8> as Vector<4>>::Component

Safety

impl Vector<4> for NdVector<4, u16>

type Component = u16

fn zero() -> NdVector<4, u16>

fn get(&self, index: usize) -> &<NdVector<4, u16> as Vector<4>>::Component

fn get_mut( &mut self, index: usize, ) -> &mut <NdVector<4, u16> as Vector<4>>::Component

unsafe fn get_unchecked( &self, index: usize, ) -> &<NdVector<4, u16> as Vector<4>>::Component

Safety

unsafe fn get_unchecked_mut( &mut self, index: usize, ) -> &mut <NdVector<4, u16> as Vector<4>>::Component

Safety

impl Vector<4> for NdVector<4, u32>

type Component = u32

fn zero() -> NdVector<4, u32>

fn get(&self, index: usize) -> &<NdVector<4, u32> as Vector<4>>::Component

fn get_mut( &mut self, index: usize, ) -> &mut <NdVector<4, u32> as Vector<4>>::Component

unsafe fn get_unchecked( &self, index: usize, ) -> &<NdVector<4, u32> as Vector<4>>::Component

Safety

unsafe fn get_unchecked_mut( &mut self, index: usize, ) -> &mut <NdVector<4, u32> as Vector<4>>::Component

Safety

impl Vector<4> for NdVector<4, u64>

type Component = u64

fn zero() -> NdVector<4, u64>

fn get(&self, index: usize) -> &<NdVector<4, u64> as Vector<4>>::Component

fn get_mut( &mut self, index: usize, ) -> &mut <NdVector<4, u64> as Vector<4>>::Component

unsafe fn get_unchecked( &self, index: usize, ) -> &<NdVector<4, u64> as Vector<4>>::Component

Safety

unsafe fn get_unchecked_mut( &mut self, index: usize, ) -> &mut <NdVector<4, u64> as Vector<4>>::Component

Safety

impl Vector<4> for NdVector<4, i8>

type Component = i8

fn zero() -> NdVector<4, i8>

fn get(&self, index: usize) -> &<NdVector<4, i8> as Vector<4>>::Component

fn get_mut( &mut self, index: usize, ) -> &mut <NdVector<4, i8> as Vector<4>>::Component

unsafe fn get_unchecked( &self, index: usize, ) -> &<NdVector<4, i8> as Vector<4>>::Component

Safety

unsafe fn get_unchecked_mut( &mut self, index: usize, ) -> &mut <NdVector<4, i8> as Vector<4>>::Component

Safety

impl Vector<4> for NdVector<4, i16>

type Component = i16

fn zero() -> NdVector<4, i16>

fn get(&self, index: usize) -> &<NdVector<4, i16> as Vector<4>>::Component

fn get_mut( &mut self, index: usize, ) -> &mut <NdVector<4, i16> as Vector<4>>::Component

unsafe fn get_unchecked( &self, index: usize, ) -> &<NdVector<4, i16> as Vector<4>>::Component

Safety

unsafe fn get_unchecked_mut( &mut self, index: usize, ) -> &mut <NdVector<4, i16> as Vector<4>>::Component

Safety

impl Vector<4> for NdVector<4, i32>

type Component = i32

fn zero() -> NdVector<4, i32>

fn get(&self, index: usize) -> &<NdVector<4, i32> as Vector<4>>::Component

fn get_mut( &mut self, index: usize, ) -> &mut <NdVector<4, i32> as Vector<4>>::Component

unsafe fn get_unchecked( &self, index: usize, ) -> &<NdVector<4, i32> as Vector<4>>::Component

Safety

unsafe fn get_unchecked_mut( &mut self, index: usize, ) -> &mut <NdVector<4, i32> as Vector<4>>::Component

Safety

impl Vector<4> for NdVector<4, i64>

type Component = i64

fn zero() -> NdVector<4, i64>

fn get(&self, index: usize) -> &<NdVector<4, i64> as Vector<4>>::Component

fn get_mut( &mut self, index: usize, ) -> &mut <NdVector<4, i64> as Vector<4>>::Component

unsafe fn get_unchecked( &self, index: usize, ) -> &<NdVector<4, i64> as Vector<4>>::Component

Safety

unsafe fn get_unchecked_mut( &mut self, index: usize, ) -> &mut <NdVector<4, i64> as Vector<4>>::Component

Safety

impl Vector<4> for NdVector<4, f32>

type Component = f32

fn zero() -> NdVector<4, f32>

fn get(&self, index: usize) -> &<NdVector<4, f32> as Vector<4>>::Component

fn get_mut( &mut self, index: usize, ) -> &mut <NdVector<4, f32> as Vector<4>>::Component

unsafe fn get_unchecked( &self, index: usize, ) -> &<NdVector<4, f32> as Vector<4>>::Component

Safety

unsafe fn get_unchecked_mut( &mut self, index: usize, ) -> &mut <NdVector<4, f32> as Vector<4>>::Component

Safety

impl Vector<4> for NdVector<4, f64>

type Component = f64

fn zero() -> NdVector<4, f64>

fn get(&self, index: usize) -> &<NdVector<4, f64> as Vector<4>>::Component

fn get_mut( &mut self, index: usize, ) -> &mut <NdVector<4, f64> as Vector<4>>::Component

unsafe fn get_unchecked( &self, index: usize, ) -> &<NdVector<4, f64> as Vector<4>>::Component

Safety

unsafe fn get_unchecked_mut( &mut self, index: usize, ) -> &mut <NdVector<4, f64> as Vector<4>>::Component

Safety