Struct Matrix 

pub struct Matrix<T> {
    pub data: Vec<T>,
    /* private fields */
}

Fields

data: Vec<T>

Implementations

impl<T> Matrix<T>

pub fn new<U: AsPrimitive<usize>>(rows: U, cols: U, data: Vec<T>) -> Self

Create a new matrix with the given number of rows and columns.

pub fn rows(&self) -> usize

The number of rows in the matrix.

pub fn cols(&self) -> usize

The number of columns in the matrix.

pub fn generate<F, U>(rows: U, cols: U, generator: F) -> Self

where F: Fn(usize, usize) -> T, U: AsPrimitive<usize>,

Create a new matrix using a function to generate the data.

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

Get a reference to the element at the given row and column.

pub fn put(&mut self, row: usize, col: usize, item: T) -> bool

Insert a value at the given row and column.

pub fn valid<U: Into<usize>>(&self, row: U, col: U) -> bool

Is this a valid row and column?

impl<T> Matrix<T>

where T: Clone + Copy,

pub fn fill(rows: usize, cols: usize, datum: T) -> Self

Create a new matrix with the given number of rows and columns filled with a given value.

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

Return the element at the given row and column.

pub fn insert_col(&self, n: usize, column: Vec<T>) -> Self

Insert a column at position n.

pub fn insert_row(&self, n: usize, row: Vec<T>) -> Self

Insert a row at position n.

pub fn transpose(&self) -> Self

impl<T> Matrix<T>

where T: Zero + Clone,

pub fn zeros<U: AsPrimitive<usize>>(rows: U, cols: U) -> Self

A matrix of all zeros.

impl<T> Matrix<T>

where T: One + Clone,

pub fn ones<U: AsPrimitive<usize>>(rows: U, cols: U) -> Self

A matrix of all ones.

impl<T> Matrix<T>

where T: Float,

pub fn convolve(&self, kernel: &Matrix<T>) -> Matrix<T>

Convolves the matrix with the given kernel.

Trait Implementations

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

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

Formats the value using the given formatter.

impl<T> Div<T> for &Matrix<T>

where T: Div<Output = T> + Zero + Copy,

type Output = Matrix<T>

The resulting type after applying the / operator.

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

Performs the / operation.

impl<T> Eq for Matrix<T>

where T: Eq,

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

type Output = [T]

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

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

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

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

impl<T> Mul<&Matrix<T>> for &Matrix<T>

where T: Add<Output = T> + Mul<Output = T> + Zero + Copy,

type Output = Matrix<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> Mul<&Vec<T>> for &Matrix<T>

where T: Add<Output = T> + Mul<Output = T> + Zero + Copy,

type Output = Vec<T>

The resulting type after applying the * operator.

fn mul(self, rhs: &Vec<T>) -> Self::Output

Performs the * operation.

impl<T> Mul<T> for &Matrix<T>

where T: Mul<Output = T> + Zero + Copy,

type Output = Matrix<T>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<T> PartialEq for Matrix<T>

where T: PartialEq,

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.