Struct Matrix 

pub struct Matrix<Set: Clone> { /* private fields */ }

Implementations

impl<F: MetaType> Matrix<F>

where F::Signature: ComplexConjugateSignature + FieldSignature,

pub fn gram_schmidt_row_orthogonalization_algorithm( self, ) -> (Matrix<F>, Matrix<F>)

pub fn gram_schmidt_col_orthogonalization_algorithm( self, ) -> (Matrix<F>, Matrix<F>)

pub fn gram_schmidt_row_orthogonalization(self) -> Matrix<F>

pub fn gram_schmidt_col_orthogonalization(self) -> Matrix<F>

impl<F: MetaType> Matrix<F>

where F::Signature: ComplexConjugateSignature + PositiveRealNthRootSignature + FieldSignature,

pub fn lq_decomposition_algorithm(self) -> (Matrix<F>, Matrix<F>)

pub fn qr_decomposition_algorithm(self) -> (Matrix<F>, Matrix<F>)

pub fn gram_schmidt_row_orthonormalization(self) -> Matrix<F>

pub fn gram_schmidt_col_orthonormalization(self) -> Matrix<F>

impl<R: MetaType> Matrix<R>

where R::Signature: BezoutDomainSignature,

pub fn row_hermite_algorithm(&self) -> (Self, Self, R, Vec<usize>)

pub fn col_hermite_algorithm(&self) -> (Self, Self, R, Vec<usize>)

pub fn det(&self) -> Result<R, MatOppErr>

pub fn rank(&self) -> usize

impl<R: MetaType> Matrix<R>

where R::Signature: EuclideanDomainSignature + BezoutDomainSignature + FavoriteAssociateSignature,

pub fn row_reduced_hermite_algorithm(&self) -> (Self, Self, R, Vec<usize>)

pub fn row_reduced_hermite_normal_form(&self) -> Self

pub fn col_reduced_hermite_algorithm(&self) -> (Self, Self, R, Vec<usize>)

pub fn col_reduced_hermite_normal_form(&self) -> Self

pub fn inv(&self) -> Result<Matrix<R>, MatOppErr>

pub fn row_span(self) -> FinitelyFreeSubmodule<R>

pub fn col_span(self) -> FinitelyFreeSubmodule<R>

pub fn row_kernel(self) -> FinitelyFreeSubmodule<R>

pub fn col_kernel(self) -> FinitelyFreeSubmodule<R>

pub fn row_preimage( &self, space: &FinitelyFreeSubmodule<R>, ) -> FinitelyFreeSubmodule<R>

pub fn col_preimage( &self, space: &FinitelyFreeSubmodule<R>, ) -> FinitelyFreeSubmodule<R>

pub fn row_affine_span(self) -> FinitelyFreeSubmoduleAffineSubset<R>

pub fn col_affine_span(self) -> FinitelyFreeSubmoduleAffineSubset<R>

pub fn row_solve(self, y: &Vec<R>) -> Option<Vec<R>>

pub fn col_solve(self, y: &Vec<R>) -> Option<Vec<R>>

pub fn row_solution_set( self, y: &Vec<R>, ) -> FinitelyFreeSubmoduleAffineSubset<R>

pub fn col_solution_set( self, y: &Vec<R>, ) -> FinitelyFreeSubmoduleAffineSubset<R>

impl<Set: Clone> Matrix<Set>

pub fn full(rows: usize, cols: usize, elem: &Set) -> Self

pub fn construct( rows: usize, cols: usize, make_entry: impl Fn(usize, usize) -> Set, ) -> Self

Construct a matrix from a closure.

use algebraeon_nzq::Integer;
use algebraeon_rings::matrix::Matrix;
let a = Matrix::<Integer>::construct(2, 3, |r, c| if (r + c) % 2 == 0 { Integer::ZERO } else { Integer::ONE });
let b = Matrix::<Integer>::from_rows(
    vec![
        vec![Integer::ZERO, Integer::ONE, Integer::ZERO],
        vec![Integer::ONE, Integer::ZERO, Integer::ONE]
    ]
);
assert_eq!(a, b);

pub fn from_rows(rows_elems: Vec<Vec<impl Into<Set> + Clone>>) -> Self

Construct a matrix from a list of rows.

pub fn from_cols(cols_elems: Vec<Vec<impl Into<Set> + Clone>>) -> Self

Construct a matrix from a list of columns.

pub fn from_row(elems: Vec<impl Into<Set> + Clone>) -> Self

Construct a matrix from a row.

pub fn from_col(elems: Vec<impl Into<Set> + Clone>) -> Self

Construct a matrix from a column.

pub fn at(&self, r: usize, c: usize) -> Result<&Set, MatOppErr>

Get a reference to the entry at row r and column c.

pub fn at_mut(&mut self, r: usize, c: usize) -> Result<&mut Set, MatOppErr>

Get a mutable reference to the entry at row r and column c.

pub fn rows(&self) -> usize

pub fn cols(&self) -> usize

pub fn submatrix(&self, rows: Vec<usize>, cols: Vec<usize>) -> Self

Return the submatrix given by the intersection of the rows defined by rows and the columns defined by cols.

pub fn get_row_submatrix(&self, row: usize) -> Self

pub fn get_col_submatrix(&self, col: usize) -> Self

pub fn get_row_refs(&self, row: usize) -> Vec<&Set>

pub fn get_col_refs(&self, col: usize) -> Vec<&Set>

pub fn get_row(&self, row: usize) -> Vec<Set>

pub fn get_col(&self, col: usize) -> Vec<Set>

pub fn apply_map<NewSet: Clone>( &self, f: impl Fn(&Set) -> NewSet, ) -> Matrix<NewSet>

Apply a function f to the entries of this matrix, producing a new matrix.

pub fn transpose(self) -> Self

pub fn transpose_ref(&self) -> Self

pub fn transpose_mut(&mut self)

pub fn flip_rows(self) -> Self

pub fn flip_rows_ref(&self) -> Self

pub fn flip_rows_mut(&mut self)

pub fn flip_cols(self) -> Self

pub fn flip_cols_ref(&self) -> Self

pub fn flip_cols_mut(&mut self)

pub fn join_rows<MatT: Borrow<Matrix<Set>>>( cols: usize, mats: Vec<MatT>, ) -> Matrix<Set>

Concatenate the rows of the matrices in mats into a single matrix.

cols must match the number of columns of every matrix in mats. The purpose of this input is to produce an empty matrix of the correct dimension when mats is empty.

Panics

This function panics if cols does not match the number of columns of every matrix in mats.

pub fn join_cols<MatT: Borrow<Matrix<Set>>>( rows: usize, mats: Vec<MatT>, ) -> Matrix<Set>

Concatenate the columns of the matrices in mats into a single matrix.

rows must match the number of rows of every matrix in mats. The purpose of this input is to produce an empty matrix of the correct dimension when mats is empty.

Panics

This function panics if rows does not match the number of rows of every matrix in mats.

pub fn entries_list(&self) -> Vec<&Set>

Return a vector containing the entries of this matrix.

Most useful when this matrix is a row vector or a column vector.

impl<R: MetaType> Matrix<R>

where R::Signature: ToStringSignature,

pub fn pprint(&self)

impl<R: MetaType> Matrix<R>

where R::Signature: RingSignature,

pub fn zero(rows: usize, cols: usize) -> Self

pub fn ident(n: usize) -> Self

pub fn diag(diag: &[R]) -> Self

pub fn dot(a: &Self, b: &Self) -> R

pub fn add_mut(&mut self, b: &Self) -> Result<(), MatOppErr>

pub fn add(a: &Self, b: &Self) -> Result<Self, MatOppErr>

pub fn neg_mut(&mut self)

pub fn neg(&self) -> Self

pub fn mul(a: &Self, b: &Self) -> Result<Self, MatOppErr>

pub fn apply_row(&self, row: &[R]) -> Vec<R>

pub fn apply_col(&self, col: &[R]) -> Vec<R>

pub fn mul_scalar(&self, scalar: &R) -> Matrix<R>

pub fn mul_scalar_ref(&self, scalar: &R) -> Matrix<R>

pub fn det_naive(&self) -> Result<R, MatOppErr>

pub fn trace(&self) -> Result<R, MatOppErr>

impl<F: MetaType> Matrix<F>

where F::Signature: FieldSignature,

pub fn presentation_matrix(&self) -> Result<Matrix<Polynomial<F>>, MatOppErr>

pub fn minimal_polynomial(&self) -> Result<Polynomial<F>, MatOppErr>

pub fn characteristic_polynomial(&self) -> Result<Polynomial<F>, MatOppErr>

impl<R: MetaType> Matrix<R>

where R::Signature: GreatestCommonDivisorSignature,

pub fn factor_primitive(self) -> Option<(R, Matrix<R>)>

pub fn primitive_part(self) -> Option<Matrix<R>>

impl<Field: MetaType> Matrix<Field>

where Field::Signature: FieldSignature, PrincipalIntegerMap<Field::Signature, Field::Signature>: FieldOfFractionsInclusion<IntegerCanonicalStructure, Field::Signature>,

pub fn factor_primitive_fof(&self) -> (Field, Matrix<Integer>)

impl<R: MetaType> Matrix<R>

where R::Signature: BezoutDomainSignature,

pub fn smith_algorithm(&self) -> (Self, Self, Self, usize)

Trait Implementations

impl<Set: Clone + Clone> Clone for Matrix<Set>

fn clone(&self) -> Matrix<Set>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Set: Debug + Clone> Debug for Matrix<Set>

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

Formats the value using the given formatter.

impl<R: MetaType> MetaType for Matrix<R>

where R::Signature: SetSignature,

type Signature = MatrixStructure<<R as MetaType>::Signature, <R as MetaType>::Signature>

fn structure() -> Self::Signature

impl<R: MetaType> PartialEq for Matrix<R>

where R::Signature: RingSignature + EqSignature,

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<R: MetaType> Eq for Matrix<R>

where R::Signature: RingSignature + EqSignature,