Struct Matrix

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

A dynamically sized matrix with entries of a type T

Data is stored column-wise, so adjacent elements of the flatmap vector are in the same column (modulo column breaks)

If T is a Ring, many more useful operations open up. When T is an abstract data type, this is pretty much only useful for storage.

Implementations

impl<T: Clone> Matrix<T>

pub fn from_flatmap(rows: usize, cols: usize, flatmap: Vec<T>) -> Matrix<T>

Constructs a matrix from a flat vector

pub fn from_index_def( rows: usize, cols: usize, at_index: &mut dyn FnMut(usize, usize) -> T, ) -> Matrix<T>

Constructs a matrix defined index-wise

pub fn is_square(&self) -> bool

Returns whether or not this is a square matrix

pub fn row_count(&self) -> usize

The amount of rows in this matrix

pub fn col_count(&self) -> usize

The amount of columns in this matrix

pub fn as_vec(&self) -> Vec<T>

Returns a copy of the underlying vector of this matrix

pub fn columns(&self) -> Vec<Matrix<T>>

Returns the columns of this matrix

pub fn is_vector(&self) -> bool

Returns true if this matrix is really just a column vector

pub fn is_row_vector(&self) -> bool

Returns whether or not this is a row vector

pub fn get(&self, r: usize, c: usize) -> T

Returns a copy of the entry at row r and column c

pub fn set(&mut self, r: usize, c: usize, x: T)

Sets the entry at row r and column c to x

pub fn append_col_ref(&mut self, col: &mut Vec<T>)

Appends a reference to a column to this matrix on the right

pub fn append_mat_right_ref(&mut self, mat: &mut Matrix<T>)

Appends a reference to a matrix to this matrix on the right

pub fn append_col(&mut self, col: Vec<T>)

Appends a column to this matrix on the right

pub fn append_mat_right(&mut self, mat: Matrix<T>)

Appends a matrix to this matrix, on the right

pub fn append_row(&mut self, row: Vec<T>)

Appends a row to this matrix on the bottom

pub fn append_mat_bottom(&mut self, mat: Matrix<T>)

Appends a matrix to this matrix, on the bottom

pub fn applying_to_all<J: Ring>(&self, f: &dyn Fn(T) -> J) -> Matrix<J>

Applies a function to all entries in this matrix, returning the result as a separate matrix

pub fn apply_to_all(&mut self, f: &dyn Fn(T) -> T)

Applies a function to all entries in this matrix, in place

pub fn transpose(&self) -> Matrix<T>

The transpose of this matrix

pub fn get_submatrix( &self, row_range: Range<usize>, col_range: Range<usize>, ) -> Matrix<T>

Accesses a sub-matrix of this matrix

pub fn set_submatrix( &mut self, row_range: Range<usize>, col_range: Range<usize>, submat: Matrix<T>, )

Writes to a sub-matrix of this matrix

impl<R: Ring> Matrix<R>

pub fn from_cols(columns: Vec<Matrix<R>>) -> Matrix<R>

Constructs a matrix with the given columns

pub fn new(rows: usize, cols: usize) -> Matrix<R>

Constructs a matrix of all zeroes for a given dimension

pub fn ones(rows: usize, cols: usize) -> Matrix<R>

Constructs a matrix of all ones

pub fn get_diagonal(&self) -> Vec<R>

Returns the diagonal of this matrix as a list

pub fn get_upperdiagonal(&self) -> Vec<R>

Returns the upper diagonal of this matrix as a list

pub fn inner_product(&self, other: &Matrix<R>) -> R

Computes the inner-product of this vector with another vector

This operates in the entries in the flatmap of each matrix, so if the argument to this function are not proper vectors (i.e., they are matrices with both dimensions greater than 1) then the behavior here is not well-defined

pub fn l2_norm_squared(&self) -> R

The squared L2 norm of this vector

pub fn hadamard(&self, other: Matrix<R>) -> Matrix<R>

Computes the point-wise product of this and another matrix of the same dimension

pub fn identity(rows: usize, cols: usize) -> Matrix<R>

Constructs the rows * cols identity matrix

pub fn from_diagonal(diagonal: Vec<R>) -> Matrix<R>

Creates a diagonal matrix from a given diagonal

pub fn from_block_diagonal(blocks: Vec<Matrix<R>>) -> Matrix<R>

Creates a block-diagonal matrix from square blocks

pub fn from_bidiagonal(diagonal: Vec<R>, superdiagonal: Vec<R>) -> Matrix<R>

Creates an upper bidiagonal matrix from a diagonal and superdiagonal

pub fn is_identity(&self) -> bool

Returns true if this matrix is the identity matrix

impl<F: Field> Matrix<F>

pub fn is_orthogonal_to(&self, other: Matrix<F>) -> bool

Returns whether or not two vectors are orthogonal

pub fn is_orthogonal(&self) -> bool

Returns whether or not a matrix is orthogonal (meaning its columns are each orthogonal and of unit length)

pub fn proj_onto(&self, other: Matrix<F>) -> Matrix<F>

Projects this vector onto another vector

pub fn gram_schmidt(&self) -> Matrix<F>

Performs Gram-Schmidt Orthogonalization on a matrix, returning a matrix whose columns are orthogonal, and span the same column space as the original matrix. This does NOT normalize the GS vectors.

impl Matrix<f64>

pub fn random_normal( rows: usize, cols: usize, mean: f64, variance: f64, ) -> Matrix<f64>

Constructs a random matrix with gaussianly distributed entries

pub fn normalize(&mut self)

Normalizes this vector

pub fn normalized(&self) -> Matrix<f64>

Returns the normalized version of this vector

pub fn angle(&self) -> f64

Returns the angle of this 2D vector with the x-axis

Trait Implementations

impl<R: Ring> Add for Matrix<R>

type Output = Matrix<R>

The resulting type after applying the + operator.

fn add(self, rhs: Matrix<R>) -> Matrix<R>

Performs the + operation.

impl<R: Ring> AddAssign for Matrix<R>

fn add_assign(&mut self, rhs: Matrix<R>)

Performs the += operation.

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

impl<F: Field> Div<F> for Matrix<F>

type Output = Matrix<F>

The resulting type after applying the / operator.

fn div(self, rhs: F) -> Matrix<F>

Performs the / operation.

impl<F: Field> DivAssign<F> for Matrix<F>

fn div_assign(&mut self, rhs: F)

Performs the /= operation.

impl<T: Clone> Index<usize> for Matrix<T>

fn index(&self, index: usize) -> &Self::Output

Returns the column index as a slice

type Output = [T]

The returned type after indexing.

impl<T: Clone> IndexMut<usize> for Matrix<T>

fn index_mut(&mut self, index: usize) -> &mut Self::Output

Returns a mutable reference to the column index

impl<R: Ring> Mul<R> for Matrix<R>

type Output = Matrix<R>

The resulting type after applying the * operator.

fn mul(self, rhs: R) -> Self::Output

Performs the * operation.

impl<R: Ring> Mul for Matrix<R>

type Output = Matrix<R>

The resulting type after applying the * operator.

fn mul(self, rhs: Matrix<R>) -> Self::Output

Performs the * operation.

impl<R: Ring> MulAssign<R> for Matrix<R>

fn mul_assign(&mut self, rhs: R)

Performs the *= operation.

impl<R: Ring> MulAssign for Matrix<R>

fn mul_assign(&mut self, rhs: Matrix<R>)

Performs in-place multiplication, only valid on square matrices

impl<T: Clone + PartialEq> PartialEq for Matrix<T>

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: Ring> Sub for Matrix<R>

type Output = Matrix<R>

The resulting type after applying the - operator.

fn sub(self, rhs: Matrix<R>) -> Matrix<R>

Performs the - operation.

impl<R: Ring> SubAssign for Matrix<R>

fn sub_assign(&mut self, rhs: Matrix<R>)

Performs the -= operation.