vectormatrix 0.1.2

pub mod vectormatrix
pub mod vectormatrix::matrix
pub struct vectormatrix::matrix::Matrix<T, const R: usize, const C: usize>
impl<T, const M: usize, const N: usize> vectormatrix::matrix::Matrix<T, M, N> where T: core::clone::Clone + core::ops::arith::Mul<Output = T> + core::ops::arith::Add<Output = T>
pub fn vectormatrix::matrix::Matrix<T, M, N>::mul_matrix<const P: usize>(self, other: vectormatrix::matrix::Matrix<T, N, P>) -> vectormatrix::matrix::Matrix<T, M, P>
impl<T, const R: usize, const C: usize> vectormatrix::matrix::Matrix<T, R, C> where T: core::clone::Clone + vectormatrix::types::sealed::Float
pub fn vectormatrix::matrix::Matrix<T, R, C>::eq_approx(self, other: Self, tolerance: T) -> bool
impl<T, const R: usize, const C: usize> vectormatrix::matrix::Matrix<T, R, C> where T: core::clone::Clone
pub fn vectormatrix::matrix::Matrix<T, R, C>::rows(self) -> [vectormatrix::vector::Vector<T, C>; R]
impl<T, const R: usize, const C: usize> vectormatrix::matrix::Matrix<T, R, C> where T: core::ops::arith::SubAssign + core::clone::Clone
pub fn vectormatrix::matrix::Matrix<T, R, C>::sub_scalar_assign(&mut self, other: T)
impl<T, const R: usize, const C: usize> vectormatrix::matrix::Matrix<T, R, C>
pub const vectormatrix::matrix::Matrix<T, R, C>::UNINIT: vectormatrix::matrix::Matrix<core::mem::maybe_uninit::MaybeUninit<T>, R, C>
pub const fn vectormatrix::matrix::Matrix<T, R, C>::new_columns(columns: [vectormatrix::vector::Vector<T, R>; C]) -> Self
pub fn vectormatrix::matrix::Matrix<T, R, C>::new_from_array<const L: usize>(arr: [T; L]) -> Self where T: core::clone::Clone
pub fn vectormatrix::matrix::Matrix<T, R, C>::new_rows(rows: [vectormatrix::vector::Vector<T, C>; R]) -> Self where T: core::clone::Clone
pub fn vectormatrix::matrix::Matrix<T, R, C>::transpose(self) -> vectormatrix::matrix::Matrix<T, C, R> where T: core::clone::Clone
impl<T, const R: usize, const C: usize> vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::columns(&self) -> &[vectormatrix::vector::Vector<T, R>; C]
pub fn vectormatrix::matrix::Matrix<T, R, C>::columns_mut(&mut self) -> &mut [vectormatrix::vector::Vector<T, R>; C]
pub fn vectormatrix::matrix::Matrix<T, R, C>::element_at(&self, row: usize, col: usize) -> &T
pub fn vectormatrix::matrix::Matrix<T, R, C>::element_at_mut(&mut self, row: usize, col: usize) -> &mut T
impl<T, const R: usize, const C: usize> vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::map_in_place<F: core::ops::function::FnMut(&mut T)>(&mut self, f: F)
impl<T, const R: usize, const C: usize> vectormatrix::matrix::Matrix<core::mem::maybe_uninit::MaybeUninit<T>, R, C>
pub unsafe fn vectormatrix::matrix::Matrix<core::mem::maybe_uninit::MaybeUninit<T>, R, C>::assume_init(self) -> vectormatrix::matrix::Matrix<T, R, C>
impl<T: core::clone::Clone + core::ops::arith::Add<Output = T>, const R: usize, const C: usize> vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::add_scalar(self, other: T) -> Self
impl<T: core::clone::Clone + core::ops::arith::AddAssign, const R: usize, const C: usize> vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::add_elementwise_assign(&mut self, other: Self)
impl<T: core::clone::Clone + core::ops::arith::Div<Output = T>, const R: usize, const C: usize> vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::div_scalar(self, other: T) -> Self
impl<T: core::clone::Clone + core::ops::arith::DivAssign, const R: usize, const C: usize> vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::div_elementwise_assign(&mut self, other: Self)
impl<T: core::clone::Clone + core::ops::arith::Mul<Output = T>, const R: usize, const C: usize> vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::mul_scalar(self, other: T) -> Self
impl<T: core::clone::Clone + core::ops::arith::MulAssign, const R: usize, const C: usize> vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::mul_elementwise_assign(&mut self, other: Self)
impl<T: core::clone::Clone + core::ops::arith::Sub<Output = T>, const R: usize, const C: usize> vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::sub_scalar(self, other: T) -> Self
impl<T: core::clone::Clone + core::ops::arith::SubAssign, const R: usize, const C: usize> vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::sub_elementwise_assign(&mut self, other: Self)
impl<T: core::clone::Clone, const R: usize, const C: usize> vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::map<F: core::ops::function::FnMut(T) -> T>(self, f: F) -> Self
impl<T: vectormatrix::types::sealed::Constants + core::clone::Clone + core::ops::arith::Add<Output = T>, const R: usize, const C: usize> vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::elementwise_add(self, other: Self) -> Self
impl<T: vectormatrix::types::sealed::Constants + core::clone::Clone + core::ops::arith::Div<Output = T>, const R: usize, const C: usize> vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::elementwise_div(self, other: Self) -> Self
impl<T: vectormatrix::types::sealed::Constants + core::clone::Clone + core::ops::arith::Mul<Output = T>, const R: usize, const C: usize> vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::elementwise_mul(self, other: Self) -> Self
impl<T: vectormatrix::types::sealed::Constants + core::clone::Clone + core::ops::arith::Sub<Output = T>, const R: usize, const C: usize> vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::elementwise_sub(self, other: Self) -> Self
impl<T: vectormatrix::types::sealed::Constants, const R: usize, const C: usize> vectormatrix::matrix::Matrix<T, R, C>
pub const vectormatrix::matrix::Matrix<T, R, C>::ONE: Self
pub const vectormatrix::matrix::Matrix<T, R, C>::ZERO: Self
impl<T: vectormatrix::types::sealed::Constants> vectormatrix::matrix::Matrix<T, 1, 1>
pub const vectormatrix::matrix::Matrix<T, 1, 1>::IDENTITY: Self
impl<T: vectormatrix::types::sealed::Constants> vectormatrix::matrix::Matrix<T, 1, 2>
pub const vectormatrix::matrix::Matrix<T, 1, 2>::IDENTITY: Self
impl<T: vectormatrix::types::sealed::Constants> vectormatrix::matrix::Matrix<T, 1, 3>
pub const vectormatrix::matrix::Matrix<T, 1, 3>::IDENTITY: Self
impl<T: vectormatrix::types::sealed::Constants> vectormatrix::matrix::Matrix<T, 1, 4>
pub const vectormatrix::matrix::Matrix<T, 1, 4>::IDENTITY: Self
impl<T: vectormatrix::types::sealed::Constants> vectormatrix::matrix::Matrix<T, 2, 1>
pub const vectormatrix::matrix::Matrix<T, 2, 1>::IDENTITY: Self
impl<T: vectormatrix::types::sealed::Constants> vectormatrix::matrix::Matrix<T, 2, 2>
pub const vectormatrix::matrix::Matrix<T, 2, 2>::IDENTITY: Self
impl<T: vectormatrix::types::sealed::Constants> vectormatrix::matrix::Matrix<T, 2, 3>
pub const vectormatrix::matrix::Matrix<T, 2, 3>::IDENTITY: Self
impl<T: vectormatrix::types::sealed::Constants> vectormatrix::matrix::Matrix<T, 2, 4>
pub const vectormatrix::matrix::Matrix<T, 2, 4>::IDENTITY: Self
impl<T: vectormatrix::types::sealed::Constants> vectormatrix::matrix::Matrix<T, 3, 1>
pub const vectormatrix::matrix::Matrix<T, 3, 1>::IDENTITY: Self
impl<T: vectormatrix::types::sealed::Constants> vectormatrix::matrix::Matrix<T, 3, 2>
pub const vectormatrix::matrix::Matrix<T, 3, 2>::IDENTITY: Self
impl<T: vectormatrix::types::sealed::Constants> vectormatrix::matrix::Matrix<T, 3, 3>
pub const vectormatrix::matrix::Matrix<T, 3, 3>::IDENTITY: Self
impl<T: vectormatrix::types::sealed::Constants> vectormatrix::matrix::Matrix<T, 3, 3>
pub fn vectormatrix::matrix::Matrix<T, 3, 3>::determinant(self) -> T where T: core::clone::Clone + core::ops::arith::Sub<Output = T> + core::ops::arith::Mul<Output = T> + core::ops::arith::Add<Output = T>
pub fn vectormatrix::matrix::Matrix<T, 3, 3>::inverse(self) -> core::option::Option<Self> where T: core::clone::Clone + core::ops::arith::Div<Output = T> + core::ops::arith::Mul<Output = T> + core::ops::arith::Sub<Output = T> + core::ops::arith::Add<Output = T> + core::ops::arith::Neg<Output = T> + core::cmp::PartialEq
pub fn vectormatrix::matrix::Matrix<T, 3, 3>::rotation_matrix(theta: T) -> Self where T: vectormatrix::types::sealed::Float + core::ops::arith::Neg<Output = T> + core::clone::Clone
pub const fn vectormatrix::matrix::Matrix<T, 3, 3>::scaling_matrix(sx: T, sy: T) -> Self
pub const fn vectormatrix::matrix::Matrix<T, 3, 3>::shear_matrix(sx: T, sy: T) -> Self
pub const fn vectormatrix::matrix::Matrix<T, 3, 3>::translation_matrix(dx: T, dy: T) -> Self
impl<T: vectormatrix::types::sealed::Constants> vectormatrix::matrix::Matrix<T, 3, 4>
pub const vectormatrix::matrix::Matrix<T, 3, 4>::IDENTITY: Self
impl<T: vectormatrix::types::sealed::Constants> vectormatrix::matrix::Matrix<T, 4, 1>
pub const vectormatrix::matrix::Matrix<T, 4, 1>::IDENTITY: Self
impl<T: vectormatrix::types::sealed::Constants> vectormatrix::matrix::Matrix<T, 4, 2>
pub const vectormatrix::matrix::Matrix<T, 4, 2>::IDENTITY: Self
impl<T: vectormatrix::types::sealed::Constants> vectormatrix::matrix::Matrix<T, 4, 3>
pub const vectormatrix::matrix::Matrix<T, 4, 3>::IDENTITY: Self
impl<T: vectormatrix::types::sealed::Constants> vectormatrix::matrix::Matrix<T, 4, 4>
pub const vectormatrix::matrix::Matrix<T, 4, 4>::IDENTITY: Self
impl<T> vectormatrix::matrix::Matrix<T, 2, 2>
pub fn vectormatrix::matrix::Matrix<T, 2, 2>::determinant(self) -> T where T: core::clone::Clone + core::ops::arith::Sub<Output = T> + core::ops::arith::Mul<Output = T>
pub fn vectormatrix::matrix::Matrix<T, 2, 2>::inverse(self) -> core::option::Option<Self> where T: vectormatrix::types::sealed::Constants + core::ops::arith::Div<Output = T> + core::ops::arith::Sub<Output = T> + core::ops::arith::Mul<Output = T> + core::cmp::PartialEq + core::ops::arith::Neg<Output = T> + core::clone::Clone
impl<T> vectormatrix::matrix::Matrix<T, 4, 4>
pub fn vectormatrix::matrix::Matrix<T, 4, 4>::determinant(self) -> T where T: core::clone::Clone + core::ops::arith::Mul<Output = T> + core::ops::arith::Sub<Output = T> + core::ops::arith::Add<Output = T> + core::ops::arith::Neg<Output = T>
pub fn vectormatrix::matrix::Matrix<T, 4, 4>::inverse(self) -> core::option::Option<Self> where T: vectormatrix::types::sealed::Constants + core::clone::Clone + core::ops::arith::Mul<Output = T> + core::ops::arith::Sub<Output = T> + core::ops::arith::Add<Output = T> + core::ops::arith::Neg<Output = T> + core::ops::arith::Div<Output = T> + core::cmp::PartialEq
pub fn vectormatrix::matrix::Matrix<T, 4, 4>::rotation_matrix_x(theta: T) -> Self where T: vectormatrix::types::sealed::Float + core::ops::arith::Neg<Output = T> + core::clone::Clone + vectormatrix::types::sealed::Constants
pub fn vectormatrix::matrix::Matrix<T, 4, 4>::rotation_matrix_y(theta: T) -> Self where T: vectormatrix::types::sealed::Float + core::ops::arith::Neg<Output = T> + core::clone::Clone + vectormatrix::types::sealed::Constants
pub fn vectormatrix::matrix::Matrix<T, 4, 4>::rotation_matrix_z(theta: T) -> Self where T: vectormatrix::types::sealed::Float + core::ops::arith::Neg<Output = T> + core::clone::Clone + vectormatrix::types::sealed::Constants
pub const fn vectormatrix::matrix::Matrix<T, 4, 4>::scaling_matrix(sx: T, sy: T, sz: T) -> Self where T: vectormatrix::types::sealed::Constants
pub const fn vectormatrix::matrix::Matrix<T, 4, 4>::shear_matrix(sxy: T, sxz: T, syx: T, syz: T, szx: T, szy: T) -> Self where T: vectormatrix::types::sealed::Constants
pub const fn vectormatrix::matrix::Matrix<T, 4, 4>::translation_matrix(dx: T, dy: T, dz: T) -> Self where T: vectormatrix::types::sealed::Constants
impl<T, const M: usize, const N: usize, const P: usize> core::ops::arith::Mul<vectormatrix::matrix::Matrix<T, N, P>> for vectormatrix::matrix::Matrix<T, M, N> where T: core::clone::Clone + core::ops::arith::Mul<Output = T> + core::ops::arith::Add<Output = T>
pub type vectormatrix::matrix::Matrix<T, M, N>::Output = vectormatrix::matrix::Matrix<T, M, P>
pub fn vectormatrix::matrix::Matrix<T, M, N>::mul(self, other: vectormatrix::matrix::Matrix<T, N, P>) -> Self::Output
impl<T, const N: usize, const M: usize> core::ops::arith::Mul<vectormatrix::matrix::Matrix<T, M, N>> for vectormatrix::vector::Vector<T, M> where T: core::clone::Clone + core::ops::arith::Mul<Output = T> + core::ops::arith::Add<Output = T>
pub type vectormatrix::vector::Vector<T, M>::Output = vectormatrix::matrix::Matrix<T, 1, N>
pub fn vectormatrix::vector::Vector<T, M>::mul(self, rhs: vectormatrix::matrix::Matrix<T, M, N>) -> Self::Output
impl<T, const R: usize, const C: usize> core::convert::AsMut<[vectormatrix::vector::Vector<T, R>; C]> for vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::as_mut(&mut self) -> &mut [vectormatrix::vector::Vector<T, R>; C]
impl<T, const R: usize, const C: usize> core::convert::AsRef<[vectormatrix::vector::Vector<T, R>; C]> for vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::as_ref(&self) -> &[vectormatrix::vector::Vector<T, R>; C]
impl<T, const R: usize, const C: usize> core::convert::From<[vectormatrix::vector::Vector<T, R>; C]> for vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::from(arr: [vectormatrix::vector::Vector<T, R>; C]) -> Self
impl<T, const R: usize, const C: usize> core::convert::From<vectormatrix::matrix::Matrix<T, R, C>> for [vectormatrix::vector::Vector<T, R>; C]
pub fn [vectormatrix::vector::Vector<T, R>; C]::from(m: vectormatrix::matrix::Matrix<T, R, C>) -> Self
impl<T, const R: usize, const C: usize> core::default::Default for vectormatrix::matrix::Matrix<T, R, C> where T: core::marker::Copy + core::default::Default
pub fn vectormatrix::matrix::Matrix<T, R, C>::default() -> Self
impl<T, const R: usize, const C: usize> core::fmt::Debug for vectormatrix::matrix::Matrix<T, R, C> where T: core::fmt::Debug
pub fn vectormatrix::matrix::Matrix<T, R, C>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
impl<T, const R: usize, const C: usize> core::marker::StructuralPartialEq for vectormatrix::matrix::Matrix<T, R, C>
impl<T, const R: usize, const C: usize> core::ops::arith::Add<T> for vectormatrix::matrix::Matrix<T, R, C> where T: core::ops::arith::Add<Output = T> + core::clone::Clone
pub type vectormatrix::matrix::Matrix<T, R, C>::Output = vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::add(self, other: T) -> Self
impl<T, const R: usize, const C: usize> core::ops::arith::AddAssign<T> for vectormatrix::matrix::Matrix<T, R, C> where T: core::ops::arith::AddAssign + core::clone::Clone
pub fn vectormatrix::matrix::Matrix<T, R, C>::add_assign(&mut self, other: T)
impl<T, const R: usize, const C: usize> core::ops::arith::Div<T> for vectormatrix::matrix::Matrix<T, R, C> where T: core::ops::arith::Div<Output = T> + core::clone::Clone
pub type vectormatrix::matrix::Matrix<T, R, C>::Output = vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::div(self, other: T) -> Self
impl<T, const R: usize, const C: usize> core::ops::arith::Mul<T> for vectormatrix::matrix::Matrix<T, R, C> where T: core::ops::arith::Mul<Output = T> + core::clone::Clone
pub type vectormatrix::matrix::Matrix<T, R, C>::Output = vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::mul(self, other: T) -> Self
impl<T, const R: usize, const C: usize> core::ops::arith::Mul<vectormatrix::vector::Vector<T, C>> for vectormatrix::matrix::Matrix<T, R, C> where T: core::clone::Clone + core::ops::arith::Mul<Output = T> + core::ops::arith::Add<Output = T>
pub type vectormatrix::matrix::Matrix<T, R, C>::Output = vectormatrix::matrix::Matrix<T, R, 1>
pub fn vectormatrix::matrix::Matrix<T, R, C>::mul(self, other: vectormatrix::vector::Vector<T, C>) -> Self::Output
impl<T, const R: usize, const C: usize> core::ops::arith::Sub<T> for vectormatrix::matrix::Matrix<T, R, C> where T: core::ops::arith::Sub<Output = T> + core::clone::Clone
pub type vectormatrix::matrix::Matrix<T, R, C>::Output = vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::sub(self, other: T) -> Self
impl<T, const R: usize, const C: usize> core::ops::arith::SubAssign<T> for vectormatrix::matrix::Matrix<T, R, C> where T: core::ops::arith::SubAssign + core::clone::Clone
pub fn vectormatrix::matrix::Matrix<T, R, C>::sub_assign(&mut self, other: T)
impl<T: core::clone::Clone + core::ops::arith::AddAssign, const R: usize, const C: usize> core::ops::arith::AddAssign for vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::add_assign(&mut self, other: Self)
impl<T: core::clone::Clone + core::ops::arith::DivAssign, const R: usize, const C: usize> core::ops::arith::DivAssign for vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::div_assign(&mut self, other: Self)
impl<T: core::clone::Clone + core::ops::arith::MulAssign, const R: usize, const C: usize> core::ops::arith::MulAssign for vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::mul_assign(&mut self, other: Self)
impl<T: core::clone::Clone + core::ops::arith::SubAssign, const R: usize, const C: usize> core::ops::arith::SubAssign for vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::sub_assign(&mut self, other: Self)
impl<T: core::clone::Clone, const R: usize, const C: usize> core::clone::Clone for vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::clone(&self) -> vectormatrix::matrix::Matrix<T, R, C>
impl<T: core::cmp::Eq, const R: usize, const C: usize> core::cmp::Eq for vectormatrix::matrix::Matrix<T, R, C>
impl<T: core::cmp::Ord, const R: usize, const C: usize> core::cmp::Ord for vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::cmp(&self, other: &vectormatrix::matrix::Matrix<T, R, C>) -> core::cmp::Ordering
impl<T: core::cmp::PartialEq, const R: usize, const C: usize> core::cmp::PartialEq for vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::eq(&self, other: &vectormatrix::matrix::Matrix<T, R, C>) -> bool
impl<T: core::cmp::PartialOrd, const R: usize, const C: usize> core::cmp::PartialOrd for vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::partial_cmp(&self, other: &vectormatrix::matrix::Matrix<T, R, C>) -> core::option::Option<core::cmp::Ordering>
impl<T: core::hash::Hash, const R: usize, const C: usize> core::hash::Hash for vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
impl<T: core::marker::Copy, const R: usize, const C: usize> core::marker::Copy for vectormatrix::matrix::Matrix<T, R, C>
impl<T: vectormatrix::types::sealed::Constants + core::clone::Clone + core::ops::arith::Add<Output = T>, const R: usize, const C: usize> core::ops::arith::Add for vectormatrix::matrix::Matrix<T, R, C>
pub type vectormatrix::matrix::Matrix<T, R, C>::Output = vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::add(self, other: Self) -> Self
impl<T: vectormatrix::types::sealed::Constants + core::clone::Clone + core::ops::arith::Sub<Output = T>, const R: usize, const C: usize> core::ops::arith::Sub for vectormatrix::matrix::Matrix<T, R, C>
pub type vectormatrix::matrix::Matrix<T, R, C>::Output = vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::sub(self, other: Self) -> Self
impl<T, const R: usize, const C: usize> core::marker::Freeze for vectormatrix::matrix::Matrix<T, R, C> where T: core::marker::Freeze
impl<T, const R: usize, const C: usize> core::marker::Send for vectormatrix::matrix::Matrix<T, R, C> where T: core::marker::Send
impl<T, const R: usize, const C: usize> core::marker::Sync for vectormatrix::matrix::Matrix<T, R, C> where T: core::marker::Sync
impl<T, const R: usize, const C: usize> core::marker::Unpin for vectormatrix::matrix::Matrix<T, R, C> where T: core::marker::Unpin
impl<T, const R: usize, const C: usize> core::panic::unwind_safe::RefUnwindSafe for vectormatrix::matrix::Matrix<T, R, C> where T: core::panic::unwind_safe::RefUnwindSafe
impl<T, const R: usize, const C: usize> core::panic::unwind_safe::UnwindSafe for vectormatrix::matrix::Matrix<T, R, C> where T: core::panic::unwind_safe::UnwindSafe
impl<T, U> core::convert::Into<U> for vectormatrix::matrix::Matrix<T, R, C> where U: core::convert::From<T>
pub fn vectormatrix::matrix::Matrix<T, R, C>::into(self) -> U
impl<T, U> core::convert::TryFrom<U> for vectormatrix::matrix::Matrix<T, R, C> where U: core::convert::Into<T>
pub type vectormatrix::matrix::Matrix<T, R, C>::Error = core::convert::Infallible
pub fn vectormatrix::matrix::Matrix<T, R, C>::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error>
impl<T, U> core::convert::TryInto<U> for vectormatrix::matrix::Matrix<T, R, C> where U: core::convert::TryFrom<T>
pub type vectormatrix::matrix::Matrix<T, R, C>::Error = <U as core::convert::TryFrom<T>>::Error
pub fn vectormatrix::matrix::Matrix<T, R, C>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
impl<T> alloc::borrow::ToOwned for vectormatrix::matrix::Matrix<T, R, C> where T: core::clone::Clone
pub type vectormatrix::matrix::Matrix<T, R, C>::Owned = T
pub fn vectormatrix::matrix::Matrix<T, R, C>::clone_into(&self, target: &mut T)
pub fn vectormatrix::matrix::Matrix<T, R, C>::to_owned(&self) -> T
impl<T> core::any::Any for vectormatrix::matrix::Matrix<T, R, C> where T: 'static + ?core::marker::Sized
pub fn vectormatrix::matrix::Matrix<T, R, C>::type_id(&self) -> core::any::TypeId
impl<T> core::borrow::Borrow<T> for vectormatrix::matrix::Matrix<T, R, C> where T: ?core::marker::Sized
pub fn vectormatrix::matrix::Matrix<T, R, C>::borrow(&self) -> &T
impl<T> core::borrow::BorrowMut<T> for vectormatrix::matrix::Matrix<T, R, C> where T: ?core::marker::Sized
pub fn vectormatrix::matrix::Matrix<T, R, C>::borrow_mut(&mut self) -> &mut T
impl<T> core::clone::CloneToUninit for vectormatrix::matrix::Matrix<T, R, C> where T: core::clone::Clone
pub unsafe fn vectormatrix::matrix::Matrix<T, R, C>::clone_to_uninit(&self, dest: *mut u8)
impl<T> core::convert::From<T> for vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::from(t: T) -> T
pub mod vectormatrix::vector
pub struct vectormatrix::vector::NormalizedVector<T, const N: usize>(_)
impl<T, const N: usize> vectormatrix::vector::NormalizedVector<T, N>
pub const fn vectormatrix::vector::NormalizedVector<T, N>::as_vector(&self) -> &vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::NormalizedVector<T, N>::into_vector(self) -> vectormatrix::vector::Vector<T, N>
impl<T, const N: usize> core::convert::AsRef<vectormatrix::vector::Vector<T, N>> for vectormatrix::vector::NormalizedVector<T, N>
pub fn vectormatrix::vector::NormalizedVector<T, N>::as_ref(&self) -> &vectormatrix::vector::Vector<T, N>
impl<T, const N: usize> core::convert::From<vectormatrix::vector::NormalizedVector<T, N>> for vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::from(value: vectormatrix::vector::NormalizedVector<T, N>) -> Self
impl<T, const N: usize> core::convert::From<vectormatrix::vector::Vector<T, N>> for vectormatrix::vector::NormalizedVector<T, N> where T: core::ops::arith::Add<Output = T> + core::clone::Clone + core::ops::arith::Div<Output = T> + core::ops::arith::Mul<Output = T> + vectormatrix::types::sealed::Float
pub fn vectormatrix::vector::NormalizedVector<T, N>::from(value: vectormatrix::vector::Vector<T, N>) -> Self
impl<T, const N: usize> core::marker::StructuralPartialEq for vectormatrix::vector::NormalizedVector<T, N>
impl<T, const N: usize> core::ops::deref::Deref for vectormatrix::vector::NormalizedVector<T, N>
pub type vectormatrix::vector::NormalizedVector<T, N>::Target = vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::NormalizedVector<T, N>::deref(&self) -> &Self::Target
impl<T: core::clone::Clone, const N: usize> core::clone::Clone for vectormatrix::vector::NormalizedVector<T, N>
pub fn vectormatrix::vector::NormalizedVector<T, N>::clone(&self) -> vectormatrix::vector::NormalizedVector<T, N>
impl<T: core::cmp::Eq, const N: usize> core::cmp::Eq for vectormatrix::vector::NormalizedVector<T, N>
impl<T: core::cmp::Ord, const N: usize> core::cmp::Ord for vectormatrix::vector::NormalizedVector<T, N>
pub fn vectormatrix::vector::NormalizedVector<T, N>::cmp(&self, other: &vectormatrix::vector::NormalizedVector<T, N>) -> core::cmp::Ordering
impl<T: core::cmp::PartialEq, const N: usize> core::cmp::PartialEq for vectormatrix::vector::NormalizedVector<T, N>
pub fn vectormatrix::vector::NormalizedVector<T, N>::eq(&self, other: &vectormatrix::vector::NormalizedVector<T, N>) -> bool
impl<T: core::cmp::PartialOrd, const N: usize> core::cmp::PartialOrd for vectormatrix::vector::NormalizedVector<T, N>
pub fn vectormatrix::vector::NormalizedVector<T, N>::partial_cmp(&self, other: &vectormatrix::vector::NormalizedVector<T, N>) -> core::option::Option<core::cmp::Ordering>
impl<T: core::fmt::Debug, const N: usize> core::fmt::Debug for vectormatrix::vector::NormalizedVector<T, N>
pub fn vectormatrix::vector::NormalizedVector<T, N>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
impl<T: core::hash::Hash, const N: usize> core::hash::Hash for vectormatrix::vector::NormalizedVector<T, N>
pub fn vectormatrix::vector::NormalizedVector<T, N>::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
impl<T: core::marker::Copy, const N: usize> core::marker::Copy for vectormatrix::vector::NormalizedVector<T, N>
impl<T, const N: usize> core::marker::Freeze for vectormatrix::vector::NormalizedVector<T, N> where T: core::marker::Freeze
impl<T, const N: usize> core::marker::Send for vectormatrix::vector::NormalizedVector<T, N> where T: core::marker::Send
impl<T, const N: usize> core::marker::Sync for vectormatrix::vector::NormalizedVector<T, N> where T: core::marker::Sync
impl<T, const N: usize> core::marker::Unpin for vectormatrix::vector::NormalizedVector<T, N> where T: core::marker::Unpin
impl<T, const N: usize> core::panic::unwind_safe::RefUnwindSafe for vectormatrix::vector::NormalizedVector<T, N> where T: core::panic::unwind_safe::RefUnwindSafe
impl<T, const N: usize> core::panic::unwind_safe::UnwindSafe for vectormatrix::vector::NormalizedVector<T, N> where T: core::panic::unwind_safe::UnwindSafe
impl<P, T> core::ops::deref::Receiver for vectormatrix::vector::NormalizedVector<T, N> where P: core::ops::deref::Deref<Target = T> + ?core::marker::Sized, T: ?core::marker::Sized
pub type vectormatrix::vector::NormalizedVector<T, N>::Target = T
impl<T, U> core::convert::Into<U> for vectormatrix::vector::NormalizedVector<T, N> where U: core::convert::From<T>
pub fn vectormatrix::vector::NormalizedVector<T, N>::into(self) -> U
impl<T, U> core::convert::TryFrom<U> for vectormatrix::vector::NormalizedVector<T, N> where U: core::convert::Into<T>
pub type vectormatrix::vector::NormalizedVector<T, N>::Error = core::convert::Infallible
pub fn vectormatrix::vector::NormalizedVector<T, N>::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error>
impl<T, U> core::convert::TryInto<U> for vectormatrix::vector::NormalizedVector<T, N> where U: core::convert::TryFrom<T>
pub type vectormatrix::vector::NormalizedVector<T, N>::Error = <U as core::convert::TryFrom<T>>::Error
pub fn vectormatrix::vector::NormalizedVector<T, N>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
impl<T> alloc::borrow::ToOwned for vectormatrix::vector::NormalizedVector<T, N> where T: core::clone::Clone
pub type vectormatrix::vector::NormalizedVector<T, N>::Owned = T
pub fn vectormatrix::vector::NormalizedVector<T, N>::clone_into(&self, target: &mut T)
pub fn vectormatrix::vector::NormalizedVector<T, N>::to_owned(&self) -> T
impl<T> core::any::Any for vectormatrix::vector::NormalizedVector<T, N> where T: 'static + ?core::marker::Sized
pub fn vectormatrix::vector::NormalizedVector<T, N>::type_id(&self) -> core::any::TypeId
impl<T> core::borrow::Borrow<T> for vectormatrix::vector::NormalizedVector<T, N> where T: ?core::marker::Sized
pub fn vectormatrix::vector::NormalizedVector<T, N>::borrow(&self) -> &T
impl<T> core::borrow::BorrowMut<T> for vectormatrix::vector::NormalizedVector<T, N> where T: ?core::marker::Sized
pub fn vectormatrix::vector::NormalizedVector<T, N>::borrow_mut(&mut self) -> &mut T
impl<T> core::clone::CloneToUninit for vectormatrix::vector::NormalizedVector<T, N> where T: core::clone::Clone
pub unsafe fn vectormatrix::vector::NormalizedVector<T, N>::clone_to_uninit(&self, dest: *mut u8)
impl<T> core::convert::From<T> for vectormatrix::vector::NormalizedVector<T, N>
pub fn vectormatrix::vector::NormalizedVector<T, N>::from(t: T) -> T
pub struct vectormatrix::vector::Vector<T, const N: usize>(_)
impl<T, const N: usize> vectormatrix::vector::Vector<T, N> where T: core::clone::Clone
pub fn vectormatrix::vector::Vector<T, N>::from_col(col: vectormatrix::matrix::Matrix<T, N, 1>) -> Self
pub fn vectormatrix::vector::Vector<T, N>::from_row(row: vectormatrix::matrix::Matrix<T, 1, N>) -> Self
pub fn vectormatrix::vector::Vector<T, N>::to_col(self) -> vectormatrix::matrix::Matrix<T, N, 1>
pub fn vectormatrix::vector::Vector<T, N>::to_row(self) -> vectormatrix::matrix::Matrix<T, 1, N>
impl<T, const N: usize> vectormatrix::vector::Vector<T, N> where T: core::clone::Clone
pub fn vectormatrix::vector::Vector<T, N>::map<F, U>(self, f: F) -> vectormatrix::vector::Vector<U, N> where F: core::ops::function::FnMut(T) -> U
impl<T, const N: usize> vectormatrix::vector::Vector<T, N> where [T; N]: vectormatrix::vector::private::AtLeastFour
pub const fn vectormatrix::vector::Vector<T, N>::w(&self) -> &T
pub const fn vectormatrix::vector::Vector<T, N>::w_mut(&mut self) -> &mut T
impl<T, const N: usize> vectormatrix::vector::Vector<T, N> where [T; N]: vectormatrix::vector::private::AtLeastOne
pub const fn vectormatrix::vector::Vector<T, N>::x(&self) -> &T
pub const fn vectormatrix::vector::Vector<T, N>::x_mut(&mut self) -> &mut T
impl<T, const N: usize> vectormatrix::vector::Vector<T, N> where [T; N]: vectormatrix::vector::private::AtLeastThree
pub const fn vectormatrix::vector::Vector<T, N>::z(&self) -> &T
pub const fn vectormatrix::vector::Vector<T, N>::z_mut(&mut self) -> &mut T
impl<T, const N: usize> vectormatrix::vector::Vector<T, N> where [T; N]: vectormatrix::vector::private::AtLeastTwo
pub const fn vectormatrix::vector::Vector<T, N>::y(&self) -> &T
pub const fn vectormatrix::vector::Vector<T, N>::y_mut(&mut self) -> &mut T
impl<T, const N: usize> vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::into_inner(self) -> [T; N]
pub const fn vectormatrix::vector::Vector<T, N>::new(value: [T; N]) -> Self
impl<T, const N: usize> vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::map_in_place<F>(&mut self, f: F) where F: core::ops::function::FnMut(&mut T)
impl<T, const N: usize> vectormatrix::vector::Vector<core::mem::maybe_uninit::MaybeUninit<T>, N> where T: core::marker::Sized
pub unsafe fn vectormatrix::vector::Vector<core::mem::maybe_uninit::MaybeUninit<T>, N>::assume_init(self) -> vectormatrix::vector::Vector<T, N>
impl<T, const N: usize> vectormatrix::vector::Vector<core::mem::maybe_uninit::MaybeUninit<T>, N>
pub const vectormatrix::vector::Vector<core::mem::maybe_uninit::MaybeUninit<T>, N>::UNINIT: Self
impl<T: core::cmp::PartialOrd + core::clone::Clone, const N: usize> vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::clamp(self, min: T, max: T) -> Self
impl<T: core::cmp::PartialOrd + core::clone::Clone, const N: usize> vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::max(self) -> T
pub fn vectormatrix::vector::Vector<T, N>::min(self) -> T
impl<T: core::ops::arith::Add<Output = T> + core::clone::Clone, const N: usize> vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::add_scalar(self, other: T) -> Self
impl<T: core::ops::arith::Add<Output = T> + core::clone::Clone, const N: usize> vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::elementwise_add(self, other: Self) -> Self
impl<T: core::ops::arith::AddAssign + core::clone::Clone, const N: usize> vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::add_assign_scalar(&mut self, other: T)
impl<T: core::ops::arith::AddAssign + core::clone::Clone, const N: usize> vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::add_elementwise_assign(&mut self, other: Self)
impl<T: core::ops::arith::Div<Output = T> + core::clone::Clone + core::ops::arith::Mul<Output = T> + core::ops::arith::Add<Output = T> + vectormatrix::types::sealed::Float, const N: usize> vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::normalize(self) -> vectormatrix::vector::NormalizedVector<T, N>
impl<T: core::ops::arith::Div<Output = T> + core::clone::Clone, const N: usize> vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::div_scalar(self, other: T) -> Self
impl<T: core::ops::arith::Div<Output = T> + core::clone::Clone, const N: usize> vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::elementwise_div(self, other: Self) -> Self
impl<T: core::ops::arith::DivAssign + core::clone::Clone, const N: usize> vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::div_assign_scalar(&mut self, other: T)
impl<T: core::ops::arith::Mul<Output = T> + core::clone::Clone + core::ops::arith::Add<Output = T> + vectormatrix::types::sealed::Float, const N: usize> vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::length(self) -> T
impl<T: core::ops::arith::Mul<Output = T> + core::clone::Clone + core::ops::arith::Add<Output = T>, const N: usize> vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::dot(self, other: Self) -> T
impl<T: core::ops::arith::Mul<Output = T> + core::clone::Clone + core::ops::arith::Add<Output = T>, const N: usize> vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::length_squared(self) -> T
impl<T: core::ops::arith::Mul<Output = T> + core::clone::Clone, const N: usize> vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::elementwise_mul(self, other: Self) -> Self
impl<T: core::ops::arith::Mul<Output = T> + core::clone::Clone, const N: usize> vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::mul_scalar(self, other: T) -> Self
impl<T: core::ops::arith::MulAssign + core::clone::Clone, const N: usize> vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::mul_assign_scalar(&mut self, other: T)
impl<T: core::ops::arith::Sub<Output = T> + core::clone::Clone + core::marker::Copy + core::ops::arith::Mul<Output = T> + core::ops::arith::Add<Output = T> + vectormatrix::types::sealed::Float, const N: usize> vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::euclid_distance_to(self, other: Self) -> T
impl<T: core::ops::arith::Sub<Output = T> + core::clone::Clone + core::marker::Copy + core::ops::arith::Mul<Output = T> + core::ops::arith::Add<Output = T>> vectormatrix::vector::Vector<T, 3>
pub fn vectormatrix::vector::Vector<T, 3>::cross(self, other: Self) -> Self
impl<T: core::ops::arith::Sub<Output = T> + core::clone::Clone, const N: usize> vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::elementwise_sub(self, other: Self) -> Self
impl<T: core::ops::arith::Sub<Output = T> + core::clone::Clone, const N: usize> vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::sub_scalar(self, other: T) -> Self
impl<T: core::ops::arith::SubAssign + core::clone::Clone, const N: usize> vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::sub_assign_scalar(&mut self, other: T)
impl<T: core::ops::arith::SubAssign + core::clone::Clone, const N: usize> vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::sub_elementwise_assign(&mut self, other: Self)
impl<T: vectormatrix::types::sealed::Constants, const N: usize> vectormatrix::vector::Vector<T, N>
pub const vectormatrix::vector::Vector<T, N>::ONE: Self
pub const vectormatrix::vector::Vector<T, N>::ZERO: Self
impl<T: vectormatrix::types::sealed::Float + core::clone::Clone, const N: usize> vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::eq_approx(self, other: Self, tolerance: T) -> bool
impl<T: vectormatrix::types::sealed::Float + vectormatrix::types::sealed::Constants + core::clone::Clone + core::ops::arith::Sub<Output = T> + core::ops::arith::Mul<Output = T> + core::ops::arith::Add<Output = T>, const N: usize> vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::mix(self, other: Self, weight: T) -> Self
impl<T, const N: usize, const M: usize> core::ops::arith::Mul<vectormatrix::matrix::Matrix<T, M, N>> for vectormatrix::vector::Vector<T, M> where T: core::clone::Clone + core::ops::arith::Mul<Output = T> + core::ops::arith::Add<Output = T>
pub type vectormatrix::vector::Vector<T, M>::Output = vectormatrix::matrix::Matrix<T, 1, N>
pub fn vectormatrix::vector::Vector<T, M>::mul(self, rhs: vectormatrix::matrix::Matrix<T, M, N>) -> Self::Output
impl<T, const N: usize> core::convert::AsMut<[T; N]> for vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::as_mut(&mut self) -> &mut [T; N]
impl<T, const N: usize> core::convert::AsRef<[T; N]> for vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::as_ref(&self) -> &[T; N]
impl<T, const N: usize> core::convert::AsRef<vectormatrix::vector::Vector<T, N>> for vectormatrix::vector::NormalizedVector<T, N>
pub fn vectormatrix::vector::NormalizedVector<T, N>::as_ref(&self) -> &vectormatrix::vector::Vector<T, N>
impl<T, const N: usize> core::convert::From<[T; N]> for vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::from(value: [T; N]) -> Self
impl<T, const N: usize> core::convert::From<vectormatrix::vector::NormalizedVector<T, N>> for vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::from(value: vectormatrix::vector::NormalizedVector<T, N>) -> Self
impl<T, const N: usize> core::convert::From<vectormatrix::vector::Vector<T, N>> for [T; N]
pub fn [T; N]::from(value: vectormatrix::vector::Vector<T, N>) -> Self
impl<T, const N: usize> core::convert::From<vectormatrix::vector::Vector<T, N>> for vectormatrix::vector::NormalizedVector<T, N> where T: core::ops::arith::Add<Output = T> + core::clone::Clone + core::ops::arith::Div<Output = T> + core::ops::arith::Mul<Output = T> + vectormatrix::types::sealed::Float
pub fn vectormatrix::vector::NormalizedVector<T, N>::from(value: vectormatrix::vector::Vector<T, N>) -> Self
impl<T, const N: usize> core::default::Default for vectormatrix::vector::Vector<T, N> where T: core::default::Default + core::marker::Copy
pub fn vectormatrix::vector::Vector<T, N>::default() -> Self
impl<T, const N: usize> core::marker::StructuralPartialEq for vectormatrix::vector::Vector<T, N>
impl<T, const N: usize> core::ops::index::Index<usize> for vectormatrix::vector::Vector<T, N>
pub type vectormatrix::vector::Vector<T, N>::Output = T
pub fn vectormatrix::vector::Vector<T, N>::index(&self, index: usize) -> &Self::Output
impl<T, const N: usize> core::ops::index::IndexMut<usize> for vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::index_mut(&mut self, index: usize) -> &mut Self::Output
impl<T, const R: usize, const C: usize> core::ops::arith::Mul<vectormatrix::vector::Vector<T, C>> for vectormatrix::matrix::Matrix<T, R, C> where T: core::clone::Clone + core::ops::arith::Mul<Output = T> + core::ops::arith::Add<Output = T>
pub type vectormatrix::matrix::Matrix<T, R, C>::Output = vectormatrix::matrix::Matrix<T, R, 1>
pub fn vectormatrix::matrix::Matrix<T, R, C>::mul(self, other: vectormatrix::vector::Vector<T, C>) -> Self::Output
impl<T: core::clone::Clone, const N: usize> core::clone::Clone for vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::clone(&self) -> vectormatrix::vector::Vector<T, N>
impl<T: core::cmp::Eq, const N: usize> core::cmp::Eq for vectormatrix::vector::Vector<T, N>
impl<T: core::cmp::Ord, const N: usize> core::cmp::Ord for vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::cmp(&self, other: &vectormatrix::vector::Vector<T, N>) -> core::cmp::Ordering
impl<T: core::cmp::PartialEq, const N: usize> core::cmp::PartialEq for vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::eq(&self, other: &vectormatrix::vector::Vector<T, N>) -> bool
impl<T: core::cmp::PartialOrd, const N: usize> core::cmp::PartialOrd for vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::partial_cmp(&self, other: &vectormatrix::vector::Vector<T, N>) -> core::option::Option<core::cmp::Ordering>
impl<T: core::fmt::Debug, const N: usize> core::fmt::Debug for vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
impl<T: core::hash::Hash, const N: usize> core::hash::Hash for vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
impl<T: core::marker::Copy, const N: usize> core::marker::Copy for vectormatrix::vector::Vector<T, N>
impl<T: core::ops::arith::Add<Output = T> + core::clone::Clone, const N: usize> core::ops::arith::Add for vectormatrix::vector::Vector<T, N>
pub type vectormatrix::vector::Vector<T, N>::Output = vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::add(self, other: Self) -> Self
impl<T: core::ops::arith::Add<Output = T> + core::clone::Clone, const N: usize> core::ops::arith::Add<T> for vectormatrix::vector::Vector<T, N>
pub type vectormatrix::vector::Vector<T, N>::Output = vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::add(self, other: T) -> Self
impl<T: core::ops::arith::AddAssign + core::clone::Clone, const N: usize> core::ops::arith::AddAssign for vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::add_assign(&mut self, other: Self)
impl<T: core::ops::arith::AddAssign + core::clone::Clone, const N: usize> core::ops::arith::AddAssign<T> for vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::add_assign(&mut self, other: T)
impl<T: core::ops::arith::Div<Output = T> + core::clone::Clone, const N: usize> core::ops::arith::Div for vectormatrix::vector::Vector<T, N>
pub type vectormatrix::vector::Vector<T, N>::Output = vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::div(self, other: Self) -> Self
impl<T: core::ops::arith::Div<Output = T> + core::clone::Clone, const N: usize> core::ops::arith::Div<T> for vectormatrix::vector::Vector<T, N>
pub type vectormatrix::vector::Vector<T, N>::Output = vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::div(self, other: T) -> Self
impl<T: core::ops::arith::DivAssign + core::clone::Clone, const N: usize> core::ops::arith::DivAssign for vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::div_assign(&mut self, other: Self)
impl<T: core::ops::arith::DivAssign + core::clone::Clone, const N: usize> core::ops::arith::DivAssign<T> for vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::div_assign(&mut self, other: T)
impl<T: core::ops::arith::Mul<Output = T> + core::clone::Clone, const N: usize> core::ops::arith::Mul for vectormatrix::vector::Vector<T, N>
pub type vectormatrix::vector::Vector<T, N>::Output = vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::mul(self, other: Self) -> Self
impl<T: core::ops::arith::Mul<Output = T> + core::clone::Clone, const N: usize> core::ops::arith::Mul<T> for vectormatrix::vector::Vector<T, N>
pub type vectormatrix::vector::Vector<T, N>::Output = vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::mul(self, other: T) -> Self
impl<T: core::ops::arith::MulAssign + core::clone::Clone, const N: usize> core::ops::arith::MulAssign for vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::mul_assign(&mut self, other: Self)
impl<T: core::ops::arith::MulAssign + core::clone::Clone, const N: usize> core::ops::arith::MulAssign<T> for vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::mul_assign(&mut self, other: T)
impl<T: core::ops::arith::Sub<Output = T> + core::clone::Clone, const N: usize> core::ops::arith::Sub for vectormatrix::vector::Vector<T, N>
pub type vectormatrix::vector::Vector<T, N>::Output = vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::sub(self, other: Self) -> Self
impl<T: core::ops::arith::Sub<Output = T> + core::clone::Clone, const N: usize> core::ops::arith::Sub<T> for vectormatrix::vector::Vector<T, N>
pub type vectormatrix::vector::Vector<T, N>::Output = vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::sub(self, other: T) -> Self
impl<T: core::ops::arith::SubAssign + core::clone::Clone, const N: usize> core::ops::arith::SubAssign for vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::sub_assign(&mut self, other: Self)
impl<T: core::ops::arith::SubAssign + core::clone::Clone, const N: usize> core::ops::arith::SubAssign<T> for vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::sub_assign(&mut self, other: T)
impl<T> core::convert::From<(T)> for vectormatrix::vector::Vector<T, 1>
pub fn vectormatrix::vector::Vector<T, 1>::from(value: (T)) -> Self
impl<T> core::convert::From<(T, T)> for vectormatrix::vector::Vector<T, 2>
pub fn vectormatrix::vector::Vector<T, 2>::from(value: (T, T)) -> Self
impl<T> core::convert::From<(T, T, T)> for vectormatrix::vector::Vector<T, 3>
pub fn vectormatrix::vector::Vector<T, 3>::from(value: (T, T, T)) -> Self
impl<T> core::convert::From<(T, T, T, T)> for vectormatrix::vector::Vector<T, 4>
pub fn vectormatrix::vector::Vector<T, 4>::from(value: (T, T, T, T)) -> Self
impl<T> core::convert::From<T> for vectormatrix::vector::Vector<T, 1>
pub fn vectormatrix::vector::Vector<T, 1>::from(value: T) -> Self
impl<T> core::convert::From<vectormatrix::vector::Vector<T, 1>> for (T)
pub fn (T)::from(value: vectormatrix::vector::Vector<T, 1>) -> Self
impl<T> core::convert::From<vectormatrix::vector::Vector<T, 2>> for (T, T)
pub fn (T, T)::from(value: vectormatrix::vector::Vector<T, 2>) -> Self
impl<T> core::convert::From<vectormatrix::vector::Vector<T, 3>> for (T, T, T)
pub fn (T, T, T)::from(value: vectormatrix::vector::Vector<T, 3>) -> Self
impl<T> core::convert::From<vectormatrix::vector::Vector<T, 4>> for (T, T, T, T)
pub fn (T, T, T, T)::from(value: vectormatrix::vector::Vector<T, 4>) -> Self
impl<T, const N: usize> core::marker::Freeze for vectormatrix::vector::Vector<T, N> where T: core::marker::Freeze
impl<T, const N: usize> core::marker::Send for vectormatrix::vector::Vector<T, N> where T: core::marker::Send
impl<T, const N: usize> core::marker::Sync for vectormatrix::vector::Vector<T, N> where T: core::marker::Sync
impl<T, const N: usize> core::marker::Unpin for vectormatrix::vector::Vector<T, N> where T: core::marker::Unpin
impl<T, const N: usize> core::panic::unwind_safe::RefUnwindSafe for vectormatrix::vector::Vector<T, N> where T: core::panic::unwind_safe::RefUnwindSafe
impl<T, const N: usize> core::panic::unwind_safe::UnwindSafe for vectormatrix::vector::Vector<T, N> where T: core::panic::unwind_safe::UnwindSafe
impl<T, U> core::convert::Into<U> for vectormatrix::vector::Vector<T, N> where U: core::convert::From<T>
pub fn vectormatrix::vector::Vector<T, N>::into(self) -> U
impl<T, U> core::convert::TryFrom<U> for vectormatrix::vector::Vector<T, N> where U: core::convert::Into<T>
pub type vectormatrix::vector::Vector<T, N>::Error = core::convert::Infallible
pub fn vectormatrix::vector::Vector<T, N>::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error>
impl<T, U> core::convert::TryInto<U> for vectormatrix::vector::Vector<T, N> where U: core::convert::TryFrom<T>
pub type vectormatrix::vector::Vector<T, N>::Error = <U as core::convert::TryFrom<T>>::Error
pub fn vectormatrix::vector::Vector<T, N>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
impl<T> alloc::borrow::ToOwned for vectormatrix::vector::Vector<T, N> where T: core::clone::Clone
pub type vectormatrix::vector::Vector<T, N>::Owned = T
pub fn vectormatrix::vector::Vector<T, N>::clone_into(&self, target: &mut T)
pub fn vectormatrix::vector::Vector<T, N>::to_owned(&self) -> T
impl<T> core::any::Any for vectormatrix::vector::Vector<T, N> where T: 'static + ?core::marker::Sized
pub fn vectormatrix::vector::Vector<T, N>::type_id(&self) -> core::any::TypeId
impl<T> core::borrow::Borrow<T> for vectormatrix::vector::Vector<T, N> where T: ?core::marker::Sized
pub fn vectormatrix::vector::Vector<T, N>::borrow(&self) -> &T
impl<T> core::borrow::BorrowMut<T> for vectormatrix::vector::Vector<T, N> where T: ?core::marker::Sized
pub fn vectormatrix::vector::Vector<T, N>::borrow_mut(&mut self) -> &mut T
impl<T> core::clone::CloneToUninit for vectormatrix::vector::Vector<T, N> where T: core::clone::Clone
pub unsafe fn vectormatrix::vector::Vector<T, N>::clone_to_uninit(&self, dest: *mut u8)
impl<T> core::convert::From<T> for vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::from(t: T) -> T
impl<T> core::convert::From<never> for vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::from(t: never) -> T
pub struct vectormatrix::Matrix<T, const R: usize, const C: usize>
impl<T, const M: usize, const N: usize> vectormatrix::matrix::Matrix<T, M, N> where T: core::clone::Clone + core::ops::arith::Mul<Output = T> + core::ops::arith::Add<Output = T>
pub fn vectormatrix::matrix::Matrix<T, M, N>::mul_matrix<const P: usize>(self, other: vectormatrix::matrix::Matrix<T, N, P>) -> vectormatrix::matrix::Matrix<T, M, P>
impl<T, const R: usize, const C: usize> vectormatrix::matrix::Matrix<T, R, C> where T: core::clone::Clone + vectormatrix::types::sealed::Float
pub fn vectormatrix::matrix::Matrix<T, R, C>::eq_approx(self, other: Self, tolerance: T) -> bool
impl<T, const R: usize, const C: usize> vectormatrix::matrix::Matrix<T, R, C> where T: core::clone::Clone
pub fn vectormatrix::matrix::Matrix<T, R, C>::rows(self) -> [vectormatrix::vector::Vector<T, C>; R]
impl<T, const R: usize, const C: usize> vectormatrix::matrix::Matrix<T, R, C> where T: core::ops::arith::SubAssign + core::clone::Clone
pub fn vectormatrix::matrix::Matrix<T, R, C>::sub_scalar_assign(&mut self, other: T)
impl<T, const R: usize, const C: usize> vectormatrix::matrix::Matrix<T, R, C>
pub const vectormatrix::matrix::Matrix<T, R, C>::UNINIT: vectormatrix::matrix::Matrix<core::mem::maybe_uninit::MaybeUninit<T>, R, C>
pub const fn vectormatrix::matrix::Matrix<T, R, C>::new_columns(columns: [vectormatrix::vector::Vector<T, R>; C]) -> Self
pub fn vectormatrix::matrix::Matrix<T, R, C>::new_from_array<const L: usize>(arr: [T; L]) -> Self where T: core::clone::Clone
pub fn vectormatrix::matrix::Matrix<T, R, C>::new_rows(rows: [vectormatrix::vector::Vector<T, C>; R]) -> Self where T: core::clone::Clone
pub fn vectormatrix::matrix::Matrix<T, R, C>::transpose(self) -> vectormatrix::matrix::Matrix<T, C, R> where T: core::clone::Clone
impl<T, const R: usize, const C: usize> vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::columns(&self) -> &[vectormatrix::vector::Vector<T, R>; C]
pub fn vectormatrix::matrix::Matrix<T, R, C>::columns_mut(&mut self) -> &mut [vectormatrix::vector::Vector<T, R>; C]
pub fn vectormatrix::matrix::Matrix<T, R, C>::element_at(&self, row: usize, col: usize) -> &T
pub fn vectormatrix::matrix::Matrix<T, R, C>::element_at_mut(&mut self, row: usize, col: usize) -> &mut T
impl<T, const R: usize, const C: usize> vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::map_in_place<F: core::ops::function::FnMut(&mut T)>(&mut self, f: F)
impl<T, const R: usize, const C: usize> vectormatrix::matrix::Matrix<core::mem::maybe_uninit::MaybeUninit<T>, R, C>
pub unsafe fn vectormatrix::matrix::Matrix<core::mem::maybe_uninit::MaybeUninit<T>, R, C>::assume_init(self) -> vectormatrix::matrix::Matrix<T, R, C>
impl<T: core::clone::Clone + core::ops::arith::Add<Output = T>, const R: usize, const C: usize> vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::add_scalar(self, other: T) -> Self
impl<T: core::clone::Clone + core::ops::arith::AddAssign, const R: usize, const C: usize> vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::add_elementwise_assign(&mut self, other: Self)
impl<T: core::clone::Clone + core::ops::arith::Div<Output = T>, const R: usize, const C: usize> vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::div_scalar(self, other: T) -> Self
impl<T: core::clone::Clone + core::ops::arith::DivAssign, const R: usize, const C: usize> vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::div_elementwise_assign(&mut self, other: Self)
impl<T: core::clone::Clone + core::ops::arith::Mul<Output = T>, const R: usize, const C: usize> vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::mul_scalar(self, other: T) -> Self
impl<T: core::clone::Clone + core::ops::arith::MulAssign, const R: usize, const C: usize> vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::mul_elementwise_assign(&mut self, other: Self)
impl<T: core::clone::Clone + core::ops::arith::Sub<Output = T>, const R: usize, const C: usize> vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::sub_scalar(self, other: T) -> Self
impl<T: core::clone::Clone + core::ops::arith::SubAssign, const R: usize, const C: usize> vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::sub_elementwise_assign(&mut self, other: Self)
impl<T: core::clone::Clone, const R: usize, const C: usize> vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::map<F: core::ops::function::FnMut(T) -> T>(self, f: F) -> Self
impl<T: vectormatrix::types::sealed::Constants + core::clone::Clone + core::ops::arith::Add<Output = T>, const R: usize, const C: usize> vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::elementwise_add(self, other: Self) -> Self
impl<T: vectormatrix::types::sealed::Constants + core::clone::Clone + core::ops::arith::Div<Output = T>, const R: usize, const C: usize> vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::elementwise_div(self, other: Self) -> Self
impl<T: vectormatrix::types::sealed::Constants + core::clone::Clone + core::ops::arith::Mul<Output = T>, const R: usize, const C: usize> vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::elementwise_mul(self, other: Self) -> Self
impl<T: vectormatrix::types::sealed::Constants + core::clone::Clone + core::ops::arith::Sub<Output = T>, const R: usize, const C: usize> vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::elementwise_sub(self, other: Self) -> Self
impl<T: vectormatrix::types::sealed::Constants, const R: usize, const C: usize> vectormatrix::matrix::Matrix<T, R, C>
pub const vectormatrix::matrix::Matrix<T, R, C>::ONE: Self
pub const vectormatrix::matrix::Matrix<T, R, C>::ZERO: Self
impl<T: vectormatrix::types::sealed::Constants> vectormatrix::matrix::Matrix<T, 1, 1>
pub const vectormatrix::matrix::Matrix<T, 1, 1>::IDENTITY: Self
impl<T: vectormatrix::types::sealed::Constants> vectormatrix::matrix::Matrix<T, 1, 2>
pub const vectormatrix::matrix::Matrix<T, 1, 2>::IDENTITY: Self
impl<T: vectormatrix::types::sealed::Constants> vectormatrix::matrix::Matrix<T, 1, 3>
pub const vectormatrix::matrix::Matrix<T, 1, 3>::IDENTITY: Self
impl<T: vectormatrix::types::sealed::Constants> vectormatrix::matrix::Matrix<T, 1, 4>
pub const vectormatrix::matrix::Matrix<T, 1, 4>::IDENTITY: Self
impl<T: vectormatrix::types::sealed::Constants> vectormatrix::matrix::Matrix<T, 2, 1>
pub const vectormatrix::matrix::Matrix<T, 2, 1>::IDENTITY: Self
impl<T: vectormatrix::types::sealed::Constants> vectormatrix::matrix::Matrix<T, 2, 2>
pub const vectormatrix::matrix::Matrix<T, 2, 2>::IDENTITY: Self
impl<T: vectormatrix::types::sealed::Constants> vectormatrix::matrix::Matrix<T, 2, 3>
pub const vectormatrix::matrix::Matrix<T, 2, 3>::IDENTITY: Self
impl<T: vectormatrix::types::sealed::Constants> vectormatrix::matrix::Matrix<T, 2, 4>
pub const vectormatrix::matrix::Matrix<T, 2, 4>::IDENTITY: Self
impl<T: vectormatrix::types::sealed::Constants> vectormatrix::matrix::Matrix<T, 3, 1>
pub const vectormatrix::matrix::Matrix<T, 3, 1>::IDENTITY: Self
impl<T: vectormatrix::types::sealed::Constants> vectormatrix::matrix::Matrix<T, 3, 2>
pub const vectormatrix::matrix::Matrix<T, 3, 2>::IDENTITY: Self
impl<T: vectormatrix::types::sealed::Constants> vectormatrix::matrix::Matrix<T, 3, 3>
pub const vectormatrix::matrix::Matrix<T, 3, 3>::IDENTITY: Self
impl<T: vectormatrix::types::sealed::Constants> vectormatrix::matrix::Matrix<T, 3, 3>
pub fn vectormatrix::matrix::Matrix<T, 3, 3>::determinant(self) -> T where T: core::clone::Clone + core::ops::arith::Sub<Output = T> + core::ops::arith::Mul<Output = T> + core::ops::arith::Add<Output = T>
pub fn vectormatrix::matrix::Matrix<T, 3, 3>::inverse(self) -> core::option::Option<Self> where T: core::clone::Clone + core::ops::arith::Div<Output = T> + core::ops::arith::Mul<Output = T> + core::ops::arith::Sub<Output = T> + core::ops::arith::Add<Output = T> + core::ops::arith::Neg<Output = T> + core::cmp::PartialEq
pub fn vectormatrix::matrix::Matrix<T, 3, 3>::rotation_matrix(theta: T) -> Self where T: vectormatrix::types::sealed::Float + core::ops::arith::Neg<Output = T> + core::clone::Clone
pub const fn vectormatrix::matrix::Matrix<T, 3, 3>::scaling_matrix(sx: T, sy: T) -> Self
pub const fn vectormatrix::matrix::Matrix<T, 3, 3>::shear_matrix(sx: T, sy: T) -> Self
pub const fn vectormatrix::matrix::Matrix<T, 3, 3>::translation_matrix(dx: T, dy: T) -> Self
impl<T: vectormatrix::types::sealed::Constants> vectormatrix::matrix::Matrix<T, 3, 4>
pub const vectormatrix::matrix::Matrix<T, 3, 4>::IDENTITY: Self
impl<T: vectormatrix::types::sealed::Constants> vectormatrix::matrix::Matrix<T, 4, 1>
pub const vectormatrix::matrix::Matrix<T, 4, 1>::IDENTITY: Self
impl<T: vectormatrix::types::sealed::Constants> vectormatrix::matrix::Matrix<T, 4, 2>
pub const vectormatrix::matrix::Matrix<T, 4, 2>::IDENTITY: Self
impl<T: vectormatrix::types::sealed::Constants> vectormatrix::matrix::Matrix<T, 4, 3>
pub const vectormatrix::matrix::Matrix<T, 4, 3>::IDENTITY: Self
impl<T: vectormatrix::types::sealed::Constants> vectormatrix::matrix::Matrix<T, 4, 4>
pub const vectormatrix::matrix::Matrix<T, 4, 4>::IDENTITY: Self
impl<T> vectormatrix::matrix::Matrix<T, 2, 2>
pub fn vectormatrix::matrix::Matrix<T, 2, 2>::determinant(self) -> T where T: core::clone::Clone + core::ops::arith::Sub<Output = T> + core::ops::arith::Mul<Output = T>
pub fn vectormatrix::matrix::Matrix<T, 2, 2>::inverse(self) -> core::option::Option<Self> where T: vectormatrix::types::sealed::Constants + core::ops::arith::Div<Output = T> + core::ops::arith::Sub<Output = T> + core::ops::arith::Mul<Output = T> + core::cmp::PartialEq + core::ops::arith::Neg<Output = T> + core::clone::Clone
impl<T> vectormatrix::matrix::Matrix<T, 4, 4>
pub fn vectormatrix::matrix::Matrix<T, 4, 4>::determinant(self) -> T where T: core::clone::Clone + core::ops::arith::Mul<Output = T> + core::ops::arith::Sub<Output = T> + core::ops::arith::Add<Output = T> + core::ops::arith::Neg<Output = T>
pub fn vectormatrix::matrix::Matrix<T, 4, 4>::inverse(self) -> core::option::Option<Self> where T: vectormatrix::types::sealed::Constants + core::clone::Clone + core::ops::arith::Mul<Output = T> + core::ops::arith::Sub<Output = T> + core::ops::arith::Add<Output = T> + core::ops::arith::Neg<Output = T> + core::ops::arith::Div<Output = T> + core::cmp::PartialEq
pub fn vectormatrix::matrix::Matrix<T, 4, 4>::rotation_matrix_x(theta: T) -> Self where T: vectormatrix::types::sealed::Float + core::ops::arith::Neg<Output = T> + core::clone::Clone + vectormatrix::types::sealed::Constants
pub fn vectormatrix::matrix::Matrix<T, 4, 4>::rotation_matrix_y(theta: T) -> Self where T: vectormatrix::types::sealed::Float + core::ops::arith::Neg<Output = T> + core::clone::Clone + vectormatrix::types::sealed::Constants
pub fn vectormatrix::matrix::Matrix<T, 4, 4>::rotation_matrix_z(theta: T) -> Self where T: vectormatrix::types::sealed::Float + core::ops::arith::Neg<Output = T> + core::clone::Clone + vectormatrix::types::sealed::Constants
pub const fn vectormatrix::matrix::Matrix<T, 4, 4>::scaling_matrix(sx: T, sy: T, sz: T) -> Self where T: vectormatrix::types::sealed::Constants
pub const fn vectormatrix::matrix::Matrix<T, 4, 4>::shear_matrix(sxy: T, sxz: T, syx: T, syz: T, szx: T, szy: T) -> Self where T: vectormatrix::types::sealed::Constants
pub const fn vectormatrix::matrix::Matrix<T, 4, 4>::translation_matrix(dx: T, dy: T, dz: T) -> Self where T: vectormatrix::types::sealed::Constants
impl<T, const M: usize, const N: usize, const P: usize> core::ops::arith::Mul<vectormatrix::matrix::Matrix<T, N, P>> for vectormatrix::matrix::Matrix<T, M, N> where T: core::clone::Clone + core::ops::arith::Mul<Output = T> + core::ops::arith::Add<Output = T>
pub type vectormatrix::matrix::Matrix<T, M, N>::Output = vectormatrix::matrix::Matrix<T, M, P>
pub fn vectormatrix::matrix::Matrix<T, M, N>::mul(self, other: vectormatrix::matrix::Matrix<T, N, P>) -> Self::Output
impl<T, const N: usize, const M: usize> core::ops::arith::Mul<vectormatrix::matrix::Matrix<T, M, N>> for vectormatrix::vector::Vector<T, M> where T: core::clone::Clone + core::ops::arith::Mul<Output = T> + core::ops::arith::Add<Output = T>
pub type vectormatrix::vector::Vector<T, M>::Output = vectormatrix::matrix::Matrix<T, 1, N>
pub fn vectormatrix::vector::Vector<T, M>::mul(self, rhs: vectormatrix::matrix::Matrix<T, M, N>) -> Self::Output
impl<T, const R: usize, const C: usize> core::convert::AsMut<[vectormatrix::vector::Vector<T, R>; C]> for vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::as_mut(&mut self) -> &mut [vectormatrix::vector::Vector<T, R>; C]
impl<T, const R: usize, const C: usize> core::convert::AsRef<[vectormatrix::vector::Vector<T, R>; C]> for vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::as_ref(&self) -> &[vectormatrix::vector::Vector<T, R>; C]
impl<T, const R: usize, const C: usize> core::convert::From<[vectormatrix::vector::Vector<T, R>; C]> for vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::from(arr: [vectormatrix::vector::Vector<T, R>; C]) -> Self
impl<T, const R: usize, const C: usize> core::convert::From<vectormatrix::matrix::Matrix<T, R, C>> for [vectormatrix::vector::Vector<T, R>; C]
pub fn [vectormatrix::vector::Vector<T, R>; C]::from(m: vectormatrix::matrix::Matrix<T, R, C>) -> Self
impl<T, const R: usize, const C: usize> core::default::Default for vectormatrix::matrix::Matrix<T, R, C> where T: core::marker::Copy + core::default::Default
pub fn vectormatrix::matrix::Matrix<T, R, C>::default() -> Self
impl<T, const R: usize, const C: usize> core::fmt::Debug for vectormatrix::matrix::Matrix<T, R, C> where T: core::fmt::Debug
pub fn vectormatrix::matrix::Matrix<T, R, C>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
impl<T, const R: usize, const C: usize> core::marker::StructuralPartialEq for vectormatrix::matrix::Matrix<T, R, C>
impl<T, const R: usize, const C: usize> core::ops::arith::Add<T> for vectormatrix::matrix::Matrix<T, R, C> where T: core::ops::arith::Add<Output = T> + core::clone::Clone
pub type vectormatrix::matrix::Matrix<T, R, C>::Output = vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::add(self, other: T) -> Self
impl<T, const R: usize, const C: usize> core::ops::arith::AddAssign<T> for vectormatrix::matrix::Matrix<T, R, C> where T: core::ops::arith::AddAssign + core::clone::Clone
pub fn vectormatrix::matrix::Matrix<T, R, C>::add_assign(&mut self, other: T)
impl<T, const R: usize, const C: usize> core::ops::arith::Div<T> for vectormatrix::matrix::Matrix<T, R, C> where T: core::ops::arith::Div<Output = T> + core::clone::Clone
pub type vectormatrix::matrix::Matrix<T, R, C>::Output = vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::div(self, other: T) -> Self
impl<T, const R: usize, const C: usize> core::ops::arith::Mul<T> for vectormatrix::matrix::Matrix<T, R, C> where T: core::ops::arith::Mul<Output = T> + core::clone::Clone
pub type vectormatrix::matrix::Matrix<T, R, C>::Output = vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::mul(self, other: T) -> Self
impl<T, const R: usize, const C: usize> core::ops::arith::Mul<vectormatrix::vector::Vector<T, C>> for vectormatrix::matrix::Matrix<T, R, C> where T: core::clone::Clone + core::ops::arith::Mul<Output = T> + core::ops::arith::Add<Output = T>
pub type vectormatrix::matrix::Matrix<T, R, C>::Output = vectormatrix::matrix::Matrix<T, R, 1>
pub fn vectormatrix::matrix::Matrix<T, R, C>::mul(self, other: vectormatrix::vector::Vector<T, C>) -> Self::Output
impl<T, const R: usize, const C: usize> core::ops::arith::Sub<T> for vectormatrix::matrix::Matrix<T, R, C> where T: core::ops::arith::Sub<Output = T> + core::clone::Clone
pub type vectormatrix::matrix::Matrix<T, R, C>::Output = vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::sub(self, other: T) -> Self
impl<T, const R: usize, const C: usize> core::ops::arith::SubAssign<T> for vectormatrix::matrix::Matrix<T, R, C> where T: core::ops::arith::SubAssign + core::clone::Clone
pub fn vectormatrix::matrix::Matrix<T, R, C>::sub_assign(&mut self, other: T)
impl<T: core::clone::Clone + core::ops::arith::AddAssign, const R: usize, const C: usize> core::ops::arith::AddAssign for vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::add_assign(&mut self, other: Self)
impl<T: core::clone::Clone + core::ops::arith::DivAssign, const R: usize, const C: usize> core::ops::arith::DivAssign for vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::div_assign(&mut self, other: Self)
impl<T: core::clone::Clone + core::ops::arith::MulAssign, const R: usize, const C: usize> core::ops::arith::MulAssign for vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::mul_assign(&mut self, other: Self)
impl<T: core::clone::Clone + core::ops::arith::SubAssign, const R: usize, const C: usize> core::ops::arith::SubAssign for vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::sub_assign(&mut self, other: Self)
impl<T: core::clone::Clone, const R: usize, const C: usize> core::clone::Clone for vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::clone(&self) -> vectormatrix::matrix::Matrix<T, R, C>
impl<T: core::cmp::Eq, const R: usize, const C: usize> core::cmp::Eq for vectormatrix::matrix::Matrix<T, R, C>
impl<T: core::cmp::Ord, const R: usize, const C: usize> core::cmp::Ord for vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::cmp(&self, other: &vectormatrix::matrix::Matrix<T, R, C>) -> core::cmp::Ordering
impl<T: core::cmp::PartialEq, const R: usize, const C: usize> core::cmp::PartialEq for vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::eq(&self, other: &vectormatrix::matrix::Matrix<T, R, C>) -> bool
impl<T: core::cmp::PartialOrd, const R: usize, const C: usize> core::cmp::PartialOrd for vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::partial_cmp(&self, other: &vectormatrix::matrix::Matrix<T, R, C>) -> core::option::Option<core::cmp::Ordering>
impl<T: core::hash::Hash, const R: usize, const C: usize> core::hash::Hash for vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
impl<T: core::marker::Copy, const R: usize, const C: usize> core::marker::Copy for vectormatrix::matrix::Matrix<T, R, C>
impl<T: vectormatrix::types::sealed::Constants + core::clone::Clone + core::ops::arith::Add<Output = T>, const R: usize, const C: usize> core::ops::arith::Add for vectormatrix::matrix::Matrix<T, R, C>
pub type vectormatrix::matrix::Matrix<T, R, C>::Output = vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::add(self, other: Self) -> Self
impl<T: vectormatrix::types::sealed::Constants + core::clone::Clone + core::ops::arith::Sub<Output = T>, const R: usize, const C: usize> core::ops::arith::Sub for vectormatrix::matrix::Matrix<T, R, C>
pub type vectormatrix::matrix::Matrix<T, R, C>::Output = vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::sub(self, other: Self) -> Self
impl<T, const R: usize, const C: usize> core::marker::Freeze for vectormatrix::matrix::Matrix<T, R, C> where T: core::marker::Freeze
impl<T, const R: usize, const C: usize> core::marker::Send for vectormatrix::matrix::Matrix<T, R, C> where T: core::marker::Send
impl<T, const R: usize, const C: usize> core::marker::Sync for vectormatrix::matrix::Matrix<T, R, C> where T: core::marker::Sync
impl<T, const R: usize, const C: usize> core::marker::Unpin for vectormatrix::matrix::Matrix<T, R, C> where T: core::marker::Unpin
impl<T, const R: usize, const C: usize> core::panic::unwind_safe::RefUnwindSafe for vectormatrix::matrix::Matrix<T, R, C> where T: core::panic::unwind_safe::RefUnwindSafe
impl<T, const R: usize, const C: usize> core::panic::unwind_safe::UnwindSafe for vectormatrix::matrix::Matrix<T, R, C> where T: core::panic::unwind_safe::UnwindSafe
impl<T, U> core::convert::Into<U> for vectormatrix::matrix::Matrix<T, R, C> where U: core::convert::From<T>
pub fn vectormatrix::matrix::Matrix<T, R, C>::into(self) -> U
impl<T, U> core::convert::TryFrom<U> for vectormatrix::matrix::Matrix<T, R, C> where U: core::convert::Into<T>
pub type vectormatrix::matrix::Matrix<T, R, C>::Error = core::convert::Infallible
pub fn vectormatrix::matrix::Matrix<T, R, C>::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error>
impl<T, U> core::convert::TryInto<U> for vectormatrix::matrix::Matrix<T, R, C> where U: core::convert::TryFrom<T>
pub type vectormatrix::matrix::Matrix<T, R, C>::Error = <U as core::convert::TryFrom<T>>::Error
pub fn vectormatrix::matrix::Matrix<T, R, C>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
impl<T> alloc::borrow::ToOwned for vectormatrix::matrix::Matrix<T, R, C> where T: core::clone::Clone
pub type vectormatrix::matrix::Matrix<T, R, C>::Owned = T
pub fn vectormatrix::matrix::Matrix<T, R, C>::clone_into(&self, target: &mut T)
pub fn vectormatrix::matrix::Matrix<T, R, C>::to_owned(&self) -> T
impl<T> core::any::Any for vectormatrix::matrix::Matrix<T, R, C> where T: 'static + ?core::marker::Sized
pub fn vectormatrix::matrix::Matrix<T, R, C>::type_id(&self) -> core::any::TypeId
impl<T> core::borrow::Borrow<T> for vectormatrix::matrix::Matrix<T, R, C> where T: ?core::marker::Sized
pub fn vectormatrix::matrix::Matrix<T, R, C>::borrow(&self) -> &T
impl<T> core::borrow::BorrowMut<T> for vectormatrix::matrix::Matrix<T, R, C> where T: ?core::marker::Sized
pub fn vectormatrix::matrix::Matrix<T, R, C>::borrow_mut(&mut self) -> &mut T
impl<T> core::clone::CloneToUninit for vectormatrix::matrix::Matrix<T, R, C> where T: core::clone::Clone
pub unsafe fn vectormatrix::matrix::Matrix<T, R, C>::clone_to_uninit(&self, dest: *mut u8)
impl<T> core::convert::From<T> for vectormatrix::matrix::Matrix<T, R, C>
pub fn vectormatrix::matrix::Matrix<T, R, C>::from(t: T) -> T
pub struct vectormatrix::NormalizedVector<T, const N: usize>(_)
impl<T, const N: usize> vectormatrix::vector::NormalizedVector<T, N>
pub const fn vectormatrix::vector::NormalizedVector<T, N>::as_vector(&self) -> &vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::NormalizedVector<T, N>::into_vector(self) -> vectormatrix::vector::Vector<T, N>
impl<T, const N: usize> core::convert::AsRef<vectormatrix::vector::Vector<T, N>> for vectormatrix::vector::NormalizedVector<T, N>
pub fn vectormatrix::vector::NormalizedVector<T, N>::as_ref(&self) -> &vectormatrix::vector::Vector<T, N>
impl<T, const N: usize> core::convert::From<vectormatrix::vector::NormalizedVector<T, N>> for vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::from(value: vectormatrix::vector::NormalizedVector<T, N>) -> Self
impl<T, const N: usize> core::convert::From<vectormatrix::vector::Vector<T, N>> for vectormatrix::vector::NormalizedVector<T, N> where T: core::ops::arith::Add<Output = T> + core::clone::Clone + core::ops::arith::Div<Output = T> + core::ops::arith::Mul<Output = T> + vectormatrix::types::sealed::Float
pub fn vectormatrix::vector::NormalizedVector<T, N>::from(value: vectormatrix::vector::Vector<T, N>) -> Self
impl<T, const N: usize> core::marker::StructuralPartialEq for vectormatrix::vector::NormalizedVector<T, N>
impl<T, const N: usize> core::ops::deref::Deref for vectormatrix::vector::NormalizedVector<T, N>
pub type vectormatrix::vector::NormalizedVector<T, N>::Target = vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::NormalizedVector<T, N>::deref(&self) -> &Self::Target
impl<T: core::clone::Clone, const N: usize> core::clone::Clone for vectormatrix::vector::NormalizedVector<T, N>
pub fn vectormatrix::vector::NormalizedVector<T, N>::clone(&self) -> vectormatrix::vector::NormalizedVector<T, N>
impl<T: core::cmp::Eq, const N: usize> core::cmp::Eq for vectormatrix::vector::NormalizedVector<T, N>
impl<T: core::cmp::Ord, const N: usize> core::cmp::Ord for vectormatrix::vector::NormalizedVector<T, N>
pub fn vectormatrix::vector::NormalizedVector<T, N>::cmp(&self, other: &vectormatrix::vector::NormalizedVector<T, N>) -> core::cmp::Ordering
impl<T: core::cmp::PartialEq, const N: usize> core::cmp::PartialEq for vectormatrix::vector::NormalizedVector<T, N>
pub fn vectormatrix::vector::NormalizedVector<T, N>::eq(&self, other: &vectormatrix::vector::NormalizedVector<T, N>) -> bool
impl<T: core::cmp::PartialOrd, const N: usize> core::cmp::PartialOrd for vectormatrix::vector::NormalizedVector<T, N>
pub fn vectormatrix::vector::NormalizedVector<T, N>::partial_cmp(&self, other: &vectormatrix::vector::NormalizedVector<T, N>) -> core::option::Option<core::cmp::Ordering>
impl<T: core::fmt::Debug, const N: usize> core::fmt::Debug for vectormatrix::vector::NormalizedVector<T, N>
pub fn vectormatrix::vector::NormalizedVector<T, N>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
impl<T: core::hash::Hash, const N: usize> core::hash::Hash for vectormatrix::vector::NormalizedVector<T, N>
pub fn vectormatrix::vector::NormalizedVector<T, N>::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
impl<T: core::marker::Copy, const N: usize> core::marker::Copy for vectormatrix::vector::NormalizedVector<T, N>
impl<T, const N: usize> core::marker::Freeze for vectormatrix::vector::NormalizedVector<T, N> where T: core::marker::Freeze
impl<T, const N: usize> core::marker::Send for vectormatrix::vector::NormalizedVector<T, N> where T: core::marker::Send
impl<T, const N: usize> core::marker::Sync for vectormatrix::vector::NormalizedVector<T, N> where T: core::marker::Sync
impl<T, const N: usize> core::marker::Unpin for vectormatrix::vector::NormalizedVector<T, N> where T: core::marker::Unpin
impl<T, const N: usize> core::panic::unwind_safe::RefUnwindSafe for vectormatrix::vector::NormalizedVector<T, N> where T: core::panic::unwind_safe::RefUnwindSafe
impl<T, const N: usize> core::panic::unwind_safe::UnwindSafe for vectormatrix::vector::NormalizedVector<T, N> where T: core::panic::unwind_safe::UnwindSafe
impl<P, T> core::ops::deref::Receiver for vectormatrix::vector::NormalizedVector<T, N> where P: core::ops::deref::Deref<Target = T> + ?core::marker::Sized, T: ?core::marker::Sized
pub type vectormatrix::vector::NormalizedVector<T, N>::Target = T
impl<T, U> core::convert::Into<U> for vectormatrix::vector::NormalizedVector<T, N> where U: core::convert::From<T>
pub fn vectormatrix::vector::NormalizedVector<T, N>::into(self) -> U
impl<T, U> core::convert::TryFrom<U> for vectormatrix::vector::NormalizedVector<T, N> where U: core::convert::Into<T>
pub type vectormatrix::vector::NormalizedVector<T, N>::Error = core::convert::Infallible
pub fn vectormatrix::vector::NormalizedVector<T, N>::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error>
impl<T, U> core::convert::TryInto<U> for vectormatrix::vector::NormalizedVector<T, N> where U: core::convert::TryFrom<T>
pub type vectormatrix::vector::NormalizedVector<T, N>::Error = <U as core::convert::TryFrom<T>>::Error
pub fn vectormatrix::vector::NormalizedVector<T, N>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
impl<T> alloc::borrow::ToOwned for vectormatrix::vector::NormalizedVector<T, N> where T: core::clone::Clone
pub type vectormatrix::vector::NormalizedVector<T, N>::Owned = T
pub fn vectormatrix::vector::NormalizedVector<T, N>::clone_into(&self, target: &mut T)
pub fn vectormatrix::vector::NormalizedVector<T, N>::to_owned(&self) -> T
impl<T> core::any::Any for vectormatrix::vector::NormalizedVector<T, N> where T: 'static + ?core::marker::Sized
pub fn vectormatrix::vector::NormalizedVector<T, N>::type_id(&self) -> core::any::TypeId
impl<T> core::borrow::Borrow<T> for vectormatrix::vector::NormalizedVector<T, N> where T: ?core::marker::Sized
pub fn vectormatrix::vector::NormalizedVector<T, N>::borrow(&self) -> &T
impl<T> core::borrow::BorrowMut<T> for vectormatrix::vector::NormalizedVector<T, N> where T: ?core::marker::Sized
pub fn vectormatrix::vector::NormalizedVector<T, N>::borrow_mut(&mut self) -> &mut T
impl<T> core::clone::CloneToUninit for vectormatrix::vector::NormalizedVector<T, N> where T: core::clone::Clone
pub unsafe fn vectormatrix::vector::NormalizedVector<T, N>::clone_to_uninit(&self, dest: *mut u8)
impl<T> core::convert::From<T> for vectormatrix::vector::NormalizedVector<T, N>
pub fn vectormatrix::vector::NormalizedVector<T, N>::from(t: T) -> T
pub struct vectormatrix::Vector<T, const N: usize>(_)
impl<T, const N: usize> vectormatrix::vector::Vector<T, N> where T: core::clone::Clone
pub fn vectormatrix::vector::Vector<T, N>::from_col(col: vectormatrix::matrix::Matrix<T, N, 1>) -> Self
pub fn vectormatrix::vector::Vector<T, N>::from_row(row: vectormatrix::matrix::Matrix<T, 1, N>) -> Self
pub fn vectormatrix::vector::Vector<T, N>::to_col(self) -> vectormatrix::matrix::Matrix<T, N, 1>
pub fn vectormatrix::vector::Vector<T, N>::to_row(self) -> vectormatrix::matrix::Matrix<T, 1, N>
impl<T, const N: usize> vectormatrix::vector::Vector<T, N> where T: core::clone::Clone
pub fn vectormatrix::vector::Vector<T, N>::map<F, U>(self, f: F) -> vectormatrix::vector::Vector<U, N> where F: core::ops::function::FnMut(T) -> U
impl<T, const N: usize> vectormatrix::vector::Vector<T, N> where [T; N]: vectormatrix::vector::private::AtLeastFour
pub const fn vectormatrix::vector::Vector<T, N>::w(&self) -> &T
pub const fn vectormatrix::vector::Vector<T, N>::w_mut(&mut self) -> &mut T
impl<T, const N: usize> vectormatrix::vector::Vector<T, N> where [T; N]: vectormatrix::vector::private::AtLeastOne
pub const fn vectormatrix::vector::Vector<T, N>::x(&self) -> &T
pub const fn vectormatrix::vector::Vector<T, N>::x_mut(&mut self) -> &mut T
impl<T, const N: usize> vectormatrix::vector::Vector<T, N> where [T; N]: vectormatrix::vector::private::AtLeastThree
pub const fn vectormatrix::vector::Vector<T, N>::z(&self) -> &T
pub const fn vectormatrix::vector::Vector<T, N>::z_mut(&mut self) -> &mut T
impl<T, const N: usize> vectormatrix::vector::Vector<T, N> where [T; N]: vectormatrix::vector::private::AtLeastTwo
pub const fn vectormatrix::vector::Vector<T, N>::y(&self) -> &T
pub const fn vectormatrix::vector::Vector<T, N>::y_mut(&mut self) -> &mut T
impl<T, const N: usize> vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::into_inner(self) -> [T; N]
pub const fn vectormatrix::vector::Vector<T, N>::new(value: [T; N]) -> Self
impl<T, const N: usize> vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::map_in_place<F>(&mut self, f: F) where F: core::ops::function::FnMut(&mut T)
impl<T, const N: usize> vectormatrix::vector::Vector<core::mem::maybe_uninit::MaybeUninit<T>, N> where T: core::marker::Sized
pub unsafe fn vectormatrix::vector::Vector<core::mem::maybe_uninit::MaybeUninit<T>, N>::assume_init(self) -> vectormatrix::vector::Vector<T, N>
impl<T, const N: usize> vectormatrix::vector::Vector<core::mem::maybe_uninit::MaybeUninit<T>, N>
pub const vectormatrix::vector::Vector<core::mem::maybe_uninit::MaybeUninit<T>, N>::UNINIT: Self
impl<T: core::cmp::PartialOrd + core::clone::Clone, const N: usize> vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::clamp(self, min: T, max: T) -> Self
impl<T: core::cmp::PartialOrd + core::clone::Clone, const N: usize> vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::max(self) -> T
pub fn vectormatrix::vector::Vector<T, N>::min(self) -> T
impl<T: core::ops::arith::Add<Output = T> + core::clone::Clone, const N: usize> vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::add_scalar(self, other: T) -> Self
impl<T: core::ops::arith::Add<Output = T> + core::clone::Clone, const N: usize> vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::elementwise_add(self, other: Self) -> Self
impl<T: core::ops::arith::AddAssign + core::clone::Clone, const N: usize> vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::add_assign_scalar(&mut self, other: T)
impl<T: core::ops::arith::AddAssign + core::clone::Clone, const N: usize> vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::add_elementwise_assign(&mut self, other: Self)
impl<T: core::ops::arith::Div<Output = T> + core::clone::Clone + core::ops::arith::Mul<Output = T> + core::ops::arith::Add<Output = T> + vectormatrix::types::sealed::Float, const N: usize> vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::normalize(self) -> vectormatrix::vector::NormalizedVector<T, N>
impl<T: core::ops::arith::Div<Output = T> + core::clone::Clone, const N: usize> vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::div_scalar(self, other: T) -> Self
impl<T: core::ops::arith::Div<Output = T> + core::clone::Clone, const N: usize> vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::elementwise_div(self, other: Self) -> Self
impl<T: core::ops::arith::DivAssign + core::clone::Clone, const N: usize> vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::div_assign_scalar(&mut self, other: T)
impl<T: core::ops::arith::Mul<Output = T> + core::clone::Clone + core::ops::arith::Add<Output = T> + vectormatrix::types::sealed::Float, const N: usize> vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::length(self) -> T
impl<T: core::ops::arith::Mul<Output = T> + core::clone::Clone + core::ops::arith::Add<Output = T>, const N: usize> vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::dot(self, other: Self) -> T
impl<T: core::ops::arith::Mul<Output = T> + core::clone::Clone + core::ops::arith::Add<Output = T>, const N: usize> vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::length_squared(self) -> T
impl<T: core::ops::arith::Mul<Output = T> + core::clone::Clone, const N: usize> vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::elementwise_mul(self, other: Self) -> Self
impl<T: core::ops::arith::Mul<Output = T> + core::clone::Clone, const N: usize> vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::mul_scalar(self, other: T) -> Self
impl<T: core::ops::arith::MulAssign + core::clone::Clone, const N: usize> vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::mul_assign_scalar(&mut self, other: T)
impl<T: core::ops::arith::Sub<Output = T> + core::clone::Clone + core::marker::Copy + core::ops::arith::Mul<Output = T> + core::ops::arith::Add<Output = T> + vectormatrix::types::sealed::Float, const N: usize> vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::euclid_distance_to(self, other: Self) -> T
impl<T: core::ops::arith::Sub<Output = T> + core::clone::Clone + core::marker::Copy + core::ops::arith::Mul<Output = T> + core::ops::arith::Add<Output = T>> vectormatrix::vector::Vector<T, 3>
pub fn vectormatrix::vector::Vector<T, 3>::cross(self, other: Self) -> Self
impl<T: core::ops::arith::Sub<Output = T> + core::clone::Clone, const N: usize> vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::elementwise_sub(self, other: Self) -> Self
impl<T: core::ops::arith::Sub<Output = T> + core::clone::Clone, const N: usize> vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::sub_scalar(self, other: T) -> Self
impl<T: core::ops::arith::SubAssign + core::clone::Clone, const N: usize> vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::sub_assign_scalar(&mut self, other: T)
impl<T: core::ops::arith::SubAssign + core::clone::Clone, const N: usize> vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::sub_elementwise_assign(&mut self, other: Self)
impl<T: vectormatrix::types::sealed::Constants, const N: usize> vectormatrix::vector::Vector<T, N>
pub const vectormatrix::vector::Vector<T, N>::ONE: Self
pub const vectormatrix::vector::Vector<T, N>::ZERO: Self
impl<T: vectormatrix::types::sealed::Float + core::clone::Clone, const N: usize> vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::eq_approx(self, other: Self, tolerance: T) -> bool
impl<T: vectormatrix::types::sealed::Float + vectormatrix::types::sealed::Constants + core::clone::Clone + core::ops::arith::Sub<Output = T> + core::ops::arith::Mul<Output = T> + core::ops::arith::Add<Output = T>, const N: usize> vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::mix(self, other: Self, weight: T) -> Self
impl<T, const N: usize, const M: usize> core::ops::arith::Mul<vectormatrix::matrix::Matrix<T, M, N>> for vectormatrix::vector::Vector<T, M> where T: core::clone::Clone + core::ops::arith::Mul<Output = T> + core::ops::arith::Add<Output = T>
pub type vectormatrix::vector::Vector<T, M>::Output = vectormatrix::matrix::Matrix<T, 1, N>
pub fn vectormatrix::vector::Vector<T, M>::mul(self, rhs: vectormatrix::matrix::Matrix<T, M, N>) -> Self::Output
impl<T, const N: usize> core::convert::AsMut<[T; N]> for vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::as_mut(&mut self) -> &mut [T; N]
impl<T, const N: usize> core::convert::AsRef<[T; N]> for vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::as_ref(&self) -> &[T; N]
impl<T, const N: usize> core::convert::AsRef<vectormatrix::vector::Vector<T, N>> for vectormatrix::vector::NormalizedVector<T, N>
pub fn vectormatrix::vector::NormalizedVector<T, N>::as_ref(&self) -> &vectormatrix::vector::Vector<T, N>
impl<T, const N: usize> core::convert::From<[T; N]> for vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::from(value: [T; N]) -> Self
impl<T, const N: usize> core::convert::From<vectormatrix::vector::NormalizedVector<T, N>> for vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::from(value: vectormatrix::vector::NormalizedVector<T, N>) -> Self
impl<T, const N: usize> core::convert::From<vectormatrix::vector::Vector<T, N>> for [T; N]
pub fn [T; N]::from(value: vectormatrix::vector::Vector<T, N>) -> Self
impl<T, const N: usize> core::convert::From<vectormatrix::vector::Vector<T, N>> for vectormatrix::vector::NormalizedVector<T, N> where T: core::ops::arith::Add<Output = T> + core::clone::Clone + core::ops::arith::Div<Output = T> + core::ops::arith::Mul<Output = T> + vectormatrix::types::sealed::Float
pub fn vectormatrix::vector::NormalizedVector<T, N>::from(value: vectormatrix::vector::Vector<T, N>) -> Self
impl<T, const N: usize> core::default::Default for vectormatrix::vector::Vector<T, N> where T: core::default::Default + core::marker::Copy
pub fn vectormatrix::vector::Vector<T, N>::default() -> Self
impl<T, const N: usize> core::marker::StructuralPartialEq for vectormatrix::vector::Vector<T, N>
impl<T, const N: usize> core::ops::index::Index<usize> for vectormatrix::vector::Vector<T, N>
pub type vectormatrix::vector::Vector<T, N>::Output = T
pub fn vectormatrix::vector::Vector<T, N>::index(&self, index: usize) -> &Self::Output
impl<T, const N: usize> core::ops::index::IndexMut<usize> for vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::index_mut(&mut self, index: usize) -> &mut Self::Output
impl<T, const R: usize, const C: usize> core::ops::arith::Mul<vectormatrix::vector::Vector<T, C>> for vectormatrix::matrix::Matrix<T, R, C> where T: core::clone::Clone + core::ops::arith::Mul<Output = T> + core::ops::arith::Add<Output = T>
pub type vectormatrix::matrix::Matrix<T, R, C>::Output = vectormatrix::matrix::Matrix<T, R, 1>
pub fn vectormatrix::matrix::Matrix<T, R, C>::mul(self, other: vectormatrix::vector::Vector<T, C>) -> Self::Output
impl<T: core::clone::Clone, const N: usize> core::clone::Clone for vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::clone(&self) -> vectormatrix::vector::Vector<T, N>
impl<T: core::cmp::Eq, const N: usize> core::cmp::Eq for vectormatrix::vector::Vector<T, N>
impl<T: core::cmp::Ord, const N: usize> core::cmp::Ord for vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::cmp(&self, other: &vectormatrix::vector::Vector<T, N>) -> core::cmp::Ordering
impl<T: core::cmp::PartialEq, const N: usize> core::cmp::PartialEq for vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::eq(&self, other: &vectormatrix::vector::Vector<T, N>) -> bool
impl<T: core::cmp::PartialOrd, const N: usize> core::cmp::PartialOrd for vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::partial_cmp(&self, other: &vectormatrix::vector::Vector<T, N>) -> core::option::Option<core::cmp::Ordering>
impl<T: core::fmt::Debug, const N: usize> core::fmt::Debug for vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result
impl<T: core::hash::Hash, const N: usize> core::hash::Hash for vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::hash<__H: core::hash::Hasher>(&self, state: &mut __H)
impl<T: core::marker::Copy, const N: usize> core::marker::Copy for vectormatrix::vector::Vector<T, N>
impl<T: core::ops::arith::Add<Output = T> + core::clone::Clone, const N: usize> core::ops::arith::Add for vectormatrix::vector::Vector<T, N>
pub type vectormatrix::vector::Vector<T, N>::Output = vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::add(self, other: Self) -> Self
impl<T: core::ops::arith::Add<Output = T> + core::clone::Clone, const N: usize> core::ops::arith::Add<T> for vectormatrix::vector::Vector<T, N>
pub type vectormatrix::vector::Vector<T, N>::Output = vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::add(self, other: T) -> Self
impl<T: core::ops::arith::AddAssign + core::clone::Clone, const N: usize> core::ops::arith::AddAssign for vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::add_assign(&mut self, other: Self)
impl<T: core::ops::arith::AddAssign + core::clone::Clone, const N: usize> core::ops::arith::AddAssign<T> for vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::add_assign(&mut self, other: T)
impl<T: core::ops::arith::Div<Output = T> + core::clone::Clone, const N: usize> core::ops::arith::Div for vectormatrix::vector::Vector<T, N>
pub type vectormatrix::vector::Vector<T, N>::Output = vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::div(self, other: Self) -> Self
impl<T: core::ops::arith::Div<Output = T> + core::clone::Clone, const N: usize> core::ops::arith::Div<T> for vectormatrix::vector::Vector<T, N>
pub type vectormatrix::vector::Vector<T, N>::Output = vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::div(self, other: T) -> Self
impl<T: core::ops::arith::DivAssign + core::clone::Clone, const N: usize> core::ops::arith::DivAssign for vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::div_assign(&mut self, other: Self)
impl<T: core::ops::arith::DivAssign + core::clone::Clone, const N: usize> core::ops::arith::DivAssign<T> for vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::div_assign(&mut self, other: T)
impl<T: core::ops::arith::Mul<Output = T> + core::clone::Clone, const N: usize> core::ops::arith::Mul for vectormatrix::vector::Vector<T, N>
pub type vectormatrix::vector::Vector<T, N>::Output = vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::mul(self, other: Self) -> Self
impl<T: core::ops::arith::Mul<Output = T> + core::clone::Clone, const N: usize> core::ops::arith::Mul<T> for vectormatrix::vector::Vector<T, N>
pub type vectormatrix::vector::Vector<T, N>::Output = vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::mul(self, other: T) -> Self
impl<T: core::ops::arith::MulAssign + core::clone::Clone, const N: usize> core::ops::arith::MulAssign for vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::mul_assign(&mut self, other: Self)
impl<T: core::ops::arith::MulAssign + core::clone::Clone, const N: usize> core::ops::arith::MulAssign<T> for vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::mul_assign(&mut self, other: T)
impl<T: core::ops::arith::Sub<Output = T> + core::clone::Clone, const N: usize> core::ops::arith::Sub for vectormatrix::vector::Vector<T, N>
pub type vectormatrix::vector::Vector<T, N>::Output = vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::sub(self, other: Self) -> Self
impl<T: core::ops::arith::Sub<Output = T> + core::clone::Clone, const N: usize> core::ops::arith::Sub<T> for vectormatrix::vector::Vector<T, N>
pub type vectormatrix::vector::Vector<T, N>::Output = vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::sub(self, other: T) -> Self
impl<T: core::ops::arith::SubAssign + core::clone::Clone, const N: usize> core::ops::arith::SubAssign for vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::sub_assign(&mut self, other: Self)
impl<T: core::ops::arith::SubAssign + core::clone::Clone, const N: usize> core::ops::arith::SubAssign<T> for vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::sub_assign(&mut self, other: T)
impl<T> core::convert::From<(T)> for vectormatrix::vector::Vector<T, 1>
pub fn vectormatrix::vector::Vector<T, 1>::from(value: (T)) -> Self
impl<T> core::convert::From<(T, T)> for vectormatrix::vector::Vector<T, 2>
pub fn vectormatrix::vector::Vector<T, 2>::from(value: (T, T)) -> Self
impl<T> core::convert::From<(T, T, T)> for vectormatrix::vector::Vector<T, 3>
pub fn vectormatrix::vector::Vector<T, 3>::from(value: (T, T, T)) -> Self
impl<T> core::convert::From<(T, T, T, T)> for vectormatrix::vector::Vector<T, 4>
pub fn vectormatrix::vector::Vector<T, 4>::from(value: (T, T, T, T)) -> Self
impl<T> core::convert::From<T> for vectormatrix::vector::Vector<T, 1>
pub fn vectormatrix::vector::Vector<T, 1>::from(value: T) -> Self
impl<T> core::convert::From<vectormatrix::vector::Vector<T, 1>> for (T)
pub fn (T)::from(value: vectormatrix::vector::Vector<T, 1>) -> Self
impl<T> core::convert::From<vectormatrix::vector::Vector<T, 2>> for (T, T)
pub fn (T, T)::from(value: vectormatrix::vector::Vector<T, 2>) -> Self
impl<T> core::convert::From<vectormatrix::vector::Vector<T, 3>> for (T, T, T)
pub fn (T, T, T)::from(value: vectormatrix::vector::Vector<T, 3>) -> Self
impl<T> core::convert::From<vectormatrix::vector::Vector<T, 4>> for (T, T, T, T)
pub fn (T, T, T, T)::from(value: vectormatrix::vector::Vector<T, 4>) -> Self
impl<T, const N: usize> core::marker::Freeze for vectormatrix::vector::Vector<T, N> where T: core::marker::Freeze
impl<T, const N: usize> core::marker::Send for vectormatrix::vector::Vector<T, N> where T: core::marker::Send
impl<T, const N: usize> core::marker::Sync for vectormatrix::vector::Vector<T, N> where T: core::marker::Sync
impl<T, const N: usize> core::marker::Unpin for vectormatrix::vector::Vector<T, N> where T: core::marker::Unpin
impl<T, const N: usize> core::panic::unwind_safe::RefUnwindSafe for vectormatrix::vector::Vector<T, N> where T: core::panic::unwind_safe::RefUnwindSafe
impl<T, const N: usize> core::panic::unwind_safe::UnwindSafe for vectormatrix::vector::Vector<T, N> where T: core::panic::unwind_safe::UnwindSafe
impl<T, U> core::convert::Into<U> for vectormatrix::vector::Vector<T, N> where U: core::convert::From<T>
pub fn vectormatrix::vector::Vector<T, N>::into(self) -> U
impl<T, U> core::convert::TryFrom<U> for vectormatrix::vector::Vector<T, N> where U: core::convert::Into<T>
pub type vectormatrix::vector::Vector<T, N>::Error = core::convert::Infallible
pub fn vectormatrix::vector::Vector<T, N>::try_from(value: U) -> core::result::Result<T, <T as core::convert::TryFrom<U>>::Error>
impl<T, U> core::convert::TryInto<U> for vectormatrix::vector::Vector<T, N> where U: core::convert::TryFrom<T>
pub type vectormatrix::vector::Vector<T, N>::Error = <U as core::convert::TryFrom<T>>::Error
pub fn vectormatrix::vector::Vector<T, N>::try_into(self) -> core::result::Result<U, <U as core::convert::TryFrom<T>>::Error>
impl<T> alloc::borrow::ToOwned for vectormatrix::vector::Vector<T, N> where T: core::clone::Clone
pub type vectormatrix::vector::Vector<T, N>::Owned = T
pub fn vectormatrix::vector::Vector<T, N>::clone_into(&self, target: &mut T)
pub fn vectormatrix::vector::Vector<T, N>::to_owned(&self) -> T
impl<T> core::any::Any for vectormatrix::vector::Vector<T, N> where T: 'static + ?core::marker::Sized
pub fn vectormatrix::vector::Vector<T, N>::type_id(&self) -> core::any::TypeId
impl<T> core::borrow::Borrow<T> for vectormatrix::vector::Vector<T, N> where T: ?core::marker::Sized
pub fn vectormatrix::vector::Vector<T, N>::borrow(&self) -> &T
impl<T> core::borrow::BorrowMut<T> for vectormatrix::vector::Vector<T, N> where T: ?core::marker::Sized
pub fn vectormatrix::vector::Vector<T, N>::borrow_mut(&mut self) -> &mut T
impl<T> core::clone::CloneToUninit for vectormatrix::vector::Vector<T, N> where T: core::clone::Clone
pub unsafe fn vectormatrix::vector::Vector<T, N>::clone_to_uninit(&self, dest: *mut u8)
impl<T> core::convert::From<T> for vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::from(t: T) -> T
impl<T> core::convert::From<never> for vectormatrix::vector::Vector<T, N>
pub fn vectormatrix::vector::Vector<T, N>::from(t: never) -> T