Struct vecmat::Matrix

#[repr(transparent)]pub struct Matrix<T, const M: usize, const N: usize> { /* fields omitted */ }

Matrix with fixed dimensions.

Implementations

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

pub fn from_vector_of_vectors(a: Vector<Vector<T, N>, M>) -> Self

pub fn from_array_of_vectors(a: [Vector<T, N>; M]) -> Self

pub fn from_array_of_arrays(a: [[T; N]; M]) -> Self

pub fn into_vector_of_vectors(self) -> Vector<Vector<T, N>, M>

pub fn into_array_of_vectors(self) -> [Vector<T, N>; M]

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

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

pub fn as_vector_of_vectors(&self) -> &Vector<Vector<T, N>, M>

pub fn as_mut_vector_of_vectors(&mut self) -> &mut Vector<Vector<T, N>, M>

pub fn as_array_of_vectors(&self) -> &[Vector<T, N>; M]

pub fn as_mut_array_of_vectors(&mut self) -> &mut [Vector<T, N>; M]

pub fn as_array_of_arrays(&self) -> &[[T; N]; M]

pub fn as_mut_array_of_arrays(&mut self) -> &mut [[T; N]; M]

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

pub fn try_from_iter_of_vectors<I>(i: I) -> Option<Self> where
    I: Iterator<Item = Vector<T, N>>, 

pub fn try_from_iter<I>(i: I) -> Option<Self> where
    I: Iterator<Item = T>, 

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

pub fn uninit() -> Matrix<MaybeUninit<T>, M, N>

Create a matrix with uninitialized content.

impl<T, const M: usize, const N: usize> Matrix<MaybeUninit<T>, M, N>

pub unsafe fn assume_init(self) -> Matrix<T, M, N>

Assume that matrix content is initialized.

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

pub fn init<F: FnMut() -> T>(f: F) -> Self

Initialize matrix by closure.

impl<T, const M: usize, const N: usize> Matrix<T, M, N> where
    T: Default, 

pub fn new() -> Self

Create default matrix.

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

pub fn fill(v: T) -> Self

Create matrix which elements are filled with scalar value.

pub fn fill_ref(v: &T) -> Self

Fill with a scalar value reference.

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

pub fn row_ref(&self, i: usize) -> &Vector<T, N>

pub fn row_mut(&mut self, i: usize) -> &mut Vector<T, N>

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

pub fn row(&self, i: usize) -> Vector<T, N>

pub fn col(&self, j: usize) -> Vector<T, M>

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

pub fn as_ptr(&self) -> *const T

Get pointer to the first element.

pub fn as_mut_ptr(&mut self) -> *mut T

Get mutable pointer to the first element.

pub unsafe fn get_unchecked(&self, i: usize, j: usize) -> &T

pub unsafe fn get_unchecked_mut(&mut self, i: usize, j: usize) -> &mut T

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

pub fn iter(&self) -> impl Iterator<Item = &T>

Returns iterator over matrix element refrences.

pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut T>

Returns iterator over matrix element mutable refrences.

impl<const M: usize, const N: usize> Matrix<(usize, usize), M, N>

pub fn indices() -> Self

Create matrix which elements are tuples (j, i) where j and i are coordinates of the matrix cell.

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

pub fn for_each<F: FnMut(T)>(self, f: F)

Call closure for each element of the matrix passing it by value.

pub fn map<U, F: FnMut(T) -> U>(self, f: F) -> Matrix<U, M, N>

Map matrix elements.

pub fn zip<U>(self, other: Matrix<U, M, N>) -> Matrix<(T, U), M, N>

Zip two matrices into one.

impl<T, U, const M: usize, const N: usize> Matrix<(T, U), M, N>

pub fn unzip(self) -> (Matrix<T, M, N>, Matrix<U, M, N>)

Unzip matrix of tuples into two matrices.

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

pub fn fold<S, F: Fn(S, T) -> S>(self, s: S, f: F) -> S

pub fn fold_first<F: FnMut(T, T) -> T>(self, f: F) -> T

pub fn scan<S, U, F: FnMut(&mut S, T) -> U>(self, s: S, f: F) -> Matrix<U, M, N>

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

pub fn sum(self) -> T where
    T: Add<Output = T>, 

pub fn max(self) -> T where
    T: PartialOrd, 

pub fn min(self) -> T where
    T: PartialOrd, 

impl<const M: usize, const N: usize> Matrix<bool, M, N>

pub fn any(self) -> bool

impl<const M: usize, const N: usize> Matrix<bool, M, N>

pub fn all(self) -> bool

impl<T, const M: usize, const N: usize> Matrix<T, M, N> where
    T: Integer, 

pub fn div_floor(self, other: Matrix<T, M, N>) -> Matrix<T, M, N>

pub fn mod_floor(self, other: Matrix<T, M, N>) -> Matrix<T, M, N>

pub fn div_mod_floor(
    self,
    other: Matrix<T, M, N>
) -> (Matrix<T, M, N>, Matrix<T, M, N>)

impl<T, const M: usize, const N: usize> Matrix<T, M, N> where
    T: PartialEq, 

pub fn veq(self, other: Matrix<T, M, N>) -> Matrix<bool, M, N>

pub fn vne(self, other: Matrix<T, M, N>) -> Matrix<bool, M, N>

impl<T, const M: usize, const N: usize> Matrix<T, M, N> where
    T: PartialOrd, 

pub fn vlt(self, other: Matrix<T, M, N>) -> Matrix<bool, M, N>

pub fn vle(self, other: Matrix<T, M, N>) -> Matrix<bool, M, N>

pub fn vgt(self, other: Matrix<T, M, N>) -> Matrix<bool, M, N>

pub fn vge(self, other: Matrix<T, M, N>) -> Matrix<bool, M, N>

impl<T, const N: usize> Matrix<T, N, N> where
    T: Zero, 

pub fn diagonal(diag: Vector<T, N>) -> Self

Create diagonal matrix.

impl<T, const N: usize> Matrix<T, N, N> where
    T: Neg<Output = T> + Num + Copy, 

pub fn cofactor(&self, i: usize, j: usize) -> T

Cofactor of the matrix at (i, j).

pub fn det(&self) -> T

Determinant of the matrix.

pub fn adj(&self) -> Self

Adjugate matrix.

pub fn inv(&self) -> Self

Inverse matrix.

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

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

Trait Implementations

impl<T, const M: usize, const N: usize> AbsDiffEq<Matrix<T, M, N>> for Matrix<T, M, N> where
    T: AbsDiffEq<Epsilon = T> + Copy, 

type Epsilon = T

Used for specifying relative comparisons.

fn default_epsilon() -> Self::Epsilon

The default tolerance to use when testing values that are close together.

fn abs_diff_eq(&self, other: &Self, epsilon: Self::Epsilon) -> bool

A test for equality that uses the absolute difference to compute the approximate equality of two numbers.

pub fn abs_diff_ne(&self, other: &Rhs, epsilon: Self::Epsilon) -> bool

The inverse of AbsDiffEq::abs_diff_eq.

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

type Output = Matrix<T, M, N>

The resulting type after applying the + operator.

fn add(self, vec: Matrix<T, M, N>) -> Self::Output

Performs the + operation.

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

fn add_assign(&mut self, vec: Matrix<T, M, N>)

Performs the += operation.

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

fn as_mut(&mut self) -> &mut Vector<Vector<T, N>, M>

Performs the conversion.

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

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

Performs the conversion.

impl<T, const M: usize, const N: usize> BitAnd<Matrix<T, M, N>> for Matrix<T, M, N> where
    T: BitAnd<Output = T>, 

type Output = Matrix<T, M, N>

The resulting type after applying the & operator.

fn bitand(self, other: Matrix<T, M, N>) -> Self::Output

Performs the & operation.

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

fn bitand_assign(&mut self, other: Matrix<T, M, N>)

Performs the &= operation.

impl<T, const M: usize, const N: usize> BitOr<Matrix<T, M, N>> for Matrix<T, M, N> where
    T: BitOr<Output = T>, 

type Output = Matrix<T, M, N>

The resulting type after applying the | operator.

fn bitor(self, other: Matrix<T, M, N>) -> Self::Output

Performs the | operation.

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

fn bitor_assign(&mut self, other: Matrix<T, M, N>)

Performs the |= operation.

impl<T, const M: usize, const N: usize> BitXor<Matrix<T, M, N>> for Matrix<T, M, N> where
    T: BitXor<Output = T>, 

type Output = Matrix<T, M, N>

The resulting type after applying the ^ operator.

fn bitxor(self, other: Matrix<T, M, N>) -> Self::Output

Performs the ^ operation.

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

fn bitxor_assign(&mut self, other: Matrix<T, M, N>)

Performs the ^= operation.

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

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

Formats the value using the given formatter.

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

fn default() -> Self

Create matrix filled with default values.

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

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

Formats the value using the given formatter.

impl<D: Distribution<T>, T, const M: usize, const N: usize> Distribution<Matrix<T, M, N>> for MatrixDistribution<D, T, M, N>

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Matrix<T, M, N>

Generate a random value of T, using rng as the source of randomness.

pub fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T> where
    R: Rng, 

Create an iterator that generates random values of T, using rng as the source of randomness.

impl<T, const M: usize, const N: usize> Distribution<Matrix<T, M, N>> for Normal where
    Normal: Distribution<T>, 

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Matrix<T, M, N>

Generate a random value of T, using rng as the source of randomness.

pub fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T> where
    R: Rng, 

Create an iterator that generates random values of T, using rng as the source of randomness.

impl<T, const N: usize> Distribution<Matrix<T, N, N>> for Invertible where
    Normal: Distribution<Matrix<T, N, N>>,
    T: Neg<Output = T> + Num + NormL1 + Copy,
    <T as NormL1>::Output: Epsilon, 

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Matrix<T, N, N>

Generate a random value of T, using rng as the source of randomness.

pub fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T> where
    R: Rng, 

Create an iterator that generates random values of T, using rng as the source of randomness.

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

type Output = Matrix<T, M, N>

The resulting type after applying the / operator.

fn div(self, vec: Matrix<T, M, N>) -> Self::Output

Performs the / operation.

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

type Output = Matrix<T, M, N>

The resulting type after applying the / operator.

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

Performs the / operation.

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

fn div_assign(&mut self, vec: Matrix<T, M, N>)

Performs the /= operation.

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

fn div_assign(&mut self, a: T)

Performs the /= operation.

impl<T, const M: usize, const N: usize> Dot<Matrix<T, M, N>> for Vector<T, M> where
    T: Mul<Output = T> + Add<Output = T> + Copy, 

type Output = Vector<T, N>

Dot product output type.

fn dot(self, mat: Matrix<T, M, N>) -> Self::Output

Perform dot product.

impl<T, const L: usize, const M: usize, const N: usize> Dot<Matrix<T, M, N>> for Matrix<T, L, M> where
    T: Mul<Output = T> + Add<Output = T> + Copy, 

type Output = Matrix<T, L, N>

Dot product output type.

fn dot(self, mat: Matrix<T, M, N>) -> Self::Output

Perform dot product.

impl<T, const M: usize, const N: usize> Dot<Vector<T, N>> for Matrix<T, M, N> where
    T: Mul<Output = T> + Add<Output = T> + Copy, 

type Output = Vector<T, M>

Dot product output type.

fn dot(self, vec: Vector<T, N>) -> Self::Output

Perform dot product.

impl<T, const M: usize, const N: usize> From<&'_ [[T; N]; M]> for Matrix<T, M, N> where
    T: Copy, 

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

Performs the conversion.

impl<T, const M: usize, const N: usize> From<&'_ [Vector<T, N>; M]> for Matrix<T, M, N> where
    T: Copy, 

fn from(ar: &[Vector<T, N>; M]) -> Self

Performs the conversion.

impl<T, const M: usize, const N: usize> From<&'_ Vector<Vector<T, N>, M>> for Matrix<T, M, N> where
    T: Copy, 

fn from(ar: &Vector<Vector<T, N>, M>) -> Self

Performs the conversion.

impl<'a, T, const M: usize, const N: usize> From<&'a Matrix<T, M, N>> for &'a Vector<Vector<T, N>, M>

fn from(mr: &'a Matrix<T, M, N>) -> Self

Performs the conversion.

impl<'a, T, const M: usize, const N: usize> From<&'a mut Matrix<T, M, N>> for &'a mut Vector<Vector<T, N>, M>

fn from(mr: &'a mut Matrix<T, M, N>) -> Self

Performs the conversion.

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

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

Performs the conversion.

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

fn from(a: [Vector<T, N>; M]) -> Self

Performs the conversion.

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

fn from(lin: Linear<T, N>) -> Matrix<T, N, N>

Performs the conversion.

impl<T> From<Matrix<T, 2_usize, 2_usize>> for Moebius<T>

fn from(mat: Matrix2x2<T>) -> Self

Performs the conversion.

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

fn from(mat: Matrix<T, M, N>) -> Self

Performs the conversion.

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

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

Performs the conversion.

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

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

Performs the conversion.

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

type Output = T

The returned type after indexing.

fn index(&self, (j, i): (usize, usize)) -> &T

Performs the indexing (container[index]) operation.

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

fn index_mut(&mut self, (j, i): (usize, usize)) -> &mut T

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

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

type Item = T

The type of the elements being iterated over.

type IntoIter = FlatIter<<Vector<Vector<T, N>, M> as IntoIterator>::IntoIter, Vector<T, N>, <Vector<T, N> as IntoIterator>::IntoIter>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T, const M: usize, const N: usize> IntoIterator for &'a Matrix<T, M, N>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = FlatIter<Iter<'a, Vector<T, N>>, &'a Vector<T, N>, Iter<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T, const M: usize, const N: usize> IntoIterator for &'a mut Matrix<T, M, N>

type Item = &'a mut T

The type of the elements being iterated over.

type IntoIter = FlatIter<IterMut<'a, Vector<T, N>>, &'a mut Vector<T, N>, IterMut<'a, T>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

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

type Output = Matrix<T, M, N>

The resulting type after applying the * operator.

fn mul(self, vec: Matrix<T, M, N>) -> Self::Output

Performs the * operation.

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

type Output = Matrix<T, M, N>

The resulting type after applying the * operator.

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

Performs the * operation.

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

fn mul_assign(&mut self, vec: Matrix<T, M, N>)

Performs the *= operation.

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

fn mul_assign(&mut self, a: T)

Performs the *= operation.

impl<T, const M: usize, const N: usize> Neg for Matrix<T, M, N> where
    T: Neg<Output = T>, 

type Output = Matrix<T, M, N>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

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

type Output = T

Type of the norm.

fn norm_l1(self) -> T

Norm of the element.

impl<T, const M: usize, const N: usize> NormL2 for Matrix<T, M, N> where
    T: Float, 

type Output = T

Type of the norm.

fn norm_l2_sqr(self) -> T

Square norm of the element.

fn norm_l2(self) -> T

Norm of the element.

impl<T, const M: usize, const N: usize> NormLInf for Matrix<T, M, N> where
    T: NormLInf<Output = T> + PartialOrd, 

type Output = T

Type of the norm.

fn norm_l_inf(self) -> T

Norm of the element.

impl<T, const M: usize, const N: usize> Not for Matrix<T, M, N> where
    T: Not<Output = T>, 

type Output = Matrix<T, M, N>

The resulting type after applying the ! operator.

fn not(self) -> Self::Output

Performs the unary ! operation.

impl<T, const N: usize> One for Matrix<T, N, N> where
    T: One + Zero, 

fn one() -> Self

Create identity matrix.

pub fn set_one(&mut self)

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

pub fn is_one(&self) -> bool where
    Self: PartialEq<Self>, 

Returns true if self is equal to the multiplicative identity.

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

fn eq(&self, other: &Matrix<T, M, N>) -> bool

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

fn ne(&self, other: &Matrix<T, M, N>) -> bool

This method tests for !=.

impl<T, const M: usize, const N: usize> Rem<Matrix<T, M, N>> for Matrix<T, M, N> where
    T: Rem<Output = T>, 

type Output = Matrix<T, M, N>

The resulting type after applying the % operator.

fn rem(self, vec: Matrix<T, M, N>) -> Self::Output

Performs the % operation.

impl<T, const M: usize, const N: usize> Rem<T> for Matrix<T, M, N> where
    T: Rem<Output = T> + Copy, 

type Output = Matrix<T, M, N>

The resulting type after applying the % operator.

fn rem(self, a: T) -> Self::Output

Performs the % operation.

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

fn rem_assign(&mut self, vec: Matrix<T, M, N>)

Performs the %= operation.

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

fn rem_assign(&mut self, a: T)

Performs the %= operation.

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

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

type Output = Matrix<T, M, N>

The resulting type after applying the - operator.

fn sub(self, vec: Matrix<T, M, N>) -> Self::Output

Performs the - operation.

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

fn sub_assign(&mut self, vec: Matrix<T, M, N>)

Performs the -= operation.

impl<'a, T, const M: usize, const N: usize> TryFrom<&'a [T]> for Matrix<T, M, N> where
    T: Copy, 

type Error = ()

The type returned in the event of a conversion error.

fn try_from(s: &'a [T]) -> Result<Self, ()>

Performs the conversion.

impl<'a, T, const M: usize, const N: usize> TryFrom<&'a [Vector<T, N>]> for Matrix<T, M, N> where
    T: Copy, 

type Error = ()

The type returned in the event of a conversion error.

fn try_from(s: &'a [Vector<T, N>]) -> Result<Self, ()>

Performs the conversion.

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

fn zero() -> Self

Returns the additive identity element of Self, 0.

fn is_zero(&self) -> bool

Returns true if self is equal to the additive identity.

pub fn set_zero(&mut self)

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