Struct const_alg::Matrix

#[repr(transparent)]
pub struct Matrix<T, const N: usize, const M: usize>(pub [[T; M]; N]);

Matrix represents an N x M matrix stored in row-major order

So when you go to make it, you can just do

Matrix(
    [[0, 1, 2],
     [3, 4, 5]]
)

And Rust will take care of the rest!

Methods

impl<T, const N: usize, const M: usize> Matrix<T, { N }, { M }>

Important traits for IntoRows<T, { N }, { M }>

impl<T, const N: usize, const M: usize> Iterator for IntoRows<T, { N }, { M }> type Item = IntoLine<T, { M }>;

pub fn into_rows(self) -> IntoRows<T, { N }, { M }>

Consumes the matrix and iterates over its rows

Important traits for IntoCols<T, { N }, { M }>

impl<T, const N: usize, const M: usize> Iterator for IntoCols<T, { N }, { M }> type Item = IntoLine<T, { N }>;

pub fn into_cols(self) -> IntoCols<T, { N }, { M }>

Consumes the matrix and iterates over its columns

Important traits for RowsMut<'a, T, { N }, { M }>

impl<'a, T, const N: usize, const M: usize> Iterator for RowsMut<'a, T, { N }, { M }> type Item = RowMut<'a, T, { N }, { M }>;

pub fn rows_mut(&mut self) -> RowsMut<T, { N }, { M }>

iterates over unique references to rows of a matrix

Important traits for ColsMut<'a, T, { N }, { M }>

impl<'a, T, const N: usize, const M: usize> Iterator for ColsMut<'a, T, { N }, { M }> type Item = ColMut<'a, T, { N }, { M }>;

pub fn cols_mut(&mut self) -> ColsMut<T, { N }, { M }>

iterates over unique references to columns of a matrix

Important traits for Rows<'a, T, { N }, { M }>

impl<'a, T, const N: usize, const M: usize> Iterator for Rows<'a, T, { N }, { M }> type Item = Row<'a, T, { N }, { M }>;

pub fn rows(&self) -> Rows<T, { N }, { M }>

iterates over shared references to rows of a matrix

Important traits for Cols<'a, T, { N }, { M }>

impl<'a, T, const N: usize, const M: usize> Iterator for Cols<'a, T, { N }, { M }> type Item = Col<'a, T, { N }, { M }>;

pub fn cols(&self) -> Cols<T, { N }, { M }>

iterates over shared references to columns of a matrix

impl<T, const N: usize, const M: usize> Matrix<T, { N }, { M }>

pub fn T(self) -> Matrix<T, { M }, { N }>

Transposes the matrix,

This is some sugar for transpose

pub fn transpose(self) -> Matrix<T, { M }, { N }>

Does the matrix transpose of the given matrix

Every element matrix[(row, col)] will be taken to output[(col, row)]

pub fn get(&self, row: usize, col: usize) -> Option<&T>

Gets an element from the matrix

If the row or col is out of bounds, None is returned

pub fn get_mut(&mut self, row: usize, col: usize) -> Option<&mut T>

Gets an element from the matrix

If the row or col is out of bounds, None is returned

pub unsafe fn get_unchecked(&self, row: usize, col: usize) -> &T

Gets an element from the matrix

If the row or col is out of bounds, this causes UB on release mode, and panics on debug mode

pub unsafe fn get_unchecked_mut(&mut self, row: usize, col: usize) -> &mut T

Gets an element from the matrix

If the row or col is out of bounds, this causes UB on release mode, and panics on debug mode

pub fn get_all_mut<const P: usize>(
    &mut self,
    pos: [(usize, usize); P]
) -> [Option<&mut T>; P]

Get's all of the elements specified by the array,

If there are any duplicates, the first one will return a value and the rest will be None,

If any pos is out of bounds, it will result in None

Example,

let m = Matrix(
    [[0, 1, 2],
     [3, 4, 5]]
);
 
assert_eq!(m.get_all_mut([(0, 0), (0, 2), (2, 0), (0, 0)]), [Some(&mut 0), Some(&mut 2), None, None]);

Trait Implementations

impl<T, U, V, F, const N: usize, const M: usize> ZipWith<Matrix<U, N, M>, F> for Matrix<T, { N }, { M }> where
    F: FnMut(T, U) -> V, 

type Output = Matrix<V, { N }, { M }>

default fn zip_with(self, other: Matrix<U, { N }, { M }>, f: F) -> Self::Output

impl<'b, T, U, V, F, const N: usize, const M: usize> ZipWith<&'b mut Matrix<U, N, M>, F> for Matrix<T, { N }, { M }> where
    F: FnMut(T, &'b mut U) -> V, 

type Output = Matrix<V, { N }, { M }>

default fn zip_with(
    self,
    other: &'b mut Matrix<U, { N }, { M }>,
    f: F
) -> Self::Output

impl<'b, T, U, V, F, const N: usize, const M: usize> ZipWith<&'b Matrix<U, N, M>, F> for Matrix<T, { N }, { M }> where
    F: FnMut(T, &'b U) -> V, 

type Output = Matrix<V, { N }, { M }>

default fn zip_with(
    self,
    other: &'b Matrix<U, { N }, { M }>,
    f: F
) -> Self::Output

impl<'a, T, U, V, F, const N: usize, const M: usize> ZipWith<Matrix<U, N, M>, F> for &'a mut Matrix<T, { N }, { M }> where
    F: FnMut(&'a mut T, U) -> V, 

type Output = Matrix<V, { N }, { M }>

default fn zip_with(self, other: Matrix<U, { N }, { M }>, f: F) -> Self::Output

impl<'a, 'b, T, U, V, F, const N: usize, const M: usize> ZipWith<&'b mut Matrix<U, N, M>, F> for &'a mut Matrix<T, { N }, { M }> where
    F: FnMut(&'a mut T, &'b mut U) -> V, 

type Output = Matrix<V, { N }, { M }>

default fn zip_with(
    self,
    other: &'b mut Matrix<U, { N }, { M }>,
    f: F
) -> Self::Output

impl<'a, 'b, T, U, V, F, const N: usize, const M: usize> ZipWith<&'b Matrix<U, N, M>, F> for &'a mut Matrix<T, { N }, { M }> where
    F: FnMut(&'a mut T, &'b U) -> V, 

type Output = Matrix<V, { N }, { M }>

default fn zip_with(
    self,
    other: &'b Matrix<U, { N }, { M }>,
    f: F
) -> Self::Output

impl<'a, T, U, V, F, const N: usize, const M: usize> ZipWith<Matrix<U, N, M>, F> for &'a Matrix<T, { N }, { M }> where
    F: FnMut(&'a T, U) -> V, 

type Output = Matrix<V, { N }, { M }>

default fn zip_with(self, other: Matrix<U, { N }, { M }>, f: F) -> Self::Output

impl<'a, 'b, T, U, V, F, const N: usize, const M: usize> ZipWith<&'b mut Matrix<U, N, M>, F> for &'a Matrix<T, { N }, { M }> where
    F: FnMut(&'a T, &'b mut U) -> V, 

type Output = Matrix<V, { N }, { M }>

default fn zip_with(
    self,
    other: &'b mut Matrix<U, { N }, { M }>,
    f: F
) -> Self::Output

impl<'a, 'b, T, U, V, F, const N: usize, const M: usize> ZipWith<&'b Matrix<U, N, M>, F> for &'a Matrix<T, { N }, { M }> where
    F: FnMut(&'a T, &'b U) -> V, 

type Output = Matrix<V, { N }, { M }>

default fn zip_with(
    self,
    other: &'b Matrix<U, { N }, { M }>,
    f: F
) -> Self::Output

impl<T, U, F, const N: usize, const M: usize> ZipWith<Matrix<U, N, M>, F> for Matrix<T, { N }, { M }> where
    F: FnMut(T, U), 

default fn zip_with(self, other: Matrix<U, { N }, { M }>, f: F) -> Self::Output

type Output

impl<'b, T, U, F, const N: usize, const M: usize> ZipWith<&'b mut Matrix<U, N, M>, F> for Matrix<T, { N }, { M }> where
    F: FnMut(T, &'b mut U), 

default fn zip_with(
    self,
    other: &'b mut Matrix<U, { N }, { M }>,
    f: F
) -> Self::Output

type Output

impl<'b, T, U, F, const N: usize, const M: usize> ZipWith<&'b Matrix<U, N, M>, F> for Matrix<T, { N }, { M }> where
    F: FnMut(T, &'b U), 

default fn zip_with(
    self,
    other: &'b Matrix<U, { N }, { M }>,
    f: F
) -> Self::Output

type Output

impl<'a, T, U, F, const N: usize, const M: usize> ZipWith<Matrix<U, N, M>, F> for &'a mut Matrix<T, { N }, { M }> where
    F: FnMut(&'a mut T, U), 

default fn zip_with(self, other: Matrix<U, { N }, { M }>, f: F) -> Self::Output

type Output

impl<'a, 'b, T, U, F, const N: usize, const M: usize> ZipWith<&'b mut Matrix<U, N, M>, F> for &'a mut Matrix<T, { N }, { M }> where
    F: FnMut(&'a mut T, &'b mut U), 

default fn zip_with(
    self,
    other: &'b mut Matrix<U, { N }, { M }>,
    f: F
) -> Self::Output

type Output

impl<'a, 'b, T, U, F, const N: usize, const M: usize> ZipWith<&'b Matrix<U, N, M>, F> for &'a mut Matrix<T, { N }, { M }> where
    F: FnMut(&'a mut T, &'b U), 

default fn zip_with(
    self,
    other: &'b Matrix<U, { N }, { M }>,
    f: F
) -> Self::Output

type Output

impl<'a, T, U, F, const N: usize, const M: usize> ZipWith<Matrix<U, N, M>, F> for &'a Matrix<T, { N }, { M }> where
    F: FnMut(&'a T, U), 

default fn zip_with(self, other: Matrix<U, { N }, { M }>, f: F) -> Self::Output

type Output

impl<'a, 'b, T, U, F, const N: usize, const M: usize> ZipWith<&'b mut Matrix<U, N, M>, F> for &'a Matrix<T, { N }, { M }> where
    F: FnMut(&'a T, &'b mut U), 

default fn zip_with(
    self,
    other: &'b mut Matrix<U, { N }, { M }>,
    f: F
) -> Self::Output

type Output

impl<'a, 'b, T, U, F, const N: usize, const M: usize> ZipWith<&'b Matrix<U, N, M>, F> for &'a Matrix<T, { N }, { M }> where
    F: FnMut(&'a T, &'b U), 

default fn zip_with(
    self,
    other: &'b Matrix<U, { N }, { M }>,
    f: F
) -> Self::Output

type Output

impl<F, T, U, const N: usize, const M: usize> Map<F> for Matrix<T, { N }, { M }> where
    F: FnMut(T) -> U, 

type Output = Matrix<U, { N }, { M }>

default fn map(self, f: F) -> Self::Output

impl<F, T, const N: usize, const M: usize> Map<F> for Matrix<T, { N }, { M }> where
    F: FnMut(T), 

default fn map(self, f: F) -> Self::Output

type Output

impl<'a, F, T, U, const N: usize, const M: usize> Map<F> for &'a mut Matrix<T, { N }, { M }> where
    F: FnMut(&'a mut T) -> U, 

type Output = Matrix<U, { N }, { M }>

default fn map(self, f: F) -> Self::Output

impl<'a, F, T, U, const N: usize, const M: usize> Map<F> for &'a Matrix<T, { N }, { M }> where
    F: FnMut(&'a T) -> U, 

type Output = Matrix<U, { N }, { M }>

default fn map(self, f: F) -> Self::Output

impl<'a, T, F, const N: usize, const M: usize> Map<F> for &'a mut Matrix<T, { N }, { M }> where
    F: FnMut(&'a mut T), 

default fn map(self, f: F) -> Self::Output

type Output

impl<'a, 'b, T, F, const N: usize, const M: usize> Map<F> for &'a Matrix<T, { N }, { M }> where
    F: FnMut(&'a T), 

default fn map(self, f: F) -> Self::Output

type Output

impl<T, F, const N: usize, const M: usize> ForEach<F> for Matrix<T, { N }, { M }> where
    F: FnMut(T), 

fn for_each(self, f: F)

impl<'a, T, F, const N: usize, const M: usize> ForEach<F> for &'a mut Matrix<T, { N }, { M }> where
    F: FnMut(&'a mut T), 

fn for_each(self, f: F)

impl<'a, T, F, const N: usize, const M: usize> ForEach<F> for &'a Matrix<T, { N }, { M }> where
    F: FnMut(&'a T), 

fn for_each(self, f: F)

impl<T, U, F, const N: usize, const M: usize> ForBoth<Matrix<U, N, M>, F> for Matrix<T, { N }, { M }> where
    F: FnMut(T, U), 

fn for_both(self, other: Matrix<U, { N }, { M }>, f: F)

impl<'b, T, U, F, const N: usize, const M: usize> ForBoth<&'b mut Matrix<U, N, M>, F> for Matrix<T, { N }, { M }> where
    F: FnMut(T, &'b mut U), 

fn for_both(self, other: &'b mut Matrix<U, { N }, { M }>, f: F)

impl<'b, T, U, F, const N: usize, const M: usize> ForBoth<&'b Matrix<U, N, M>, F> for Matrix<T, { N }, { M }> where
    F: FnMut(T, &'b U), 

fn for_both(self, other: &'b Matrix<U, { N }, { M }>, f: F)

impl<'a, T, U, F, const N: usize, const M: usize> ForBoth<Matrix<U, N, M>, F> for &'a mut Matrix<T, { N }, { M }> where
    F: FnMut(&'a mut T, U), 

fn for_both(self, other: Matrix<U, { N }, { M }>, f: F)

impl<'a, 'b, T, U, F, const N: usize, const M: usize> ForBoth<&'b mut Matrix<U, N, M>, F> for &'a mut Matrix<T, { N }, { M }> where
    F: FnMut(&'a mut T, &'b mut U), 

fn for_both(self, other: &'b mut Matrix<U, { N }, { M }>, f: F)

impl<'a, 'b, T, U, F, const N: usize, const M: usize> ForBoth<&'b Matrix<U, N, M>, F> for &'a mut Matrix<T, { N }, { M }> where
    F: FnMut(&'a mut T, &'b U), 

fn for_both(self, other: &'b Matrix<U, { N }, { M }>, f: F)

impl<'a, T, U, F, const N: usize, const M: usize> ForBoth<Matrix<U, N, M>, F> for &'a Matrix<T, { N }, { M }> where
    F: FnMut(&'a T, U), 

fn for_both(self, other: Matrix<U, { N }, { M }>, f: F)

impl<'a, 'b, T, U, F, const N: usize, const M: usize> ForBoth<&'b mut Matrix<U, N, M>, F> for &'a Matrix<T, { N }, { M }> where
    F: FnMut(&'a T, &'b mut U), 

fn for_both(self, other: &'b mut Matrix<U, { N }, { M }>, f: F)

impl<'a, 'b, T, U, F, const N: usize, const M: usize> ForBoth<&'b Matrix<U, N, M>, F> for &'a Matrix<T, { N }, { M }> where
    F: FnMut(&'a T, &'b U), 

fn for_both(self, other: &'b Matrix<U, { N }, { M }>, f: F)

impl<T: PartialEq, const N: usize, const M: usize> PartialEq<Matrix<T, N, M>> for Matrix<T, { N }, { M }>

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

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

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

This method tests for !=.

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

impl<T: Eq, const N: usize, const M: usize> Eq for Matrix<T, { N }, { M }>

impl<T, const N: usize, const M: usize> From<[[T; M]; N]> for Matrix<T, { N }, { M }>

fn from(arr: [[T; M]; N]) -> Self

Performs the conversion.

impl<T, const N: usize, const M: usize> Into<[[T; M]; N]> for Matrix<T, { N }, { M }>

fn into(self) -> [[T; M]; N]

Performs the conversion.

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, const N: usize, const M: usize> Deref for Matrix<T, { N }, { M }>

type Target = [[T; M]; N]

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T, const N: usize, const M: usize> DerefMut for Matrix<T, { N }, { M }>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<T: Hash, const N: usize, const M: usize> Hash for Matrix<T, { N }, { M }>

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

Feeds this value into the given [Hasher].

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

Feeds a slice of this type into the given [Hasher].

impl<T, const N: usize, const M: usize> Add<Matrix<T, N, M>> for Matrix<T, { N }, { M }> where
    T: Add<Output = T>, 

type Output = Self

The resulting type after applying the + operator.

fn add(self, other: Self) -> Self

Performs the + operation.

impl<T, const N: usize, const M: usize> Sub<Matrix<T, N, M>> for Matrix<T, { N }, { M }> where
    T: Sub<Output = T>, 

type Output = Self

The resulting type after applying the - operator.

fn sub(self, other: Self) -> Self

Performs the - operation.

impl<'a, 'b, T, const N: usize, const M: usize, const O: usize> Mul<&'b Matrix<T, M, O>> for &'a Matrix<T, { N }, { M }> where
    T: Add<Output = T> + Mul<Output = T> + Zero + Clone, 

type Output = Matrix<T, { N }, { O }>

The resulting type after applying the * operator.

fn mul(self, other: &'b Matrix<T, { M }, { O }>) -> Matrix<T, { N }, { O }>

Performs the * operation.

impl<'a, 'b, T, const N: usize, const M: usize, const O: usize> Mul<&'b mut Matrix<T, M, O>> for &'a Matrix<T, { N }, { M }> where
    T: Add<Output = T> + Mul<Output = T> + Zero + Clone, 

type Output = Matrix<T, { N }, { O }>

The resulting type after applying the * operator.

fn mul(self, other: &'b mut Matrix<T, { M }, { O }>) -> Matrix<T, { N }, { O }>

Performs the * operation.

impl<'a, 'b, T, const N: usize, const M: usize, const O: usize> Mul<Matrix<T, M, O>> for &'a Matrix<T, { N }, { M }> where
    T: Add<Output = T> + Mul<Output = T> + Zero + Clone, 

type Output = Matrix<T, { N }, { O }>

The resulting type after applying the * operator.

fn mul(self, other: Matrix<T, { M }, { O }>) -> Matrix<T, { N }, { O }>

Performs the * operation.

impl<'a, 'b, T, const N: usize, const M: usize, const O: usize> Mul<&'b Matrix<T, M, O>> for &'a mut Matrix<T, { N }, { M }> where
    T: Add<Output = T> + Mul<Output = T> + Zero + Clone, 

type Output = Matrix<T, { N }, { O }>

The resulting type after applying the * operator.

fn mul(self, other: &'b Matrix<T, { M }, { O }>) -> Matrix<T, { N }, { O }>

Performs the * operation.

impl<'a, 'b, T, const N: usize, const M: usize, const O: usize> Mul<&'b mut Matrix<T, M, O>> for &'a mut Matrix<T, { N }, { M }> where
    T: Add<Output = T> + Mul<Output = T> + Zero + Clone, 

type Output = Matrix<T, { N }, { O }>

The resulting type after applying the * operator.

fn mul(self, other: &'b mut Matrix<T, { M }, { O }>) -> Matrix<T, { N }, { O }>

Performs the * operation.

impl<'a, 'b, T, const N: usize, const M: usize, const O: usize> Mul<Matrix<T, M, O>> for &'a mut Matrix<T, { N }, { M }> where
    T: Add<Output = T> + Mul<Output = T> + Zero + Clone, 

type Output = Matrix<T, { N }, { O }>

The resulting type after applying the * operator.

fn mul(self, other: Matrix<T, { M }, { O }>) -> Matrix<T, { N }, { O }>

Performs the * operation.

impl<'a, 'b, T, const N: usize, const M: usize, const O: usize> Mul<&'b Matrix<T, M, O>> for Matrix<T, { N }, { M }> where
    T: Add<Output = T> + Mul<Output = T> + Zero + Clone, 

type Output = Matrix<T, { N }, { O }>

The resulting type after applying the * operator.

fn mul(self, other: &'b Matrix<T, { M }, { O }>) -> Matrix<T, { N }, { O }>

Performs the * operation.

impl<'a, 'b, T, const N: usize, const M: usize, const O: usize> Mul<&'b mut Matrix<T, M, O>> for Matrix<T, { N }, { M }> where
    T: Add<Output = T> + Mul<Output = T> + Zero + Clone, 

type Output = Matrix<T, { N }, { O }>

The resulting type after applying the * operator.

fn mul(self, other: &'b mut Matrix<T, { M }, { O }>) -> Matrix<T, { N }, { O }>

Performs the * operation.

impl<'a, 'b, T, const N: usize, const M: usize, const O: usize> Mul<Matrix<T, M, O>> for Matrix<T, { N }, { M }> where
    T: Add<Output = T> + Mul<Output = T> + Zero + Clone, 

type Output = Matrix<T, { N }, { O }>

The resulting type after applying the * operator.

fn mul(self, other: Matrix<T, { M }, { O }>) -> Matrix<T, { N }, { O }>

Performs the * operation.

impl<T, const N: usize, const M: usize> Mul<T> for Matrix<T, { N }, { M }> where
    T: Mul<Output = T> + Clone, 

type Output = Matrix<T, { N }, { M }>

The resulting type after applying the * operator.

fn mul(self, other: T) -> Matrix<T, { N }, { M }>

Performs the * operation.

impl<T, const N: usize, const M: usize> Div<T> for Matrix<T, { N }, { M }> where
    T: Div<Output = T> + Clone, 

type Output = Matrix<T, { N }, { M }>

The resulting type after applying the / operator.

fn div(self, other: T) -> Matrix<T, { N }, { M }>

Performs the / operation.

impl<T, const N: usize, const M: usize> Neg for Matrix<T, { N }, { M }> where
    T: Neg, 

type Output = Matrix<T::Output, { N }, { M }>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<T, const N: usize, const M: usize> AddAssign<Matrix<T, N, M>> for Matrix<T, { N }, { M }> where
    T: AddAssign, 

fn add_assign(&mut self, other: Self)

Performs the += operation.

impl<T, const N: usize, const M: usize> SubAssign<Matrix<T, N, M>> for Matrix<T, { N }, { M }> where
    T: SubAssign, 

fn sub_assign(&mut self, other: Self)

Performs the -= operation.

impl<T, const N: usize> MulAssign<Matrix<T, N, N>> for Matrix<T, { N }, { N }> where
    T: Add<Output = T> + Mul<Output = T> + Zero + Clone, 

fn mul_assign(&mut self, other: Self)

Performs the *= operation.

impl<T, const N: usize, const M: usize> MulAssign<T> for Matrix<T, { N }, { M }> where
    T: MulAssign + Clone, 

fn mul_assign(&mut self, other: T)

Performs the *= operation.

impl<T, const N: usize, const M: usize> DivAssign<T> for Matrix<T, { N }, { M }> where
    T: DivAssign + Clone, 

fn div_assign(&mut self, other: T)

Performs the /= operation.

impl<T, const N: usize, const M: usize> Index<(usize, usize)> for Matrix<T, { N }, { M }>

type Output = T

The returned type after indexing.

fn index(&self, (row, col): (usize, usize)) -> &T

Performs the indexing (container[index]) operation.

impl<T, const N: usize, const M: usize> IndexMut<(usize, usize)> for Matrix<T, { N }, { M }>

fn index_mut(&mut self, (row, col): (usize, usize)) -> &mut T

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

impl<T: Debug, const N: usize, const M: usize> Debug for Matrix<T, { N }, { M }>

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

Formats the value using the given formatter.

impl<T: Zero, const N: usize, const M: usize> Zero for Matrix<T, { N }, { M }>

fn zero() -> Self

Returns the additive identity element of Self, 0. # Purity

fn set_zero(&mut self)

Sets self to the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

impl<T: PartialEq + Zero + One, const N: usize> One for Matrix<T, { N }, { N }> where
    Self: Mul<Output = Self>, 

fn one() -> Self

Returns the multiplicative identity element of Self, 1.

fn set_one(&mut self)

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

fn is_one(&self) -> bool

Returns true if self is equal to the multiplicative identity.